#define JSON_IS_AMALGAMATION

#ifndef JSON_VERSION_H_INCLUDED

# define JSON_VERSION_H_INCLUDED

# 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

#ifdef JSON_IN_CPPTL

#define JSON_API CPPTL_API

#elif defined(JSON_DLL_BUILD)

#define JSON_API __declspec(dllexport)

#define JSONCPP_DISABLE_DLL_INTERFACE_WARNING

#endif // if defined(_MSC_VER)

#elif defined(JSON_DLL)

#define JSON_API __declspec(dllimport)

#define JSONCPP_DISABLE_DLL_INTERFACE_WARNING

#endif // if defined(_MSC_VER)

#endif

#endif

#if !defined(JSONCPP_DEPRECATED)

#define JSONCPP_DEPRECATED(message)

#endif // if !defined(JSONCPP_DEPRECATED)

namespace Json {

typedef int Int;

typedef unsigned int UInt;

typedef __int64 Int64;

typedef unsigned __int64 UInt64;

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

#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

#include "forwards.h"

#endif // if !defined(JSON_IS_AMALGAMATION)

namespace Json {

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

/// false.

bool strictRoot_;

};

} // namespace Json

#endif // CPPTL_JSON_FEATURES_H_INCLUDED

#include <cpptl/forwards.h>

#endif

#if !defined(JSONCPP_NORETURN)

# if defined(_MSC_VER)

# endif

#endif

namespace Json {

class JSON_API Exception : public std::exception {

};

class JSON_API RuntimeError : public Exception {

};

class JSON_API LogicError : public Exception {

};

class JSON_API Value {

friend class ValueIteratorBase;

typedef ValueIterator iterator;

typedef ValueConstIterator const_iterator;

typedef Json::UInt UInt;

typedef Json::LargestUInt LargestUInt;

typedef Json::ArrayIndex ArrayIndex;

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

CZString(ArrayIndex index);

CZString(char const* str, unsigned length, DuplicationPolicy allocate);

CZString(CZString const& other);

~CZString();

CZString& operator=(CZString other);

bool operator<(CZString const& other) const;

Value(const StaticString& value);

#ifdef JSON_USE_CPPTL

Value(const CppTL::ConstString& value);

#endif

Value(bool value);

/// Deep copy.

Value(const Value& other);

~Value();

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

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

/// Swap everything.

void swap(Value& other);

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

int compare(const Value& other) const;

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

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

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.

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

/// that name.

/// \param key may contain embedded nulls.

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

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

/// \note deep copy

/// \param key may contain embedded nulls.

#ifdef JSON_USE_CPPTL

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

/// \note deep copy

/// Same as removeMember(const char*)

/// \param key may contain embedded nulls.

/// \deprecated

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

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

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

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

/** \brief Remove the indexed array element.

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 char* begin, const char* end) const;

#ifdef JSON_USE_CPPTL

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

//# endif

/// \deprecated Always pass len.

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

bool hasComment(CommentPlacement placement) const;

/// Include delimiters and embedded newlines.

const_iterator begin() const;

const_iterator end() const;

iterator begin();

iterator end();

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

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

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

CommentInfo* comments_;

};

PathArgument();

PathArgument(ArrayIndex index);

PathArgument(const char* key);

enum Kind {

kindNone = 0,

kindIndex,

kindKey

};

ArrayIndex index_;

Kind kind_;

};

class JSON_API Path {

const PathArgument& a1 = PathArgument(),

const PathArgument& a2 = PathArgument(),

const PathArgument& a3 = PathArgument(),

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

typedef std::vector<PathArgument> Args;

const InArgs& in,

InArgs::const_iterator& itInArg,

PathArgument::Kind kind);

Args args_;

};

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

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

/// objectValue.

typedef ValueConstIterator SelfType;

ValueConstIterator();

typedef ValueIterator SelfType;

ValueIterator();

ValueIterator(const ValueIterator& other);

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

}

#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)

#pragma warning(pop)

#pragma warning(disable : 4251)

#endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)

namespace Json {

typedef char Char;

typedef const Char* Location;