/* auto-generated on Fri Mar 20 11:47:31 PDT 2020. Do not edit! */

/* begin file include/simdjson.h */

#ifndef SIMDJSON_H

#define SIMDJSON_H

/* begin file include/simdjson/compiler_check.h */

#ifndef SIMDJSON_COMPILER_CHECK_H

#define SIMDJSON_COMPILER_CHECK_H

#ifndef __cplusplus

#error simdjson requires a C++ compiler

#endif

#ifndef SIMDJSON_CPLUSPLUS

#if defined(_MSVC_LANG) && !defined(__clang__)

#define SIMDJSON_CPLUSPLUS (_MSC_VER == 1900 ? 201103L : _MSVC_LANG)

#else

#define SIMDJSON_CPLUSPLUS __cplusplus

#endif

#endif

#if (SIMDJSON_CPLUSPLUS < 201703L)

#error simdjson requires a compiler compliant with the C++17 standard

#endif

#endif // SIMDJSON_COMPILER_CHECK_H

/* end file include/simdjson/compiler_check.h */

// Public API

/* begin file include/simdjson/simdjson_version.h */

// /include/simdjson/simdjson_version.h automatically generated by release.py,

// do not change by hand

#ifndef SIMDJSON_SIMDJSON_VERSION_H

#define SIMDJSON_SIMDJSON_VERSION_H

/** The version of simdjson being used (major.minor.revision) */

#define SIMDJSON_VERSION 0.2.1

namespace simdjson {

enum {

/**

* The major version (MAJOR.minor.revision) of simdjson being used.

*/

SIMDJSON_VERSION_MAJOR = 0,

/**

* The minor version (major.MINOR.revision) of simdjson being used.

*/

SIMDJSON_VERSION_MINOR = 2,

/**

* The revision (major.minor.REVISION) of simdjson being used.

*/

SIMDJSON_VERSION_REVISION = 1

};

} // namespace simdjson

#endif // SIMDJSON_SIMDJSON_VERSION_H

/* end file include/simdjson/simdjson_version.h */

/* begin file include/simdjson/error.h */

#ifndef SIMDJSON_ERROR_H

#define SIMDJSON_ERROR_H

/* begin file include/simdjson/common_defs.h */

#ifndef SIMDJSON_COMMON_DEFS_H

#define SIMDJSON_COMMON_DEFS_H

#include <cassert>

/* begin file include/simdjson/portability.h */

#ifndef SIMDJSON_PORTABILITY_H

#define SIMDJSON_PORTABILITY_H

#include <cstddef>

#include <cstdint>

#include <cstdlib>

#ifdef _MSC_VER

#include <iso646.h>

#endif

#if defined(__x86_64__) || defined(_M_AMD64)

#define IS_X86_64 1

#endif

#if defined(__aarch64__) || defined(_M_ARM64)

#define IS_ARM64 1

#endif

// this is almost standard?

#undef STRINGIFY_IMPLEMENTATION_

#undef STRINGIFY

#define STRINGIFY_IMPLEMENTATION_(a) #a

#define STRINGIFY(a) STRINGIFY_IMPLEMENTATION_(a)

#ifndef SIMDJSON_IMPLEMENTATION_FALLBACK

#define SIMDJSON_IMPLEMENTATION_FALLBACK 1

#endif

#if IS_ARM64

#ifndef SIMDJSON_IMPLEMENTATION_ARM64

#define SIMDJSON_IMPLEMENTATION_ARM64 1

#endif

#define SIMDJSON_IMPLEMENTATION_HASWELL 0

#define SIMDJSON_IMPLEMENTATION_WESTMERE 0

#endif // IS_ARM64

#if IS_X86_64

#ifndef SIMDJSON_IMPLEMENTATION_HASWELL

#define SIMDJSON_IMPLEMENTATION_HASWELL 1

#endif

#ifndef SIMDJSON_IMPLEMENTATION_WESTMERE

#define SIMDJSON_IMPLEMENTATION_WESTMERE 1

#endif

#define SIMDJSON_IMPLEMENTATION_ARM64 0

#endif // IS_X86_64

// we are going to use runtime dispatch

#ifdef IS_X86_64

#ifdef __clang__

// clang does not have GCC push pop

// warning: clang attribute push can't be used within a namespace in clang up

// til 8.0 so TARGET_REGION and UNTARGET_REGION must be *outside* of a

// namespace.

