json.h

#ifndef JSON_INCLUDED
#define JSON_INCLUDED

#ifdef _WIN32

typedef signed char int8_t;
typedef short int int16_t;
typedef int int32_t;
typedef long long int int64_t;
typedef unsigned char uint8_t;
typedef unsigned short int uint16_t;
typedef unsigned int uint32_t;
typedef unsigned long long int uint64_t;

#else

#include <stdlib.h>
#include <stdint.h>
#include <string.h>

#endif

#include <map>
#include <queue>
#include <vector>
#include <string>
#include <string.h>
#include <limits>
#include <algorithm>
#include <cinttypes>
using namespace std;



class JValue
{
public:
	enum TYPE
	{
		E_NULL = 0,
		E_INT,
		E_BOOL,
		E_FLOAT,
		E_ARRAY,
		E_OBJECT,
		E_STRING,
		E_DATE,
		E_DATA,
	};

public:
	JValue(TYPE type = E_NULL);
	JValue(int val);
	JValue(bool val);
	JValue(double val);
	JValue(int64_t val);
	JValue(const char *val);
	JValue(const string &val);
	JValue(const JValue &other);
	JValue(const char *val, size_t len);
	~JValue();

public:
	int asInt() const;
	bool asBool() const;
	double asFloat() const;
	int64_t asInt64() const;
	string asString() const;
	const char *asCString() const;
	time_t asDate() const;
	string asData() const;

	void assignData(const char *val, size_t size);
	void assignDate(time_t val);
	void assignDateString(time_t val);

	TYPE type() const;
	size_t size() const;
	void clear();

	JValue &at(int index);
	JValue &at(size_t index);
	JValue &at(const char *key);

	bool has(const char *key) const;
	int index(const char *ele) const;
	bool keys(vector<string> &arrKeys) const;

	bool join(JValue &jv);
	bool append(JValue &jv);

	bool remove(int index);
	bool remove(size_t index);
	bool remove(const char *key);

	JValue &back();
	JValue &front();

	bool push_back(int val);
	bool push_back(bool val);
	bool push_back(double val);
	bool push_back(int64_t val);
	bool push_back(const char *val);
	bool push_back(const string &val);
	bool push_back(const JValue &jval);
	bool push_back(const char *val, size_t len);

	bool isInt() const;
	bool isNull() const;
	bool isBool() const;
	bool isFloat() const;
	bool isArray() const;
	bool isObject() const;
	bool isString() const;
	bool isEmpty() const;
	bool isData() const;
	bool isDate() const;
	bool isDataString() const;
	bool isDateString() const;

	operator int() const;
	operator bool() const;
	operator double() const;
	operator int64_t() const;
	operator string() const;
	operator const char *() const;

	JValue &operator=(const JValue &other);

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

	JValue &operator[](size_t index);
	const JValue &operator[](size_t index) const;

	JValue &operator[](int64_t index);
	const JValue &operator[](int64_t index) const;

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

	JValue &operator[](const string &key);
	const JValue &operator[](const string &key) const;

	friend bool operator==(const JValue &jv, const char *psz)
	{
		return (0 == strcmp(jv.asCString(), psz));
	}

	friend bool operator==(const char *psz, const JValue &jv)
	{
		return (0 == strcmp(jv.asCString(), psz));
	}

	friend bool operator!=(const JValue &jv, const char *psz)
	{
		return (0 != strcmp(jv.asCString(), psz));
	}

	friend bool operator!=(const char *psz, const JValue &jv)
	{
		return (0 != strcmp(jv.asCString(), psz));
	}

private:
	void Free();
	char *NewString(const char *cstr);
	void CopyValue(const JValue &src);
	bool WriteDataToFile(const char *file, const char *data, size_t len);

public:
	static const JValue null;
	static const string nullData;

private:
	union HOLD {
		bool vBool;
		double vFloat;
		int64_t vInt64;
		char *vString;
		vector<JValue> *vArray;
		map<string, JValue> *vObject;
		time_t vDate;
		string *vData;
		wchar_t *vUnicode;
	} m_Value;

	TYPE m_eType;

public:
	string write() const;
	const char *write(string &strDoc) const;

	string styleWrite() const;
	const char *styleWrite(string &strDoc) const;

	bool read(const char *pdoc, string *pstrerr = NULL);
	bool read(const string &strdoc, string *pstrerr = NULL);

	string writePList() const;
	const char *writePList(string &strDoc) const;

	bool readPList(const string &strdoc, string *pstrerr = NULL);
	bool readPList(const char *pdoc, size_t len = 0, string *pstrerr = NULL);

	bool readFile(const char *file, string *pstrerr = NULL);
	bool readPListFile(const char *file, string *pstrerr = NULL);

	bool writeFile(const char *file);
	bool writePListFile(const char *file);
	bool styleWriteFile(const char *file);

