#ifndef JSON_AMALGATED_H_INCLUDED

# define JSON_AMALGATED_H_INCLUDED

#define JSON_IS_AMALGAMATION

#ifndef JSON_VERSION_H_INCLUDED

# define JSON_VERSION_H_INCLUDED

# define JSONCPP_VERSION_STRING "1.0.0"

# define JSONCPP_VERSION_MAJOR 1

# define JSONCPP_VERSION_MINOR 0

# define JSONCPP_VERSION_PATCH 0

# define JSONCPP_VERSION_QUALIFIER

# define JSONCPP_VERSION_HEXA ((JSONCPP_VERSION_MAJOR << 24) | (JSONCPP_VERSION_MINOR << 16) | (JSONCPP_VERSION_PATCH << 8))

#endif // JSON_VERSION_H_INCLUDED

#ifndef JSON_CONFIG_H_INCLUDED

#define JSON_CONFIG_H_INCLUDED

#ifndef JSON_USE_EXCEPTION

#define JSON_USE_EXCEPTION 1

#endif

#ifdef JSON_IN_CPPTL

#include <cpptl/config.h>

#ifndef JSON_USE_CPPTL

#define JSON_USE_CPPTL 1

#endif

#endif

#ifdef JSON_IN_CPPTL

#define JSON_API CPPTL_API

#elif defined(JSON_DLL_BUILD)

#if defined(_MSC_VER)

#define JSON_API __declspec(dllexport)

#define JSONCPP_DISABLE_DLL_INTERFACE_WARNING

#endif // if defined(_MSC_VER)

#elif defined(JSON_DLL)

#if defined(_MSC_VER)

#define JSON_API __declspec(dllimport)

#define JSONCPP_DISABLE_DLL_INTERFACE_WARNING

#endif // if defined(_MSC_VER)

#endif // ifdef JSON_IN_CPPTL

#if !defined(JSON_API)

#define JSON_API

#endif

#if defined(_MSC_VER) && _MSC_VER <= 1200 // MSVC 6

#define JSON_USE_INT64_DOUBLE_CONVERSION 1

#pragma warning(disable : 4786)

#endif // if defined(_MSC_VER) && _MSC_VER < 1200 // MSVC 6

#if defined(_MSC_VER) && _MSC_VER >= 1500 // MSVC 2008

#define JSONCPP_DEPRECATED(message) __declspec(deprecated(message))

#endif

#if !defined(JSONCPP_DEPRECATED)

#define JSONCPP_DEPRECATED(message)

#endif // if !defined(JSONCPP_DEPRECATED)

namespace Json {

typedef int Int;

typedef unsigned int UInt;

#if defined(JSON_NO_INT64)

typedef int LargestInt;

typedef unsigned int LargestUInt;

#undef JSON_HAS_INT64

#else // if defined(JSON_NO_INT64)

#if defined(_MSC_VER) // Microsoft Visual Studio

typedef __int64 Int64;

typedef unsigned __int64 UInt64;

#else // if defined(_MSC_VER) // Other platforms, use long long

typedef long long int Int64;

typedef unsigned long long int UInt64;

#endif // if defined(_MSC_VER)

typedef Int64 LargestInt;

typedef UInt64 LargestUInt;

#define JSON_HAS_INT64

#endif // if defined(JSON_NO_INT64)

} // end namespace Json

#endif // JSON_CONFIG_H_INCLUDED

#ifndef JSON_FORWARDS_H_INCLUDED

#define JSON_FORWARDS_H_INCLUDED

#if !defined(JSON_IS_AMALGAMATION)

#include "config.h"

#endif // if !defined(JSON_IS_AMALGAMATION)

namespace Json {

class FastWriter;

class StyledWriter;

class Reader;

class Features;

typedef unsigned int ArrayIndex;

class StaticString;

class Path;

class PathArgument;

class Value;

class ValueIteratorBase;

class ValueIterator;

class ValueConstIterator;

#ifdef JSON_VALUE_USE_INTERNAL_MAP

class ValueMapAllocator;

class ValueInternalLink;

class ValueInternalArray;

class ValueInternalMap;

#endif // #ifdef JSON_VALUE_USE_INTERNAL_MAP

} // namespace Json

#endif // JSON_FORWARDS_H_INCLUDED

#ifndef CPPTL_JSON_FEATURES_H_INCLUDED

#define CPPTL_JSON_FEATURES_H_INCLUDED

#if !defined(JSON_IS_AMALGAMATION)

#include "forwards.h"

#endif // if !defined(JSON_IS_AMALGAMATION)