#define TARGET_REGION(T) \

_Pragma(STRINGIFY( \

clang attribute push(__attribute__((target(T))), apply_to = function)))

#define UNTARGET_REGION _Pragma("clang attribute pop")

#elif defined(__GNUC__)

// GCC is easier

#define TARGET_REGION(T) \

_Pragma("GCC push_options") _Pragma(STRINGIFY(GCC target(T)))

#define UNTARGET_REGION _Pragma("GCC pop_options")

#endif // clang then gcc

#endif // x86

// Default target region macros don't do anything.

#ifndef TARGET_REGION

#define TARGET_REGION(T)

#define UNTARGET_REGION

#endif

// under GCC and CLANG, we use these two macros

#define TARGET_HASWELL TARGET_REGION("avx2,bmi,pclmul,lzcnt")

#define TARGET_WESTMERE TARGET_REGION("sse4.2,pclmul")

#define TARGET_ARM64

// Threading is disabled

#undef SIMDJSON_THREADS_ENABLED

// Is threading enabled?

#if defined(BOOST_HAS_THREADS) || defined(_REENTRANT) || defined(_MT)

#define SIMDJSON_THREADS_ENABLED

#endif

#if defined(__clang__)

#define NO_SANITIZE_UNDEFINED __attribute__((no_sanitize("undefined")))

#elif defined(__GNUC__)

#define NO_SANITIZE_UNDEFINED __attribute__((no_sanitize_undefined))

#else

#define NO_SANITIZE_UNDEFINED

#endif

#ifdef _MSC_VER

#include <intrin.h> // visual studio

#endif

#ifdef _MSC_VER

#define simdjson_strcasecmp _stricmp

#else

#define simdjson_strcasecmp strcasecmp

#endif

namespace simdjson {

// portable version of posix_memalign

static inline void *aligned_malloc(size_t alignment, size_t size) {

void *p;

#ifdef _MSC_VER

p = _aligned_malloc(size, alignment);

#elif defined(__MINGW32__) || defined(__MINGW64__)

p = __mingw_aligned_malloc(size, alignment);

#else

// somehow, if this is used before including "x86intrin.h", it creates an

// implicit defined warning.

if (posix_memalign(&p, alignment, size) != 0) {

return nullptr;

}

#endif

return p;

}

static inline char *aligned_malloc_char(size_t alignment, size_t size) {

return (char *)aligned_malloc(alignment, size);

}

static inline void aligned_free(void *mem_block) {

if (mem_block == nullptr) {

return;

}

#ifdef _MSC_VER

_aligned_free(mem_block);

#elif defined(__MINGW32__) || defined(__MINGW64__)

__mingw_aligned_free(mem_block);

#else

free(mem_block);

#endif

}

static inline void aligned_free_char(char *mem_block) {

aligned_free((void *)mem_block);

}

} // namespace simdjson

#endif // SIMDJSON_PORTABILITY_H

/* end file include/simdjson/portability.h */

namespace simdjson {

#ifndef SIMDJSON_EXCEPTIONS

#if __cpp_exceptions

#define SIMDJSON_EXCEPTIONS 1

#else

#define SIMDJSON_EXCEPTIONS 0

#endif

#endif

/** The maximum document size supported by simdjson. */

constexpr size_t SIMDJSON_MAXSIZE_BYTES = 0xFFFFFFFF;

/**

* The amount of padding needed in a buffer to parse JSON.

*

* the input buf should be readable up to buf + SIMDJSON_PADDING

* this is a stopgap; there should be a better description of the

* main loop and its behavior that abstracts over this

* See https://github.com/lemire/simdjson/issues/174

*/

constexpr size_t SIMDJSON_PADDING = 32;

/**

* By default, simdjson supports this many nested objects and arrays.

*

* This is the default for document::parser::max_depth().

*/

constexpr size_t DEFAULT_MAX_DEPTH = 1024;

} // namespace simdjson

#if defined(__GNUC__)

// Marks a block with a name so that MCA analysis can see it.

#define BEGIN_DEBUG_BLOCK(name) __asm volatile("# LLVM-MCA-BEGIN " #name);

#define END_DEBUG_BLOCK(name) __asm volatile("# LLVM-MCA-END " #name);

#define DEBUG_BLOCK(name, block) BEGIN_DEBUG_BLOCK(name); block; END_DEBUG_BLOCK(name);

#else

#define BEGIN_DEBUG_BLOCK(name)

