/* auto-generated on Thu Mar 5 10:30:07 PST 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

#define SIMDJSON_VERSION 0.2.1

namespace simdjson {

enum {

SIMDJSON_VERSION_MAJOR = 0,

SIMDJSON_VERSION_MINOR = 2,

SIMDJSON_VERSION_REVISION = 1

};

}

#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

#include <string>

namespace simdjson {

enum error_code {

SUCCESS = 0,

SUCCESS_AND_HAS_MORE, //No errors 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

UNEXPECTED_ERROR // indicative of a bug in simdjson

};

const std::string &error_message(error_code error) noexcept;

struct invalid_json : public std::exception {

invalid_json(error_code _error) : error{_error} { }

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

error_code error;

};

// TODO these are deprecated, remove

using ErrorValues = error_code;

inline const std::string &error_message(int error) noexcept { return error_message(error_code(error)); }

} // namespace simdjson

#endif // SIMDJSON_ERROR_H

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

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

#ifndef SIMDJSON_PADDING_STRING_H

#define SIMDJSON_PADDING_STRING_H

/* 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)

// 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 */

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

#ifndef SIMDJSON_COMMON_DEFS_H

#define SIMDJSON_COMMON_DEFS_H

#include <cassert>

// we support documents up to 4GB

#define SIMDJSON_MAXSIZE_BYTES 0xFFFFFFFF

// 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

#define SIMDJSON_PADDING 32

#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/common_defs.h */

#include <cstring>

#include <memory>

#include <string>

namespace simdjson {

// 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 {

// we could do a simple malloc

// return (char *) malloc(length + SIMDJSON_PADDING);

// However, we might as well align to cache lines...

size_t totalpaddedlength = length + SIMDJSON_PADDING;

char *padded_buffer = aligned_malloc_char(64, totalpaddedlength);

#ifndef NDEBUG

if (padded_buffer == nullptr) {

return nullptr;

}

#endif // NDEBUG

memset(padded_buffer + length, 0, totalpaddedlength - length);

return padded_buffer;

} // allocate_padded_buffer

// Simple string with padded allocation.

// We deliberately forbid copies, users should rely on swap or move

// constructors.

struct padded_string final {

explicit padded_string() noexcept : viable_size(0), data_ptr(nullptr) {}

explicit padded_string(size_t length) noexcept

: viable_size(length), data_ptr(allocate_padded_buffer(length)) {

if (data_ptr != nullptr)

data_ptr[length] = '\0'; // easier when you need a c_str

}

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

: viable_size(length), data_ptr(allocate_padded_buffer(length)) {

if ((data != nullptr) and (data_ptr != nullptr)) {

memcpy(data_ptr, data, length);

data_ptr[length] = '\0'; // easier when you need a c_str

}

}

// note: do not pass std::string arguments by value

padded_string(const std::string & str_ ) noexcept

: viable_size(str_.size()), data_ptr(allocate_padded_buffer(str_.size())) {

if (data_ptr != nullptr) {

memcpy(data_ptr, str_.data(), str_.size());

data_ptr[str_.size()] = '\0'; // easier when you need a c_str

}

}

// note: do pass std::string_view arguments by value

padded_string(std::string_view sv_) noexcept

: viable_size(sv_.size()), data_ptr(allocate_padded_buffer(sv_.size())) {

if (data_ptr != nullptr) {

memcpy(data_ptr, sv_.data(), sv_.size());

data_ptr[sv_.size()] = '\0'; // easier when you need a c_str

}

}

padded_string(padded_string &&o) noexcept

: viable_size(o.viable_size), data_ptr(o.data_ptr) {

o.data_ptr = nullptr; // we take ownership

}

padded_string &operator=(padded_string &&o) {

aligned_free_char(data_ptr);

data_ptr = o.data_ptr;

viable_size = o.viable_size;

o.data_ptr = nullptr; // we take ownership

o.viable_size = 0;

return *this;

}

void swap(padded_string &o) {

size_t tmp_viable_size = viable_size;

char *tmp_data_ptr = data_ptr;

viable_size = o.viable_size;

data_ptr = o.data_ptr;

o.data_ptr = tmp_data_ptr;

o.viable_size = tmp_viable_size;

}

~padded_string() {

aligned_free_char(data_ptr);

}

size_t size() const { return viable_size; }

size_t length() const { return viable_size; }

char *data() const { return data_ptr; }

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

#endif

/* end file include/simdjson/common_defs.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>

/* 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 */

#define JSON_VALUE_MASK 0x00FFFFFFFFFFFFFF

#define DEFAULT_MAX_DEPTH 1024 // a JSON document with a depth exceeding 1024 is probably de facto invalid

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

// Nested classes

class element;

class array;

class object;

class key_value_pair;

class parser;

template<typename T=element>

class element_result;

class doc_result;

class doc_ref_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.

*/

element_result<array> as_array() const noexcept;

/**

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

*/

element_result<object> as_object() const noexcept;

/**

* Get the root element of this document.

*/

operator element() const noexcept;

/**

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

*

* @return The JSON array.

* @exception invalid_json(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 invalid_json(UNEXPECTED_TYPE) if the JSON element is not an object

*/

operator object() const noexcept(false);

/**

* 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<element> 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<element> operator[](const char *s) const noexcept;

/**

* Print this JSON to a std::ostream.

*

* @param os the stream to output to.

* @param max_depth the maximum JSON depth to output.

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

*/

bool print_json(std::ostream &os, size_t max_depth=DEFAULT_MAX_DEPTH) 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;

/**

* 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_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_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_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_result parse(const padded_string &s) noexcept;

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

doc_ref_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:

class tape_ref;

enum class tape_type;

bool set_capacity(size_t len);

}; // class document

/**

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

*

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

*

* Returns an owned `document`. When the doc_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_result {

public:

/**

* The parsed document. This is *invalid* if there is an error.

*/

document doc;

/**

* The error code, or SUCCESS (0) if there is no error.

*/

error_code error;

/**

* Return the document, or throw an exception if it is invalid.

*

* @return the document.

* @exception invalid_json if the document is invalid or there was an error parsing it.

*/

operator document() noexcept(false);

/**

* Get the error message for the error.

*/

const std::string &get_error_message() const noexcept;

~doc_result() noexcept=default;

private:

doc_result(document &&_doc, error_code _error) noexcept;

doc_result(document &&_doc) noexcept;

doc_result(error_code _error) noexcept;

friend class document;

}; // class document::doc_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_ref_result {

