Class Parser

include/sonic/dom/parser.h:57–886

}

class Parser {
 public:
  explicit Parser() noexcept = default;
  // sonic_force_inline Parser(JsonInput& input) : input_(input) {}
  Parser(Parser &&other) noexcept = default;
  sonic_force_inline Parser(const Parser &other) = delete;
  sonic_force_inline Parser &operator=(const Parser &other) = delete;
  sonic_force_inline Parser &operator=(Parser &&other) noexcept = default;
  ~Parser() noexcept = default;

  template <unsigned parseFlags = kParseDefault, typename SAX>
  sonic_force_inline ParseResult Parse(char *data, size_t len, SAX &sax) {
    reset();
    json_buf_ = reinterpret_cast<uint8_t *>(data);
    len_ = len;
    parseImpl<parseFlags>(sax);
    if (!err_ && hasTrailingChars()) {
      err_ = kParseErrorInvalidChar;
    }
    return ParseResult{err_, static_cast<size_t>(pos_)};
  }

  // parseLazyImpl only mark the json positions, and not parse any more, even
  // the keys.
  template <typename LazySAX>
  sonic_force_inline ParseResult ParseLazy(const uint8_t *data, size_t len,
                                           LazySAX &sax) {
    return parseLazyImpl(data, len, sax);
  }

 private:
  sonic_force_inline bool hasTrailingChars() {
    while (pos_ < len_) {
      if (!internal::IsSpace(json_buf_[pos_])) return true;
      pos_++;
    }
    return false;
  }

  sonic_force_inline void setParseError(SonicError err) { err_ = err; }

  template <typename SAX>
  sonic_force_inline bool parseNull(SAX &sax) {
    const static uint32_t kNullBin = 0x6c6c756e;
    if (internal::EqBytes4(json_buf_ + pos_ - 1, kNullBin)) {
      pos_ += 3;
      return sax.Null();
    }
    setParseError(kParseErrorInvalidChar);
    return false;
  }

  template <typename SAX>
  sonic_force_inline bool parseFalse(SAX &sax) {
    const static uint32_t kFalseBin =
        0x65736c61;  // the binary of 'alse' in false
    if (internal::EqBytes4(json_buf_ + pos_, kFalseBin)) {
      pos_ += 4;