namespace Json {

class JSON_API Features {

/** \brief A configuration that allows all features and assumes all strings

static Features all();

/** \brief A configuration that is strictly compatible with the JSON

static Features strictMode();

/** \brief Initialize the configuration like JsonConfig::allFeatures;

Features();

/// \c true if comments are allowed. Default: \c true.

bool allowComments_;

/// \c true if root must be either an array or an object value. Default: \c

/// false.

bool strictRoot_;

/// \c true if dropped null placeholders are allowed. Default: \c false.

bool allowDroppedNullPlaceholders_;

/// \c true if numeric object key are allowed. Default: \c false.

bool allowNumericKeys_;

};

} // namespace Json

#endif // CPPTL_JSON_FEATURES_H_INCLUDED

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

#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_DISABLE_DLL_INTERFACE_WARNING)

#pragma warning(push)

#pragma warning(disable : 4251)

#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)

namespace Json {

enum ValueType {

};

enum CommentPlacement {

};

class JSON_API StaticString {

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

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

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

const char* str_;

};

class JSON_API Value {

friend class ValueIteratorBase;

#ifdef JSON_VALUE_USE_INTERNAL_MAP

friend class ValueInternalLink;

friend class ValueInternalMap;

#endif

typedef std::vector<std::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;

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

#ifndef JSON_VALUE_USE_INTERNAL_MAP

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 JSON_VALUE_USE_INTERNAL_MAP

#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);

Value(const char* beginValue, const char* endValue);

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

Value(const StaticString& value);

Value(const std::string& value);

#ifdef JSON_USE_CPPTL

Value(const CppTL::ConstString& value);

#endif

Value(bool value);

Value(const Value& other);

~Value();

Value& operator=(Value other);

/// Swap values.

/// \note Currently, comments are intentionally not swapped, for

/// both logic and efficiency.

void swap(Value& other);

ValueType type() 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;

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

int compare(const Value& other) const;

const char* asCString() const;

std::string asString() 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.

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.

Value& operator[](const std::string& key);

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

/// that name.

const Value& operator[](const std::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.

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

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

Value get(const std::string& key, const Value& defaultValue) const;

#ifdef JSON_USE_CPPTL

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

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

#endif

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

Value removeMember(const char* key);

/// Same as removeMember(const char*)

Value removeMember(const std::string& key);

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

bool isMember(const char* key) const;

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

bool isMember(const std::string& key) 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

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

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

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

void setComment(const std::string& comment, CommentPlacement placement);

bool hasComment(CommentPlacement placement) const;

/// Include delimiters and embedded newlines.

std::string getComment(CommentPlacement placement) const;

std::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(size_t start);

void setOffsetLimit(size_t limit);

size_t getOffsetStart() const;

size_t getOffsetLimit() const;

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

Value& resolveReference(const char* key, bool isStatic);

#ifdef JSON_VALUE_USE_INTERNAL_MAP

inline bool isItemAvailable() const { return itemIsUsed_ == 0; }

inline void setItemUsed(bool isUsed = true) { itemIsUsed_ = isUsed ? 1 : 0; }

inline bool isMemberNameStatic() const { return memberNameIsStatic_ == 0; }

inline void setMemberNameIsStatic(bool isStatic) {

memberNameIsStatic_ = isStatic ? 1 : 0;

}

#endif // # ifdef JSON_VALUE_USE_INTERNAL_MAP

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;

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

#ifdef JSON_VALUE_USE_INTERNAL_MAP

unsigned int itemIsUsed_ : 1; // used by the ValueInternalMap container.

int memberNameIsStatic_ : 1; // used by the ValueInternalMap container.

#endif

CommentInfo* comments_;

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

// was extracted.

size_t start_;

size_t limit_;

};

class JSON_API PathArgument {

friend class Path;

PathArgument();

PathArgument(ArrayIndex index);

PathArgument(const char* key);

PathArgument(const std::string& key);

enum Kind {

};

std::string key_;

ArrayIndex index_;

Kind kind_;

};

class JSON_API Path {

Path(const std::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 std::string& path, const InArgs& in);

void addPathInArg(const std::string& path,

const InArgs& in,

InArgs::const_iterator& itInArg,

PathArgument::Kind kind);

void invalidPath(const std::string& path, int location);

Args args_;

};

#ifdef JSON_VALUE_USE_INTERNAL_MAP

class JSON_API ValueMapAllocator {

virtual ~ValueMapAllocator();

virtual ValueInternalMap* newMap() = 0;

virtual ValueInternalMap* newMapCopy(const ValueInternalMap& other) = 0;

virtual void destructMap(ValueInternalMap* map) = 0;

virtual ValueInternalLink* allocateMapBuckets(unsigned int size) = 0;

virtual void releaseMapBuckets(ValueInternalLink* links) = 0;

virtual ValueInternalLink* allocateMapLink() = 0;

virtual void releaseMapLink(ValueInternalLink* link) = 0;

};

class JSON_API ValueInternalLink {

enum {

itemPerLink = 6

}; // sizeof(ValueInternalLink) = 128 on 32 bits architecture.

enum InternalFlags {