#define END_DEBUG_BLOCK(name)

#define DEBUG_BLOCK(name, block)

#endif

#if !defined(_MSC_VER) && !defined(SIMDJSON_NO_COMPUTED_GOTO)

// Implemented using Labels as Values which works in GCC and CLANG (and maybe

// also in Intel's compiler), but won't work in MSVC.

#define SIMDJSON_USE_COMPUTED_GOTO

#endif

// Align to N-byte boundary

#define ROUNDUP_N(a, n) (((a) + ((n)-1)) & ~((n)-1))

#define ROUNDDOWN_N(a, n) ((a) & ~((n)-1))

#define ISALIGNED_N(ptr, n) (((uintptr_t)(ptr) & ((n)-1)) == 0)

#ifdef _MSC_VER

#define really_inline __forceinline

#define never_inline __declspec(noinline)

#define UNUSED

#define WARN_UNUSED

#ifndef likely

#define likely(x) x

#endif

#ifndef unlikely

#define unlikely(x) x

#endif

#else

#define really_inline inline __attribute__((always_inline, unused))

#define never_inline inline __attribute__((noinline, unused))

#define UNUSED __attribute__((unused))

#define WARN_UNUSED __attribute__((warn_unused_result))

#ifndef likely

#define likely(x) __builtin_expect(!!(x), 1)

#endif

#ifndef unlikely

#define unlikely(x) __builtin_expect(!!(x), 0)

#endif

#endif // MSC_VER

#endif // SIMDJSON_COMMON_DEFS_H

/* end file include/simdjson/portability.h */

#include <string>

#include <utility>

namespace simdjson {

/**

* All possible errors returned by simdjson.

*/

enum error_code {

SUCCESS = 0, ///< No error

SUCCESS_AND_HAS_MORE, ///< No error and buffer still has more data

CAPACITY, ///< This parser can't support a document that big

MEMALLOC, ///< Error allocating memory, most likely out of memory

TAPE_ERROR, ///< Something went wrong while writing to the tape (stage 2), this is a generic error

DEPTH_ERROR, ///< Your document exceeds the user-specified depth limitation

STRING_ERROR, ///< Problem while parsing a string

T_ATOM_ERROR, ///< Problem while parsing an atom starting with the letter 't'

F_ATOM_ERROR, ///< Problem while parsing an atom starting with the letter 'f'

N_ATOM_ERROR, ///< Problem while parsing an atom starting with the letter 'n'

NUMBER_ERROR, ///< Problem while parsing a number

UTF8_ERROR, ///< the input is not valid UTF-8

UNINITIALIZED, ///< unknown error, or uninitialized document

EMPTY, ///< no structural element found

UNESCAPED_CHARS, ///< found unescaped characters in a string.

UNCLOSED_STRING, ///< missing quote at the end

UNSUPPORTED_ARCHITECTURE, ///< unsupported architecture

INCORRECT_TYPE, ///< JSON element has a different type than user expected

NUMBER_OUT_OF_RANGE, ///< JSON number does not fit in 64 bits

NO_SUCH_FIELD, ///< JSON field not found in object

IO_ERROR, ///< Error reading a file

UNEXPECTED_ERROR, ///< indicative of a bug in simdjson

/** @private Number of error codes */

NUM_ERROR_CODES

};

/**

* Get the error message for the given error code.

*

* auto [doc, error] = document::parse("foo");

* if (error) { printf("Error: %s\n", error_message(error)); }

*

* @return The error message.

*/

inline const char *error_message(error_code error) noexcept;

/**

* Write the error message to the output stream

*/

inline std::ostream& operator<<(std::ostream& out, error_code error) noexcept;

/**

* Exception thrown when an exception-supporting simdjson method is called

*/

struct simdjson_error : public std::exception {

/**

* Create an exception from a simdjson error code.

* @param error The error code

*/

simdjson_error(error_code error) noexcept : _error{error} { }

/** The error message */

const char *what() const noexcept { return error_message(error()); }

/** The error code */

error_code error() const noexcept { return _error; }

private:

/** The error code that was used */

error_code _error;

};

/**

* The result of a simd operation that could fail.

*

* Gives the option of reading error codes, or throwing an exception by casting to the desired result.

*/

template<typename T>

struct simdjson_result : public std::pair<T, error_code> {

/**

* The error.

*/

error_code error() const { return this->second; }

#if SIMDJSON_EXCEPTIONS

/**

* The value of the function.

*

* @throw simdjson_error if there was an error.

*/

T get() noexcept(false) {

if (error()) { throw simdjson_error(error()); }

return this->first;

};

/**

* Cast to the value (will throw on error).

*

* @throw simdjson_error if there was an error.

*/

operator T() noexcept(false) { return get(); }

#endif // SIMDJSON_EXCEPTIONS

/**

* Create a new error result.

*/

simdjson_result(error_code _error) noexcept : std::pair<T, error_code>({}, _error) {}

/**

* Create a new successful result.

*/

simdjson_result(T _value) noexcept : std::pair<T, error_code>(_value, SUCCESS) {}

/**

* Create a new result with both things (use if you don't want to branch when creating the result).

*/

simdjson_result(T value, error_code error) noexcept : std::pair<T, error_code>(value, error) {}

};

/**

* The result of a simd operation that could fail.

*

* This class is for values that must be *moved*, like padded_string and document.

*

* Gives the option of reading error codes, or throwing an exception by casting to the desired result.

*/

template<typename T>

struct simdjson_move_result : std::pair<T, error_code> {

/**

* Move the value and the error to the provided variables.

*/

void tie(T& t, error_code & e) {

// on the clang compiler that comes with current macOS (Apple clang version 11.0.0),

// std::tie(this->json, error) = padded_string::load(filename);

// fails with "benchmark/benchmarker.h:266:33: error: no viable overloaded '='""

t = std::move(this->first);

e = std::move(this->second);

}

/**

* The error.

*/

error_code error() const { return this->second; }

#if SIMDJSON_EXCEPTIONS

/**

* The value of the function.

*

* @throw simdjson_error if there was an error.

*/

T move() noexcept(false) {

if (error()) { throw simdjson_error(error()); }

return std::move(this->first);

};

/**

* Cast to the value (will throw on error).

*

* @throw simdjson_error if there was an error.

*/

operator T() noexcept(false) { return move(); }

#endif

/**

* Create a new error result.

*/

simdjson_move_result(error_code error) noexcept : std::pair<T, error_code>(T(), error) {}

/**

* Create a new successful result.

*/

simdjson_move_result(T value) noexcept : std::pair<T, error_code>(std::move(value), SUCCESS) {}

/**

* Create a new result with both things (use if you don't want to branch when creating the result).

*/

simdjson_move_result(T value, error_code error) noexcept : std::pair<T, error_code>(std::move(value), error) {}

};

/**

* @deprecated This is an alias and will be removed, use error_code instead

*/

using ErrorValues = error_code;

/**

* @deprecated Error codes should be stored and returned as `error_code`, use `error_message()` instead.

*/

inline const std::string &error_message(int error) noexcept;

} // namespace simdjson

