#ifndef CPPTL_JSON_H_INCLUDED

#define CPPTL_JSON_H_INCLUDED

#if !defined(JSON_IS_AMALGAMATION)

#include "forwards.h"

#endif // if !defined(JSON_IS_AMALGAMATION)

#include <string>

#include <vector>

#include <exception>

#ifndef JSON_USE_CPPTL_SMALLMAP

#include <map>

#else

#include <cpptl/smallmap.h>

#endif

#ifdef JSON_USE_CPPTL

#include <cpptl/forwards.h>

#endif

#if !defined(JSONCPP_NORETURN)

# if defined(_MSC_VER)

# define JSONCPP_NORETURN __declspec(noreturn)

# elif defined(__GNUC__)

# define JSONCPP_NORETURN __attribute__ ((__noreturn__))

# else

# define JSONCPP_NORETURN

# endif

#endif

#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)

#pragma warning(push)

#pragma warning(disable : 4251)

#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)

namespace Json {

class JSON_API Exception : public std::exception {

Exception(JSONCPP_STRING const& msg);

~Exception() JSONCPP_NOEXCEPT JSONCPP_OVERRIDE;

char const* what() const JSONCPP_NOEXCEPT JSONCPP_OVERRIDE;

JSONCPP_STRING msg_;

};

class JSON_API RuntimeError : public Exception {

RuntimeError(JSONCPP_STRING const& msg);

};

class JSON_API LogicError : public Exception {

LogicError(JSONCPP_STRING const& msg);

};

JSONCPP_NORETURN void throwRuntimeError(JSONCPP_STRING const& msg);

JSONCPP_NORETURN void throwLogicError(JSONCPP_STRING const& msg);

enum ValueType {

};

enum CommentPlacement {

};

class JSON_API StaticString {

explicit StaticString(const char* czstring) : c_str_(czstring) {}

operator const char*() const { return c_str_; }

const char* c_str() const { return c_str_; }

const char* c_str_;

};

class JSON_API Value {

friend class ValueIteratorBase;

typedef std::vector<JSONCPP_STRING> Members;

typedef ValueIterator iterator;

typedef ValueConstIterator const_iterator;

typedef Json::UInt UInt;

typedef Json::Int Int;

#if defined(JSON_HAS_INT64)

typedef Json::UInt64 UInt64;

typedef Json::Int64 Int64;

#endif // defined(JSON_HAS_INT64)

typedef Json::LargestInt LargestInt;

typedef Json::LargestUInt LargestUInt;

typedef Json::ArrayIndex ArrayIndex;

static const Value& null; ///< We regret this reference to a global instance; prefer the simpler Value().

static const Value& nullRef; ///< just a kludge for binary-compatibility; same as null

static Value const& nullSingleton(); ///< Prefer this to null or nullRef.

/// Minimum signed integer value that can be stored in a Json::Value.

static const LargestInt minLargestInt;

/// Maximum signed integer value that can be stored in a Json::Value.

static const LargestInt maxLargestInt;

/// Maximum unsigned integer value that can be stored in a Json::Value.

static const LargestUInt maxLargestUInt;

/// Minimum signed int value that can be stored in a Json::Value.

static const Int minInt;

/// Maximum signed int value that can be stored in a Json::Value.

static const Int maxInt;

/// Maximum unsigned int value that can be stored in a Json::Value.

static const UInt maxUInt;

#if defined(JSON_HAS_INT64)

/// Minimum signed 64 bits int value that can be stored in a Json::Value.

static const Int64 minInt64;

/// Maximum signed 64 bits int value that can be stored in a Json::Value.

static const Int64 maxInt64;

/// Maximum unsigned 64 bits int value that can be stored in a Json::Value.

static const UInt64 maxUInt64;

#endif // defined(JSON_HAS_INT64)

#ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION

class CZString {

};

#ifndef JSON_USE_CPPTL_SMALLMAP

typedef std::map<CZString, Value> ObjectValues;

#else

typedef CppTL::SmallMap<CZString, Value> ObjectValues;

#endif // ifndef JSON_USE_CPPTL_SMALLMAP

#endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION

/** \brief Create a default Value of the given type.

Value(ValueType type = nullValue);

Value(Int value);

Value(UInt value);

#if defined(JSON_HAS_INT64)

Value(Int64 value);

Value(UInt64 value);

#endif // if defined(JSON_HAS_INT64)

Value(double value);

Value(const char* value); ///< Copy til first 0. (NULL causes to seg-fault.)

Value(const char* begin, const char* end); ///< Copy all, incl zeroes.

/** \brief Constructs a value from a static string.

Value(const StaticString& value);

Value(const JSONCPP_STRING& value); ///< Copy data() til size(). Embedded zeroes too.

#ifdef JSON_USE_CPPTL

Value(const CppTL::ConstString& value);

#endif

Value(bool value);

/// Deep copy.

Value(const Value& other);

#if JSON_HAS_RVALUE_REFERENCES

/// Move constructor

Value(Value&& other);

#endif

~Value();

/// Deep copy, then swap(other).

/// \note Over-write existing comments. To preserve comments, use #swapPayload().

Value& operator=(Value other);

/// Swap everything.

void swap(Value& other);

/// Swap values but leave comments and source offsets in place.

void swapPayload(Value& other);

ValueType type() const;

/// Compare payload only, not comments etc.

bool operator<(const Value& other) const;

bool operator<=(const Value& other) const;

bool operator>=(const Value& other) const;

bool operator>(const Value& other) const;

bool operator==(const Value& other) const;

bool operator!=(const Value& other) const;

int compare(const Value& other) const;

const char* asCString() const; ///< Embedded zeroes could cause you trouble!

#if JSONCPP_USING_SECURE_MEMORY

unsigned getCStringLength() const; //Allows you to understand the length of the CString

#endif

JSONCPP_STRING asString() const; ///< Embedded zeroes are possible.

/** Get raw char* of string-value.

bool getString(

char const** begin, char const** end) const;

#ifdef JSON_USE_CPPTL

CppTL::ConstString asConstString() const;

#endif

Int asInt() const;

UInt asUInt() const;

#if defined(JSON_HAS_INT64)

Int64 asInt64() const;

UInt64 asUInt64() const;

#endif // if defined(JSON_HAS_INT64)

LargestInt asLargestInt() const;

LargestUInt asLargestUInt() const;

float asFloat() const;

double asDouble() const;

bool asBool() const;

bool isNull() const;

bool isBool() const;

bool isInt() const;

bool isInt64() const;

bool isUInt() const;

bool isUInt64() const;

bool isIntegral() const;

bool isDouble() const;

bool isNumeric() const;

bool isString() const;

bool isArray() const;

bool isObject() const;

bool isConvertibleTo(ValueType other) const;

/// Number of values in array or object

ArrayIndex size() const;

/// \brief Return true if empty array, empty object, or null;

/// otherwise, false.

bool empty() const;

/// Return isNull()

bool operator!() const;

/// Remove all object members and array elements.

/// \pre type() is arrayValue, objectValue, or nullValue

/// \post type() is unchanged

void clear();

/// Resize the array to size elements.

/// New elements are initialized to null.

/// May only be called on nullValue or arrayValue.

/// \pre type() is arrayValue or nullValue

/// \post type() is arrayValue

void resize(ArrayIndex size);

/// Access an array element (zero based index ).

/// If the array contains less than index element, then null value are

/// inserted

/// in the array so that its size is index+1.

/// (You may need to say 'value[0u]' to get your compiler to distinguish

/// this from the operator[] which takes a string.)

Value& operator[](ArrayIndex index);

/// Access an array element (zero based index ).

/// If the array contains less than index element, then null value are

/// inserted

/// in the array so that its size is index+1.

/// (You may need to say 'value[0u]' to get your compiler to distinguish

/// this from the operator[] which takes a string.)

Value& operator[](int index);

/// Access an array element (zero based index )

/// (You may need to say 'value[0u]' to get your compiler to distinguish

/// this from the operator[] which takes a string.)

const Value& operator[](ArrayIndex index) const;

/// Access an array element (zero based index )

/// (You may need to say 'value[0u]' to get your compiler to distinguish

/// this from the operator[] which takes a string.)

const Value& operator[](int index) const;

/// If the array contains at least index+1 elements, returns the element

/// value,

/// otherwise returns defaultValue.

Value get(ArrayIndex index, const Value& defaultValue) const;

/// Return true if index < size().

bool isValidIndex(ArrayIndex index) const;

/// \brief Append value to array at the end.

///

/// Equivalent to jsonvalue[jsonvalue.size()] = value;

Value& append(const Value& value);

/// Access an object value by name, create a null member if it does not exist.

/// \note Because of our implementation, keys are limited to 2^30 -1 chars.

/// Exceeding that will cause an exception.

Value& operator[](const char* key);

/// Access an object value by name, returns null if there is no member with

/// that name.

const Value& operator[](const char* key) const;

/// Access an object value by name, create a null member if it does not exist.

/// \param key may contain embedded nulls.

Value& operator[](const JSONCPP_STRING& key);

/// Access an object value by name, returns null if there is no member with

/// that name.

/// \param key may contain embedded nulls.

const Value& operator[](const JSONCPP_STRING& key) const;

/** \brief Access an object value by name, create a null member if it does not

Value& operator[](const StaticString& key);

#ifdef JSON_USE_CPPTL

/// Access an object value by name, create a null member if it does not exist.

Value& operator[](const CppTL::ConstString& key);

/// Access an object value by name, returns null if there is no member with

/// that name.

const Value& operator[](const CppTL::ConstString& key) const;

#endif

/// Return the member named key if it exist, defaultValue otherwise.

/// \note deep copy

Value get(const char* key, const Value& defaultValue) const;

/// Return the member named key if it exist, defaultValue otherwise.

/// \note deep copy

/// \note key may contain embedded nulls.

Value get(const char* begin, const char* end, const Value& defaultValue) const;

/// Return the member named key if it exist, defaultValue otherwise.

/// \note deep copy

/// \param key may contain embedded nulls.

Value get(const JSONCPP_STRING& key, const Value& defaultValue) const;

#ifdef JSON_USE_CPPTL

/// Return the member named key if it exist, defaultValue otherwise.

/// \note deep copy

Value get(const CppTL::ConstString& key, const Value& defaultValue) const;

#endif

/// Most general and efficient version of isMember()const, get()const,

/// and operator[]const

/// \note As stated elsewhere, behavior is undefined if (end-begin) >= 2^30

Value const* find(char const* begin, char const* end) const;

/// Most general and efficient version of object-mutators.

/// \note As stated elsewhere, behavior is undefined if (end-begin) >= 2^30

/// \return non-zero, but JSON_ASSERT if this is neither object nor nullValue.

Value const* demand(char const* begin, char const* end);

/// \brief Remove and return the named member.

///

/// Do nothing if it did not exist.

/// \return the removed Value, or null.

/// \pre type() is objectValue or nullValue

/// \post type() is unchanged

/// \deprecated

Value removeMember(const char* key);

/// Same as removeMember(const char*)

/// \param key may contain embedded nulls.

/// \deprecated

Value removeMember(const JSONCPP_STRING& key);

/// Same as removeMember(const char* begin, const char* end, Value* removed),

/// but 'key' is null-terminated.

bool removeMember(const char* key, Value* removed);

/** \brief Remove the named map member.

bool removeMember(JSONCPP_STRING const& key, Value* removed);

/// Same as removeMember(JSONCPP_STRING const& key, Value* removed)

bool removeMember(const char* begin, const char* end, Value* removed);

/** \brief Remove the indexed array element.

bool removeIndex(ArrayIndex i, Value* removed);

/// Return true if the object has a member named key.

/// \note 'key' must be null-terminated.

bool isMember(const char* key) const;

/// Return true if the object has a member named key.

/// \param key may contain embedded nulls.

bool isMember(const JSONCPP_STRING& key) const;

/// Same as isMember(JSONCPP_STRING const& key)const

bool isMember(const char* begin, const char* end) const;

#ifdef JSON_USE_CPPTL

/// Return true if the object has a member named key.

bool isMember(const CppTL::ConstString& key) const;

#endif

/// \brief Return a list of the member names.

///

/// If null, return an empty list.

/// \pre type() is objectValue or nullValue

/// \post if type() was nullValue, it remains nullValue

Members getMemberNames() const;

//# ifdef JSON_USE_CPPTL

// EnumMemberNames enumMemberNames() const;

// EnumValues enumValues() const;

//# endif

/// \deprecated Always pass len.

JSONCPP_DEPRECATED("Use setComment(JSONCPP_STRING const&) instead.")

void setComment(const char* comment, CommentPlacement placement);

/// Comments must be //... or /* ... */

void setComment(const char* comment, size_t len, CommentPlacement placement);

/// Comments must be //... or /* ... */

void setComment(const JSONCPP_STRING& comment, CommentPlacement placement);

bool hasComment(CommentPlacement placement) const;

/// Include delimiters and embedded newlines.

JSONCPP_STRING getComment(CommentPlacement placement) const;

JSONCPP_STRING toStyledString() const;

const_iterator begin() const;

const_iterator end() const;

iterator begin();

iterator end();

// Accessors for the [start, limit) range of bytes within the JSON text from

// which this value was parsed, if any.

void setOffsetStart(ptrdiff_t start);

void setOffsetLimit(ptrdiff_t limit);

ptrdiff_t getOffsetStart() const;

ptrdiff_t getOffsetLimit() const;

void initBasic(ValueType type, bool allocated = false);

Value& resolveReference(const char* key);

Value& resolveReference(const char* key, const char* end);

struct CommentInfo {

};

// struct MemberNamesTransform

//{

// typedef const char *result_type;

// const char *operator()( const CZString &name ) const

// {

// return name.c_str();

// }

//};

union ValueHolder {

} value_;

ValueType type_ : 8;

unsigned int allocated_ : 1; // Notes: if declared as bool, bitfield is useless.

// If not allocated_, string_ must be null-terminated.

CommentInfo* comments_;

// [start, limit) byte offsets in the source JSON text from which this Value

// was extracted.

ptrdiff_t start_;

ptrdiff_t limit_;

};

class JSON_API PathArgument {

friend class Path;

PathArgument();

PathArgument(ArrayIndex index);

PathArgument(const char* key);

PathArgument(const JSONCPP_STRING& key);

enum Kind {

};

JSONCPP_STRING key_;

ArrayIndex index_;

Kind kind_;

};

class JSON_API Path {

Path(const JSONCPP_STRING& path,

const PathArgument& a1 = PathArgument(),

const PathArgument& a2 = PathArgument(),

const PathArgument& a3 = PathArgument(),

const PathArgument& a4 = PathArgument(),

const PathArgument& a5 = PathArgument());

const Value& resolve(const Value& root) const;

Value resolve(const Value& root, const Value& defaultValue) const;

/// Creates the "path" to access the specified node and returns a reference on

/// the node.

Value& make(Value& root) const;

typedef std::vector<const PathArgument*> InArgs;

typedef std::vector<PathArgument> Args;

void makePath(const JSONCPP_STRING& path, const InArgs& in);

void addPathInArg(const JSONCPP_STRING& path,

const InArgs& in,

InArgs::const_iterator& itInArg,

PathArgument::Kind kind);

void invalidPath(const JSONCPP_STRING& path, int location);

Args args_;

};

class JSON_API ValueIteratorBase {

typedef std::bidirectional_iterator_tag iterator_category;

typedef unsigned int size_t;

typedef int difference_type;

typedef ValueIteratorBase SelfType;

bool operator==(const SelfType& other) const { return isEqual(other); }

bool operator!=(const SelfType& other) const { return !isEqual(other); }

difference_type operator-(const SelfType& other) const {

return other.computeDistance(*this);

}

/// Return either the index or the member name of the referenced value as a

/// Value.

Value key() const;

/// Return the index of the referenced Value, or -1 if it is not an arrayValue.

UInt index() const;

/// Return the member name of the referenced Value, or "" if it is not an

/// objectValue.

/// \note Avoid `c_str()` on result, as embedded zeroes are possible.

JSONCPP_STRING name() const;

/// Return the member name of the referenced Value. "" if it is not an

/// objectValue.

/// \deprecated This cannot be used for UTF-8 strings, since there can be embedded nulls.

JSONCPP_DEPRECATED("Use `key = name();` instead.")

char const* memberName() const;

/// Return the member name of the referenced Value, or NULL if it is not an

/// objectValue.

/// \note Better version than memberName(). Allows embedded nulls.

char const* memberName(char const** end) const;

Value& deref() const;

void increment();

void decrement();

difference_type computeDistance(const SelfType& other) const;

bool isEqual(const SelfType& other) const;

void copy(const SelfType& other);

Value::ObjectValues::iterator current_;

// Indicates that iterator is for a null value.

bool isNull_;

// For some reason, BORLAND needs these at the end, rather

// than earlier. No idea why.

ValueIteratorBase();

explicit ValueIteratorBase(const Value::ObjectValues::iterator& current);

};

class JSON_API ValueConstIterator : public ValueIteratorBase {

friend class Value;

typedef const Value value_type;

//typedef unsigned int size_t;

//typedef int difference_type;

typedef const Value& reference;

typedef const Value* pointer;

typedef ValueConstIterator SelfType;

ValueConstIterator();

ValueConstIterator(ValueIterator const& other);

explicit ValueConstIterator(const Value::ObjectValues::iterator& current);

SelfType& operator=(const ValueIteratorBase& other);

SelfType operator++(int) {

SelfType temp(*this);

++*this;

return temp;

}

SelfType operator--(int) {

SelfType temp(*this);

--*this;

return temp;

}

SelfType& operator--() {

decrement();

return *this;

}

SelfType& operator++() {

increment();

return *this;

}

reference operator*() const { return deref(); }

pointer operator->() const { return &deref(); }

};

class JSON_API ValueIterator : public ValueIteratorBase {

friend class Value;

typedef Value value_type;

typedef unsigned int size_t;

typedef int difference_type;

typedef Value& reference;

typedef Value* pointer;

typedef ValueIterator SelfType;

ValueIterator();

explicit ValueIterator(const ValueConstIterator& other);

ValueIterator(const ValueIterator& other);

explicit ValueIterator(const Value::ObjectValues::iterator& current);

SelfType& operator=(const SelfType& other);

SelfType operator++(int) {

SelfType temp(*this);

++*this;

return temp;

}

SelfType operator--(int) {

SelfType temp(*this);

--*this;

return temp;

}

SelfType& operator--() {

decrement();

return *this;

}

SelfType& operator++() {

increment();

return *this;

}

reference operator*() const { return deref(); }

pointer operator->() const { return &deref(); }

};

} // namespace Json

namespace std {

template<>

inline void swap(Json::Value& a, Json::Value& b) { a.swap(b); }

}

#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)

#pragma warning(pop)

#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)

#endif // CPPTL_JSON_H_INCLUDED