simdjson/dom_2parser_8h_source.html

#ifndef SIMDJSON_DOM_PARSER_H

#define SIMDJSON_DOM_PARSER_H


#include "simdjson/dom/base.h"

#include "simdjson/dom/document.h"


namespace simdjson {


namespace dom {


class parser {

public:

  simdjson_inline explicit parser(size_t max_capacity = SIMDJSON_MAXSIZE_BYTES) noexcept;

  simdjson_inline parser(parser &&other) noexcept;

  parser(const parser &) = delete;

  simdjson_inline parser &operator=(parser &&other) noexcept;

  parser &operator=(const parser &) = delete;


  ~parser()=default;


  inline simdjson_result<element> load(std::string_view path) & noexcept;

  inline simdjson_result<element> load(std::string_view path) &&  = delete ;


  inline simdjson_result<element> load_into_document(document& doc, std::string_view path) & noexcept;

  inline simdjson_result<element> load_into_document(document& doc, std::string_view path) && =delete;


  inline simdjson_result<element> parse(const uint8_t *buf, size_t len, bool realloc_if_needed = true) & noexcept;

  inline simdjson_result<element> parse(const uint8_t *buf, size_t len, bool realloc_if_needed = true) && =delete;

  simdjson_inline simdjson_result<element> parse(const char *buf, size_t len, bool realloc_if_needed = true) & noexcept;

  simdjson_inline simdjson_result<element> parse(const char *buf, size_t len, bool realloc_if_needed = true) && =delete;

  simdjson_inline simdjson_result<element> parse(const std::string &s) & noexcept;

  simdjson_inline simdjson_result<element> parse(const std::string &s) && =delete;

  simdjson_inline simdjson_result<element> parse(const padded_string &s) & noexcept;

  simdjson_inline simdjson_result<element> parse(const padded_string &s) && =delete;

  simdjson_inline simdjson_result<element> parse(const padded_string_view &v) & noexcept;

  simdjson_inline simdjson_result<element> parse(const padded_string_view &v) && =delete;


  simdjson_inline simdjson_result<element> parse(const char *buf) noexcept = delete;


  inline simdjson_result<element> parse_unpadded(const uint8_t *buf, size_t len) & noexcept;

  inline simdjson_result<element> parse_unpadded(const uint8_t *buf, size_t len) && =delete;

  simdjson_inline simdjson_result<element> parse_unpadded(const char *buf, size_t len) & noexcept;

  simdjson_inline simdjson_result<element> parse_unpadded(const char *buf, size_t len) && =delete;

  simdjson_inline simdjson_result<element> parse_unpadded(std::string_view s) & noexcept;

  simdjson_inline simdjson_result<element> parse_unpadded(std::string_view s) && =delete;


  inline simdjson_result<element> parse_into_document_unpadded(document& doc, const uint8_t *buf, size_t len) & noexcept;

  inline simdjson_result<element> parse_into_document_unpadded(document& doc, const uint8_t *buf, size_t len) && =delete;


  inline simdjson_result<element> parse_into_document(document& doc, const uint8_t *buf, size_t len, bool realloc_if_needed = true) & noexcept;

  inline simdjson_result<element> parse_into_document(document& doc, const uint8_t *buf, size_t len, bool realloc_if_needed = true) && =delete;

  simdjson_inline simdjson_result<element> parse_into_document(document& doc, const char *buf, size_t len, bool realloc_if_needed = true) & noexcept;

  simdjson_inline simdjson_result<element> parse_into_document(document& doc, const char *buf, size_t len, bool realloc_if_needed = true) && =delete;

  simdjson_inline simdjson_result<element> parse_into_document(document& doc, const std::string &s) & noexcept;

  simdjson_inline simdjson_result<element> parse_into_document(document& doc, const std::string &s) && =delete;

  simdjson_inline simdjson_result<element> parse_into_document(document& doc, const padded_string &s) & noexcept;

  simdjson_inline simdjson_result<element> parse_into_document(document& doc, const padded_string &s) && =delete;


  simdjson_inline simdjson_result<element> parse_into_document(document& doc, const char *buf) noexcept = delete;


  inline simdjson_result<document_stream> load_many(std::string_view path, size_t batch_size = dom::DEFAULT_BATCH_SIZE) noexcept;


  inline simdjson_result<document_stream> parse_many(const uint8_t *buf, size_t len, size_t batch_size = dom::DEFAULT_BATCH_SIZE) noexcept;

  inline simdjson_result<document_stream> parse_many(const char *buf, size_t len, size_t batch_size = dom::DEFAULT_BATCH_SIZE) noexcept;

  inline simdjson_result<document_stream> parse_many(const std::string &s, size_t batch_size = dom::DEFAULT_BATCH_SIZE) noexcept;

  inline simdjson_result<document_stream> parse_many(const std::string &&s, size_t batch_size = dom::DEFAULT_BATCH_SIZE) = delete;// unsafe