	bool readPath(const char *path, ...);
	bool readPListPath(const char *path, ...);
	bool writePath(const char *path, ...);
	bool writePListPath(const char *path, ...);
	bool styleWritePath(const char *path, ...);
};

class JReader
{
public:
	bool parse(const char *pdoc, JValue &root);
	void error(string &strmsg) const;

private:
	struct Token
	{
		enum TYPE
		{
			E_Error = 0,
			E_End,
			E_Null,
			E_True,
			E_False,
			E_Number,
			E_String,
			E_ArrayBegin,
			E_ArrayEnd,
			E_ObjectBegin,
			E_ObjectEnd,
			E_ArraySeparator,
			E_MemberSeparator
		};
		TYPE type;
		const char *pbeg;
		const char *pend;
	};

	void skipSpaces();
	void skipComment();

	bool match(const char *pattern, int patternLength);

	bool readToken(Token &token);
	bool readValue(JValue &jval);
	bool readArray(JValue &jval);
	void readNumber();

	bool readString();
	bool readObject(JValue &jval);

	bool decodeNumber(Token &token, JValue &jval);
	bool decodeString(Token &token, string &decoded);
	bool decodeDouble(Token &token, JValue &jval);

	char GetNextChar();
	bool addError(const string &message, const char *ploc);

private:
	const char *m_pBeg;
	const char *m_pEnd;
	const char *m_pCur;
	const char *m_pErr;
	string m_strErr;
};

class JWriter
{
public:
	static void FastWrite(const JValue &jval, string &strDoc);
	static void FastWriteValue(const JValue &jval, string &strDoc);

public:
	const string &StyleWrite(const JValue &jval);

private:
	void PushValue(const string &strval);
	void StyleWriteValue(const JValue &jval);
	void StyleWriteArrayValue(const JValue &jval);
	bool isMultineArray(const JValue &jval);

public:
	static string v2s(double val);
	static string v2s(int64_t val);
	static string v2s(const char *val);

	static string vstring2s(const char *val);
	static string d2s(time_t t);

private:
	string m_strDoc;
	string m_strTab;
	bool m_bAddChild;
	vector<string> m_childValues;
};

//////////////////////////////////////////////////////////////////////////
class PReader
{
public:
	PReader();

public:
	bool parse(const char *pdoc, size_t len, JValue &root);
	void error(string &strmsg) const;

private:
	struct Token
	{
		enum TYPE
		{
			E_Error = 0,
			E_End,
			E_Null,
			E_True,
			E_False,
			E_Key,
			E_Data,
			E_Date,
			E_Integer,
			E_Real,
			E_String,
			E_ArrayBegin,
			E_ArrayEnd,
			E_ArrayNull,
			E_DictionaryBegin,
			E_DictionaryEnd,
			E_DictionaryNull,
			E_ArraySeparator,
			E_MemberSeparator
		};

		Token()
		{
			pbeg = NULL;
			pend = NULL;
			type = E_Error;
		}

		TYPE type;
		const char *pbeg;
		const char *pend;
	};

	bool readToken(Token &token);
	bool readLabel(string &label);
	bool readValue(JValue &jval, Token &token);
	bool readArray(JValue &jval);
	bool readNumber();

	bool readString();
	bool readDictionary(JValue &jval);

	void endLabel(Token &token, const char *szLabel);

	bool decodeNumber(Token &token, JValue &jval);
	bool decodeString(Token &token, string &decoded);
	bool decodeDouble(Token &token, JValue &jval);

	void skipSpaces();
	bool addError(const string &message, const char *ploc);

public:
	bool parseBinary(const char *pbdoc, size_t len, JValue &pv);

private:
	uint32_t getUInt24FromBE(const char *v);
	void byteConvert(uint8_t *v, size_t size);
	uint64_t getUIntVal(const char *v, size_t size);
	bool readUIntSize(const char *&pcur, size_t &size);
	bool readBinaryValue(const char *&pcur, JValue &pv);
	bool readUnicode(const char *pcur, size_t size, JValue &pv);

public:
	static void XMLUnescape(string &strval);

private: //xml
	const char *m_pBeg;
	const char *m_pEnd;
	const char *m_pCur;
	const char *m_pErr;
	string m_strErr;

private: //binary
	const char *m_pTrailer;
	uint64_t m_uObjects;
	uint8_t m_uOffsetSize;
	const char *m_pOffsetTable;
	uint8_t m_uDictParamSize;
};

class PWriter
{
public:
	static void FastWrite(const JValue &pval, string &strdoc);
	static void FastWriteValue(const JValue &pval, string &strdoc, string &strindent);

public:
	static void XMLEscape(string &strval);
	static string &StringReplace(string &context, const string &from, const string &to);
};

#endif // JSON_INCLUDED