#endif // SIMDJSON_ERROR_H

/* end file include/simdjson/portability.h */

/* begin file include/simdjson/padded_string.h */

#ifndef SIMDJSON_PADDED_STRING_H

#define SIMDJSON_PADDED_STRING_H

#include <cstring>

#include <memory>

#include <string>

namespace simdjson {

/**

* String with extra allocation for ease of use with document::parser::parse()

*

* This is a move-only class, it cannot be copied.

*/

struct padded_string final {

/**

* Create a new, empty padded string.

*/

explicit inline padded_string() noexcept;

/**

* Create a new padded string buffer.

*

* @param length the size of the string.

*/

explicit inline padded_string(size_t length) noexcept;

/**

* Create a new padded string by copying the given input.

*

* @param data the buffer to copy

* @param length the number of bytes to copy

*/

explicit inline padded_string(const char *data, size_t length) noexcept;

/**

* Create a new padded string by copying the given input.

*

* @param str_ the string to copy

*/

inline padded_string(const std::string & str_ ) noexcept;

/**

* Create a new padded string by copying the given input.

*

* @param str_ the string to copy

*/

inline padded_string(std::string_view sv_) noexcept;

/**

* Move one padded string into another.

*

* The original padded string will be reduced to zero capacity.

*

* @param o the string to move.

*/

inline padded_string(padded_string &&o) noexcept;

/**

* Move one padded string into another.

*

* The original padded string will be reduced to zero capacity.

*

* @param o the string to move.

*/

inline padded_string &operator=(padded_string &&o) noexcept;

inline void swap(padded_string &o) noexcept;

~padded_string() noexcept;

/**

* The length of the string.

*

* Does not include padding.

*/

size_t size() const noexcept;

/**

* The length of the string.

*

* Does not include padding.

*/

size_t length() const noexcept;

/**

* The string data.

**/

const char *data() const noexcept;

/**

* The string data.

**/

char *data() noexcept;

/**

* Load this padded string from a file.

*

* @param path the path to the file.

**/

inline static simdjson_move_result<padded_string> load(const std::string &path) noexcept;

private:

padded_string &operator=(const padded_string &o) = delete;

padded_string(const padded_string &o) = delete;

size_t viable_size;

char *data_ptr{nullptr};

}; // padded_string

} // namespace simdjson

