envi-code/SourceCode/Code2026/AecRxBase/jsonRead.cpp

#include "StdAfx.h"
#include "shJson.h"
#include "Base64.h"

using namespace SHJson;

namespace
{
	long getFileSize(FILE *fp)
	{
		if (!fp) return 0L;
		fseek(fp, 0L, SEEK_END);
		long fSize = ftell(fp);
		fseek(fp, 0L, 0L);
		return fSize;
	}
}

namespace SHJson
{
	WDocument::AllocatorType &SHJson::getJsonAllocator()
	{
		static WDocument g_doc;
		return g_doc.GetAllocator();
	}

	std::wstring write2Json(const WValue &v, bool pretty)
	{
		WStringBuffer buffer;
		if (pretty)
		{
			PrettyWriter<WStringBuffer, UTF16<>, UTF16<>> writer(buffer);
			v.Accept(writer);
		}
		else
		{
			Writer<WStringBuffer, UTF16<>, UTF16<>> writer(buffer);
			v.Accept(writer);
		}
		return buffer.GetString();
	}

	WDocument& string2Json(LPCTSTR json, WDocument &doc)
	{
		doc.Parse(json);
		if (doc.HasParseError())
		{
			static WDocument docTmp;
			return docTmp;
		}
		return doc;
	}

	bool json2File(LPCTSTR path, const WValue &v, bool pretty)
	{
		if (!path) return false;

		std::wstring ws = write2Json(v, pretty);
		if (ws.empty()) return false;
		std::string s = Base64::unicode2Ansii(ws.c_str(), CP_UTF8);

		CFile f;
		CFileException e;
		if (!f.Open(path, CFile::modeCreate | CFile::modeReadWrite, &e))
		{
			CString buffer;
			e.GetErrorMessage(buffer.GetBuffer(1024), 1024);
			AfxMessageBox(buffer);
			buffer.ReleaseBuffer();
			return false;
		}

		f.Write((char *)s.c_str(), sizeof(char) * s.size());
		f.Close();

		return true;
	}

	bool file2Json(LPCTSTR pszJson, WDocument &doc)
	{
		bool brel(false);
		if (!pszJson) return false;
		if (_taccess(pszJson, 0x0) != 0x0) return false;

		FILE *fp(NULL);
		char *readBuffer(NULL);
		do
		{
			fp = _tfopen(pszJson, _T("rb"));
			if (!fp) break;

			long fSize = getFileSize(fp);
			++fSize;

			readBuffer = new char[fSize];
			::memset(readBuffer, 0, sizeof(char) * (fSize));
			FileReadStream bis(fp, readBuffer, fSize);

			AutoUTFInputStream<unsigned, FileReadStream> eis(bis);
			doc.ParseStream<0, AutoUTF<unsigned> >(eis);

			if (readBuffer) delete[] readBuffer;
			if (fp) fclose(fp);

			return !doc.HasParseError();

		} while (false);

		return false;
	}

	WValue& addMember(WValue &v, LPCTSTR name, WValue &value)
	{
		if (!name) 
		{
			static WValue vTmp;
			return vTmp;
		}
		if (!v.IsObject()) v.SetObject();
		MIt it = v.FindMember(name);
		if (it != v.MemberEnd())
		{
			it->value.Swap(value);
		}
		else
		{
			WValue vName;
			vName.SetString(name, getJsonAllocator());
			v.AddMember(vName, value, getJsonAllocator());
		}
		return v;
	}

	WValue &addMember(WValue &v, LPCTSTR name, const int &value) { return addMember(v, name, WValue(value)); }

	WValue &addMember(WValue &v, LPCTSTR name, const bool &value) { return addMember(v, name, WValue(value)); }

	WValue &addMember(WValue &v, LPCTSTR name, const unsigned &value) { return addMember(v, name, WValue(value)); }

	WValue &addMember(WValue &v, LPCTSTR name, const __int64 &value) { return addMember(v, name, WValue(value)); }

	WValue &addMember(WValue &v, LPCTSTR name, const unsigned __int64 &value) { return addMember(v, name, WValue(value)); }

	WValue &addMember(WValue &v, LPCTSTR name, const double &value) { return addMember(v, name, WValue(value)); }

	WValue &addMember(WValue &v, LPCTSTR name, const float &value) { return addMember(v, name, WValue(value)); }

	WValue &addMember(WValue &v, LPCTSTR name, LPCTSTR value)
	{
		WValue vv;
		vv.SetString(value, getJsonAllocator());
		return addMember(v, name, vv);
	}

	WValue &pushBack(WValue &arr, WValue &value)
	{
		if (!arr.IsArray()) arr.SetArray();
		arr.PushBack(value, getJsonAllocator());
		return arr;
	}

	WValue &pushBack(WValue &arr, const int &value) { return pushBack(arr, WValue(value)); }

	WValue &pushBack(WValue &arr, const unsigned &value) { return pushBack(arr, WValue(value)); }

	WValue &pushBack(WValue &arr, const __int64 &value) { return pushBack(arr, WValue(value)); }

	WValue &pushBack(WValue &arr, const unsigned __int64 &value) { return pushBack(arr, WValue(value)); }

	WValue &pushBack(WValue &arr, const bool &value) { return pushBack(arr, WValue(value)); }

	WValue &pushBack(WValue &arr, const double &value) { return pushBack(arr, WValue(value)); }

	WValue &pushBack(WValue &arr, const float &value) { return pushBack(arr, WValue(value)); }

	WValue &pushBack(WValue &arr, LPCTSTR value) { return pushBack(arr, WValue(StringRef(value))); }

#pragma region LiteJosn

	SimpleRead::SimpleRead(LPCTSTR pszJson): _v(_doc), _err(eSuccess)
	{
		SHJson::string2Json(pszJson, _doc);
		if (_doc.HasParseError())
			_err = eParseError;
	}

	SimpleRead& SimpleRead::operator[](LPCTSTR key) const
	{
		if (!_v.IsObject())
			_err = eNotObject;

		if (!_v.HasMember(key))
			_err = eNoMember;

		if (_err == eSuccess)
			return SimpleRead(_v[key]);
		else
			return SimpleRead(_err);
	}

	SimpleRead& SimpleRead::operator[](int idx) const
	{
		if (!_v.IsArray())
			_err = eNotArray;

		if (idx < 0 || idx >= !_v.Size())
			_err = eArrayOver;

		if (_err == eSuccess)
			return SimpleRead(_v[idx]);
		else
			return SimpleRead(_err);
	}
#pragma endregion
}