  inline simdjson_result<document_stream> parse_many(const padded_string &s, size_t batch_size = dom::DEFAULT_BATCH_SIZE) noexcept;

  inline simdjson_result<document_stream> parse_many(const padded_string &&s, size_t batch_size = dom::DEFAULT_BATCH_SIZE) = delete;// unsafe

  inline simdjson_result<document_stream> parse_many(const padded_string_view &v, size_t batch_size = dom::DEFAULT_BATCH_SIZE) noexcept;


  simdjson_result<document_stream> parse_many(const char *buf, size_t batch_size = dom::DEFAULT_BATCH_SIZE) noexcept = delete;


  inline simdjson_result<document_stream> parse_many(const uint8_t *buf, size_t len, size_t batch_size, stream_format format) noexcept;

  inline simdjson_result<document_stream> parse_many(const char *buf, size_t len, size_t batch_size, stream_format format) noexcept;

  inline simdjson_result<document_stream> parse_many(const std::string &s, size_t batch_size, stream_format format) noexcept;

  inline simdjson_result<document_stream> parse_many(const padded_string &s, size_t batch_size, stream_format format) noexcept;

  inline simdjson_result<document_stream> parse_many(const padded_string_view &v, size_t batch_size, stream_format format) noexcept;

  inline simdjson_result<document_stream> parse_many(const std::string &&s, size_t batch_size, stream_format format) = delete;// unsafe

  inline simdjson_result<document_stream> parse_many(const padded_string &&s, size_t batch_size, stream_format format) = delete;// unsafe


  simdjson_warn_unused inline error_code allocate(size_t capacity, size_t max_depth = DEFAULT_MAX_DEPTH) noexcept;


#ifndef SIMDJSON_DISABLE_DEPRECATED_API

  [[deprecated("Use allocate() instead.")]]

  simdjson_warn_unused inline bool allocate_capacity(size_t capacity, size_t max_depth = DEFAULT_MAX_DEPTH) noexcept;

#endif // SIMDJSON_DISABLE_DEPRECATED_API

  simdjson_inline size_t capacity() const noexcept;


  simdjson_inline size_t max_capacity() const noexcept;


  simdjson_pure simdjson_inline size_t max_depth() const noexcept;


  simdjson_inline void set_max_capacity(size_t max_capacity) noexcept;


#ifdef SIMDJSON_THREADS_ENABLED

  bool threaded{true};

#else

  bool threaded{false};

#endif

  class Iterator;

  using InvalidJSON [[deprecated("Use simdjson_error instead")]] = simdjson_error;


  std::unique_ptr<internal::dom_parser_implementation> implementation{};


  bool valid{false};

  error_code error{UNINITIALIZED};


  document doc{};


  [[deprecated("Use the result of parser.parse() instead")]]

  inline bool is_valid() const noexcept;


  [[deprecated("Use the result of parser.parse() instead")]]

  inline int get_error_code() const noexcept;


  [[deprecated("Use error_message() on the result of parser.parse() instead, or cout << error")]]

  inline std::string get_error_message() const noexcept;


  [[deprecated("Use cout << on the result of parser.parse() instead")]]

  inline bool print_json(std::ostream &os) const noexcept;


  inline bool dump_raw_tape(std::ostream &os) const noexcept;


  inline void number_as_string(bool enabled) noexcept { _number_as_string = enabled; }

  inline bool number_as_string() const noexcept { return _number_as_string; }


private:

  size_t _max_capacity;


  bool _number_as_string{false};


  std::unique_ptr<char[]> loaded_bytes;


  size_t _loaded_bytes_capacity{0};


  // all nodes are stored on the doc.tape using a 64-bit word.

  //

  // strings, double and ints are stored as

  //  a 64-bit word with a pointer to the actual value

  //

  //

  //

  // for objects or arrays, store [ or {  at the beginning and } and ] at the

  // end. For the openings ([ or {), we annotate them with a reference to the

  // location on the doc.tape of the end, and for then closings (} and ]), we

  // annotate them with a reference to the location of the opening

  //

  //


  inline error_code ensure_capacity(size_t desired_capacity) noexcept;

  inline error_code ensure_capacity(document& doc, size_t desired_capacity) noexcept;


  inline simdjson_result<size_t> read_file(std::string_view path) noexcept;


  friend class parser::Iterator;

  friend class document_stream;


}; // class parser


} // namespace dom

} // namespace simdjson


#endif // SIMDJSON_DOM_PARSER_H

simdjson::dom::document
A parsed JSON document.
Definition document.h:16

simdjson::dom::parser
A persistent document parser.
Definition parser.h:30

simdjson::dom::parser::parse
simdjson_result< element > parse(const uint8_t *buf, size_t len, bool realloc_if_needed=true) &noexcept
Parse a JSON document and return a temporary reference to it.
Definition parser-inl.h:178