namespace simdjson::internal {

// low-level function to allocate memory with padding so we can read past the

// "length" bytes safely. if you must provide a pointer to some data, create it

// with this function: length is the max. size in bytes of the string caller is

// responsible to free the memory (free(...))

inline char *allocate_padded_buffer(size_t length) noexcept;

} // namespace simdjson::internal;

#endif // SIMDJSON_PADDED_STRING_H

/* end file include/simdjson/padded_string.h */

/* begin file include/simdjson/implementation.h */

#ifndef SIMDJSON_IMPLEMENTATION_H

#define SIMDJSON_IMPLEMENTATION_H

#include <optional>

#include <string>

#include <atomic>

#include <vector>

/* begin file include/simdjson/document.h */

#ifndef SIMDJSON_DOCUMENT_H

#define SIMDJSON_DOCUMENT_H

#include <cstring>

#include <memory>

#include <string>

#include <limits>

#include <sstream>

/* begin file include/simdjson/simdjson.h */

/**

* @file

* @deprecated We'll be removing this file so it isn't confused with the top level simdjson.h

*/

#ifndef SIMDJSON_SIMDJSON_H

#define SIMDJSON_SIMDJSON_H

#endif // SIMDJSON_H

/* end file include/simdjson/simdjson.h */

namespace simdjson::internal {

constexpr const uint64_t JSON_VALUE_MASK = 0x00FFFFFFFFFFFFFF;

enum class tape_type;

class tape_ref;

} // namespace simdjson::internal

