parser.h

#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(const std::string &path) & noexcept;
  inline simdjson_result<element> load(const std::string &path) &&  = delete ;
 
  inline simdjson_result<element> load_into_document(document& doc, const std::string &path) & noexcept;
  inline simdjson_result<element> load_into_document(document& doc, const std::string &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_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(const std::string &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) = 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) = delete;// unsafe
 
  simdjson_result<document_stream> parse_many(const char *buf, size_t batch_size = dom::DEFAULT_BATCH_SIZE) noexcept = delete;
 
  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_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};
#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;
 
 
private:
  size_t _max_capacity;
 
  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(const std::string &path) noexcept;
 
  friend class parser::Iterator;
  friend class document_stream;
 
 
}; // class parser
 
} // namespace dom
} // namespace simdjson
 
#endif // SIMDJSON_DOM_PARSER_H