simdjson::dom::parser::parse_into_document
simdjson_result< element > parse_into_document(document &doc, const uint8_t *buf, size_t len, bool realloc_if_needed=true) &noexcept
Parse a JSON document into a provide document instance and return a temporary reference to it.
Definition parser-inl.h:114

simdjson::dom::parser::parser
simdjson_inline parser(parser &&other) noexcept
Take another parser's buffers and state.

simdjson::dom::parser::threaded
bool threaded
When SIMDJSON_THREADS_ENABLED is not defined, the parser instance cannot use threads.
Definition parser.h:666

simdjson::dom::parser::set_max_capacity
simdjson_inline void set_max_capacity(size_t max_capacity) noexcept
Set max_capacity.
Definition parser-inl.h:319

simdjson::dom::parser::parse_unpadded
simdjson_result< element > parse_unpadded(const uint8_t *buf, size_t len) &noexcept
Parse a JSON document whose buffer is not padded, in place and without copying it.
Definition parser-inl.h:195

simdjson::dom::parser::parse_into_document_unpadded
simdjson_result< element > parse_into_document_unpadded(document &doc, const uint8_t *buf, size_t len) &noexcept
Parse a non-padded JSON document into a caller-provided document instance, in place and without copyi...
Definition parser-inl.h:144

simdjson::dom::parser::max_capacity
simdjson_inline size_t max_capacity() const noexcept
The largest document this parser can automatically support.
Definition parser-inl.h:263

simdjson::dom::parser::load_many
simdjson_result< document_stream > load_many(std::string_view path, size_t batch_size=dom::DEFAULT_BATCH_SIZE) noexcept
Load a file containing many JSON documents.
Definition parser-inl.h:106

simdjson::dom::parser::load_into_document
simdjson_result< element > load_into_document(document &doc, std::string_view path) &noexcept
Load a JSON document from a file into a provide document instance and return a temporary reference to...
Definition parser-inl.h:99

simdjson::dom::parser::max_depth
simdjson_pure simdjson_inline size_t max_depth() const noexcept
The maximum level of nested object and arrays supported by this parser.
Definition parser-inl.h:266

simdjson::dom::parser::load
simdjson_result< element > load(std::string_view path) &noexcept
Load a JSON document from a file and return a reference to it.
Definition parser-inl.h:95

simdjson::dom::parser::~parser
~parser()=default
Deallocate the JSON parser.

simdjson::dom::parser::capacity
simdjson_inline size_t capacity() const noexcept
The largest document this parser can support without reallocating.
Definition parser-inl.h:260

simdjson::dom::parser::operator=
simdjson_inline parser & operator=(parser &&other) noexcept
Take another parser's buffers and state.

simdjson::dom::parser::allocate
simdjson_warn_unused error_code allocate(size_t capacity, size_t max_depth=DEFAULT_MAX_DEPTH) noexcept
Ensure this parser has enough memory to process JSON documents up to capacity bytes in length and max...
Definition parser-inl.h:271

simdjson::dom::parser::parse_many
simdjson_result< document_stream > parse_many(const uint8_t *buf, size_t len, size_t batch_size=dom::DEFAULT_BATCH_SIZE) noexcept
Parse a buffer containing many JSON documents.
Definition parser-inl.h:205

simdjson::implementation
An implementation of simdjson for a particular CPU architecture.
Definition implementation.h:45

simdjson::padded_string_view
User-provided string that promises it has extra padded bytes at the end for use with parser::parse().
Definition padded_string_view.h:21

simdjson
The top level simdjson namespace, containing everything the library provides.
Definition base.h:8

simdjson::stream_format
stream_format
Stream format for parse_many/iterate_many.
Definition base.h:61

simdjson::error_message
const char * error_message(error_code error) noexcept
It is the convention throughout the code that the macro SIMDJSON_DEVELOPMENT_CHECKS determines whethe...
Definition error-inl.h:25

simdjson::DEFAULT_MAX_DEPTH
constexpr size_t DEFAULT_MAX_DEPTH
By default, simdjson supports this many nested objects and arrays.
Definition base.h:49

simdjson::error_code
error_code
All possible errors returned by simdjson.
Definition error.h:19

simdjson::UNINITIALIZED
@ UNINITIALIZED
unknown error, or uninitialized document
Definition error.h:32

simdjson::SIMDJSON_MAXSIZE_BYTES
SIMDJSON_PUSH_DISABLE_UNUSED_WARNINGS constexpr size_t SIMDJSON_MAXSIZE_BYTES
The maximum document size supported by simdjson.
Definition base.h:28

simdjson::padded_string
String with extra allocation for ease of use with parser::parse()
Definition padded_string.h:23

simdjson::simdjson_error
Exception thrown when an exception-supporting simdjson method is called.
Definition error.h:92

simdjson::simdjson_result
The result of a simdjson operation that could fail.
Definition error.h:281