namespace simdjson {

template<size_t max_depth> class document_iterator;

/**

* A parsed JSON document.

*

* This class cannot be copied, only moved, to avoid unintended allocations.

*/

class document {

public:

/**

* Create a document container with zero capacity.

*

* The parser will allocate capacity as needed.

*/

document() noexcept=default;

~document() noexcept=default;

/**

* Take another document's buffers.

*

* @param other The document to take. Its capacity is zeroed and it is invalidated.

*/

document(document &&other) noexcept = default;

document(const document &) = delete; // Disallow copying

/**

* Take another document's buffers.

*

* @param other The document to take. Its capacity is zeroed.

*/

document &operator=(document &&other) noexcept = default;

document &operator=(const document &) = delete; // Disallow copying

/** The default batch size for parse_many and load_many */

static constexpr size_t DEFAULT_BATCH_SIZE = 1000000;

// Nested classes

class element;

class array;

class object;

class key_value_pair;

class parser;

class stream;

class doc_move_result;

class doc_result;

class element_result;

class array_result;

class object_result;

class stream_result;

// Nested classes. See definitions later in file.

using iterator = document_iterator<DEFAULT_MAX_DEPTH>;

/**

* Get the root element of this document as a JSON array.

*/

element root() const noexcept;

/**

* Get the root element of this document as a JSON array.

*/

array_result as_array() const noexcept;

/**

* Get the root element of this document as a JSON object.

*/

object_result as_object() const noexcept;

/**

* Get the root element of this document.

*/

operator element() const noexcept;

#if SIMDJSON_EXCEPTIONS

/**

* Read the root element of this document as a JSON array.

*

* @return The JSON array.

* @exception simdjson_error(UNEXPECTED_TYPE) if the JSON element is not an array

*/

operator array() const noexcept(false);

/**

* Read this element as a JSON object (key/value pairs).

*

* @return The JSON object.

* @exception simdjson_error(UNEXPECTED_TYPE) if the JSON element is not an object

*/

operator object() const noexcept(false);

#endif // SIMDJSON_EXCEPTIONS

/**

* Get the value associated with the given key.

*

* The key will be matched against **unescaped** JSON:

*

* document::parse(R"({ "a\n": 1 })")["a\n"].as_uint64_t().value == 1

* document::parse(R"({ "a\n": 1 })")["a\\n"].as_uint64_t().error == NO_SUCH_FIELD

*

* @return The value associated with the given key, or:

* - NO_SUCH_FIELD if the field does not exist in the object

* - UNEXPECTED_TYPE if the document is not an object

*/

element_result operator[](const std::string_view &s) const noexcept;

/**

* Get the value associated with the given key.

*

* The key will be matched against **unescaped** JSON:

*

* document::parse(R"({ "a\n": 1 })")["a\n"].as_uint64_t().value == 1

* document::parse(R"({ "a\n": 1 })")["a\\n"].as_uint64_t().error == NO_SUCH_FIELD

*

* @return The value associated with this field, or:

* - NO_SUCH_FIELD if the field does not exist in the object

* - UNEXPECTED_TYPE if the document is not an object

*/

element_result operator[](const char *s) const noexcept;

/**

* Dump the raw tape for debugging.

*

* @param os the stream to output to.

* @return false if the tape is likely wrong (e.g., you did not parse a valid JSON).

*/

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

/**

* Load a JSON document from a file and return it.

*

* document doc = document::load("jsonexamples/twitter.json");

*

* ### Parser Capacity

*

* If the parser's current capacity is less than the file length, it will allocate enough capacity

* to handle it (up to max_capacity).

*

* @param path The path to load.

* @return The document, or an error:

* - IO_ERROR if there was an error opening or reading the file.

* - MEMALLOC if the parser does not have enough capacity and memory allocation fails.

* - CAPACITY if the parser does not have enough capacity and len > max_capacity.

* - other json errors if parsing fails.

*/

inline static doc_move_result load(const std::string& path) noexcept;

/**

* Parse a JSON document and return a reference to it.

*

* The buffer must have at least SIMDJSON_PADDING extra allocated bytes. It does not matter what

* those bytes are initialized to, as long as they are allocated. If realloc_if_needed is true,

* it is assumed that the buffer does *not* have enough padding, and it is reallocated, enlarged

* and copied before parsing.

*

* @param buf The JSON to parse. Must have at least len + SIMDJSON_PADDING allocated bytes, unless

* realloc_if_needed is true.

* @param len The length of the JSON.

* @param realloc_if_needed Whether to reallocate and enlarge the JSON buffer to add padding.

* @return the document, or an error if the JSON is invalid.

*/

inline static doc_move_result parse(const uint8_t *buf, size_t len, bool realloc_if_needed = true) noexcept;

/**

* Parse a JSON document.

*

* The buffer must have at least SIMDJSON_PADDING extra allocated bytes. It does not matter what

* those bytes are initialized to, as long as they are allocated. If realloc_if_needed is true,

* it is assumed that the buffer does *not* have enough padding, and it is reallocated, enlarged

* and copied before parsing.

*

* @param buf The JSON to parse. Must have at least len + SIMDJSON_PADDING allocated bytes, unless

* realloc_if_needed is true.

* @param len The length of the JSON.

* @param realloc_if_needed Whether to reallocate and enlarge the JSON buffer to add padding.

* @return the document, or an error if the JSON is invalid.

*/

really_inline static doc_move_result parse(const char *buf, size_t len, bool realloc_if_needed = true) noexcept;

/**

* Parse a JSON document.

*

* The buffer must have at least SIMDJSON_PADDING extra allocated bytes. It does not matter what

* those bytes are initialized to, as long as they are allocated. If `str.capacity() - str.size()

* < SIMDJSON_PADDING`, the string will be copied to a string with larger capacity before parsing.

*

* @param s The JSON to parse. Must have at least len + SIMDJSON_PADDING allocated bytes, or

* a new string will be created with the extra padding.

* @return the document, or an error if the JSON is invalid.

*/

really_inline static doc_move_result parse(const std::string &s) noexcept;

/**

* Parse a JSON document.

*

* @param s The JSON to parse.

* @return the document, or an error if the JSON is invalid.

*/

really_inline static doc_move_result parse(const padded_string &s) noexcept;

// We do not want to allow implicit conversion from C string to std::string.

doc_result parse(const char *buf, bool realloc_if_needed = true) noexcept = delete;

std::unique_ptr<uint64_t[]> tape;

std::unique_ptr<uint8_t[]> string_buf;// should be at least byte_capacity

private:

inline error_code set_capacity(size_t len) noexcept;

template<typename T>

friend class minify;

}; // class document

template<typename T>

class minify;

/**

* A parsed, *owned* document, or an error if the parse failed.

*

* document &doc = document::parse(json);

*

* Returns an owned `document`. When the doc_move_result (or the document retrieved from it) goes out of

* scope, the document's memory is deallocated.

*

* ## Error Codes vs. Exceptions

*

* This result type allows the user to pick whether to use exceptions or not.

*

* Use like this to avoid exceptions:

*

* auto [doc, error] = document::parse(json);

* if (error) { exit(1); }

*

* Use like this if you'd prefer to use exceptions:

*

* document doc = document::parse(json);

*

*/

class document::doc_move_result : public simdjson_move_result<document> {

public:

/**

* Read this document as a JSON objec.

*

* @return The object value, or:

* - UNEXPECTED_TYPE if the JSON document is not an object

*/

inline object_result as_object() const noexcept;

/**

* Read this document as a JSON array.

*

* @return The array value, or:

* - UNEXPECTED_TYPE if the JSON document is not an array

*/

inline array_result as_array() const noexcept;

/**

* Get the value associated with the given key.

*

* The key will be matched against **unescaped** JSON:

*

* document::parse(R"({ "a\n": 1 })")["a\n"].as_uint64_t().value == 1

* document::parse(R"({ "a\n": 1 })")["a\\n"].as_uint64_t().error == NO_SUCH_FIELD

*

* @return The value associated with this field, or:

* - NO_SUCH_FIELD if the field does not exist in the object

* - UNEXPECTED_TYPE if the document is not an object

*/

inline element_result operator[](const std::string_view &key) const noexcept;

/**

* Get the value associated with the given key.

*

* The key will be matched against **unescaped** JSON:

*

* document::parse(R"({ "a\n": 1 })")["a\n"].as_uint64_t().value == 1

* document::parse(R"({ "a\n": 1 })")["a\\n"].as_uint64_t().error == NO_SUCH_FIELD

*

* @return The value associated with this field, or:

* - NO_SUCH_FIELD if the field does not exist in the object

* - UNEXPECTED_TYPE if the document is not an object

*/

inline element_result operator[](const char *key) const noexcept;

~doc_move_result() noexcept=default;

doc_move_result(document &&doc, error_code error) noexcept;

doc_move_result(document &&doc) noexcept;

doc_move_result(error_code error) noexcept;

friend class document;

}; // class document::doc_move_result

/**

* A parsed document reference, or an error if the parse failed.

*

* document &doc = document::parse(json);

*

* ## Document Ownership

*

* The `document &` refers to an internal document the parser reuses on each `parse()` call. It will

* become invalidated on the next `parse()`.

*

* This is more efficient for common cases where documents are parsed and used one at a time. If you

* need to keep the document around longer, you may *take* it from the parser by casting it:

*

* document doc = parser.parse(); // take ownership

*

* If you do this, the parser will automatically allocate a new document on the next `parse()` call.

*

* ## Error Codes vs. Exceptions

*

* This result type allows the user to pick whether to use exceptions or not.

*

* Use like this to avoid exceptions:

*

* auto [doc, error] = parser.parse(json);

* if (error) { exit(1); }

*

* Use like this if you'd prefer to use exceptions:

*

* document &doc = document::parse(json);

*

*/

class document::doc_result : public simdjson_result<document&> {

public:

/**

* Read this document as a JSON objec.

*

* @return The object value, or:

* - UNEXPECTED_TYPE if the JSON document is not an object

*/

inline object_result as_object() const noexcept;

/**

* Read this document as a JSON array.

*

* @return The array value, or:

* - UNEXPECTED_TYPE if the JSON document is not an array

*/

inline array_result as_array() const noexcept;

/**

* Get the value associated with the given key.

*

* The key will be matched against **unescaped** JSON:

*

* document::parse(R"({ "a\n": 1 })")["a\n"].as_uint64_t().value == 1

* document::parse(R"({ "a\n": 1 })")["a\\n"].as_uint64_t().error == NO_SUCH_FIELD

*

* @return The value associated with this field, or:

* - NO_SUCH_FIELD if the field does not exist in the object

* - UNEXPECTED_TYPE if the document is not an object

*/

inline element_result operator[](const std::string_view &key) const noexcept;

/**

* Get the value associated with the given key.

*

* The key will be matched against **unescaped** JSON:

*