public:

/**

* The parsed document. This is *invalid* if there is an error.

*/

document &doc;

/**

* The error code, or SUCCESS (0) if there is no error.

*/

error_code error;

/**

* A reference to the document, or throw an exception if it is invalid.

*

* @return the document.

* @exception invalid_json if the document is invalid or there was an error parsing it.

*/

operator document&() noexcept(false);

/**

* Get the error message for the error.

*/

const std::string &get_error_message() const noexcept;

~doc_ref_result()=default;

private:

doc_ref_result(document &_doc, error_code _error) noexcept;

friend class document::parser;

}; // class document::doc_ref_result

/**

* The possible types in the tape. Internal only.

*/

enum class document::tape_type {

ROOT = 'r',

START_ARRAY = '[',

START_OBJECT = '{',

END_ARRAY = ']',

END_OBJECT = '}',

STRING = '"',

INT64 = 'l',

UINT64 = 'u',

DOUBLE = 'd',

TRUE_VALUE = 't',

FALSE_VALUE = 'f',

NULL_VALUE = 'n'

};

/**

* A reference to an element on the tape. Internal only.

*/

class document::tape_ref {

protected:

really_inline tape_ref() noexcept;

really_inline tape_ref(const document *_doc, size_t _json_index) noexcept;

inline size_t after_element() const noexcept;

really_inline tape_type type() const noexcept;

really_inline uint64_t tape_value() const noexcept;

template<typename T>

really_inline T next_tape_value() const noexcept;

/** The document this element references. */

const document *doc;

/** The index of this element on `doc.tape[]` */

size_t json_index;

friend class document::key_value_pair;

};

/**

* A JSON element.

*

* References an element in a JSON document, representing a JSON null, boolean, string, number,

* array or object.

*/

class document::element : protected document::tape_ref {

public:

/** Whether this element is a json `null`. */

really_inline bool is_null() const noexcept;

/** Whether this is a JSON `true` or `false` */

really_inline bool is_bool() const noexcept;

/** Whether this is a JSON number (e.g. 1, 1.0 or 1e2) */

really_inline bool is_number() const noexcept;

/** Whether this is a JSON integer (e.g. 1 or -1, but *not* 1.0 or 1e2) */

really_inline bool is_integer() const noexcept;

/** Whether this is a JSON string (e.g. "abc") */

really_inline bool is_string() const noexcept;

/** Whether this is a JSON array (e.g. []) */

really_inline bool is_array() const noexcept;

/** Whether this is a JSON array (e.g. []) */

really_inline bool is_object() const noexcept;

/**

* Read this element as a boolean (json `true` or `false`).

*

* @return The boolean value, or:

* - UNEXPECTED_TYPE error if the JSON element is not a boolean

*/

inline element_result<bool> as_bool() const noexcept;

/**

* Read this element as a null-terminated string.

*

* Does *not* convert other types to a string; requires that the JSON type of the element was

* an actual string.

*

* @return A `string_view` into the string, or:

* - UNEXPECTED_TYPE error if the JSON element is not a string

*/

inline element_result<const char *> as_c_str() const noexcept;

/**

* Read this element as a C++ string_view (string with length).

*

* Does *not* convert other types to a string; requires that the JSON type of the element was

* an actual string.

*

* @return A `string_view` into the string, or:

* - UNEXPECTED_TYPE error if the JSON element is not a string

*/

inline element_result<std::string_view> as_string() const noexcept;

/**

* Read this element as an unsigned integer.

*

* @return The uninteger value, or:

* - UNEXPECTED_TYPE if the JSON element is not an integer

* - NUMBER_OUT_OF_RANGE if the integer doesn't fit in 64 bits or is negative

*/

inline element_result<uint64_t> as_uint64_t() const noexcept;

/**

* Read this element as a signed integer.

*

* @return The integer value, or:

* - UNEXPECTED_TYPE if the JSON element is not an integer

* - NUMBER_OUT_OF_RANGE if the integer doesn't fit in 64 bits

*/

inline element_result<int64_t> as_int64_t() const noexcept;

/**

* Read this element as a floating point value.

*

* @return The double value, or:

* - UNEXPECTED_TYPE if the JSON element is not a number

*/

inline element_result<double> as_double() const noexcept;

/**

* Read this element as a JSON array.

*

* @return The array value, or:

* - UNEXPECTED_TYPE if the JSON element is not an array

*/

inline element_result<document::array> as_array() const noexcept;

/**

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

*

* @return The object value, or:

* - UNEXPECTED_TYPE if the JSON element is not an object

*/

inline element_result<document::object> as_object() const noexcept;

/**

* Read this element as a boolean.

*

* @return The boolean value

* @exception invalid_json(UNEXPECTED_TYPE) if the JSON element is not a boolean.

*/

inline operator bool() const noexcept(false);

/**

* Read this element as a null-terminated string.

*

* Does *not* convert other types to a string; requires that the JSON type of the element was

* an actual string.

*

* @return The string value.

* @exception invalid_json(UNEXPECTED_TYPE) if the JSON element is not a string.

*/

inline explicit operator const char*() const noexcept(false);

/**

* Read this element as a null-terminated string.

*

* Does *not* convert other types to a string; requires that the JSON type of the element was

* an actual string.

*

* @return The string value.

* @exception invalid_json(UNEXPECTED_TYPE) if the JSON element is not a string.

*/

inline operator std::string_view() const noexcept(false);

/**

* Read this element as an unsigned integer.

*

* @return The integer value.

* @exception invalid_json(UNEXPECTED_TYPE) if the JSON element is not an integer

* @exception invalid_json(NUMBER_OUT_OF_RANGE) if the integer doesn't fit in 64 bits or is negative

*/

inline operator uint64_t() const noexcept(false);

/**

* Read this element as an signed integer.

*

* @return The integer value.

* @exception invalid_json(UNEXPECTED_TYPE) if the JSON element is not an integer

* @exception invalid_json(NUMBER_OUT_OF_RANGE) if the integer doesn't fit in 64 bits

*/

inline operator int64_t() const noexcept(false);

/**

* Read this element as an double.

*

* @return The double value.

* @exception invalid_json(UNEXPECTED_TYPE) if the JSON element is not a number

* @exception invalid_json(NUMBER_OUT_OF_RANGE) if the integer doesn't fit in 64 bits or is negative

*/

inline operator double() const noexcept(false);

/**

* Read this element as a JSON array.

*

* @return The JSON array.

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

*/

inline operator document::array() const noexcept(false);

/**

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

*

* @return The JSON object.

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

*/

inline operator document::object() const noexcept(false);

/**

* 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<element> operator[](const std::string_view &s) const noexcept;

/**

* Get the value associated with the given key.

*

* Note: 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<element> operator[](const char *s) const noexcept;

private:

really_inline element() noexcept;

really_inline element(const document *_doc, size_t _json_index) noexcept;

friend class document;

template<typename T>

friend class document::element_result;

};

/**

* Represents a JSON array.

*/

class document::array : protected document::tape_ref {

public:

class iterator : tape_ref {

public:

/**

* Get the actual value

*/

inline element operator*() const noexcept;

/**

* Get the next value.

*

* Part of the std::iterator interface.

*/

inline void operator++() noexcept;

/**

* Check if these values come from the same place in the JSON.

*

* Part of the std::iterator interface.

*/

inline bool operator!=(const iterator& other) const noexcept;

private: