libgfaservices/remanent/remvartbl.cpp

#include "remvar.h"
#include <algorithm>

/////////////////////////////////////////////////////////////////////////////

static bool _fncomp(const char *p1, const char *p2)
{
	return strcmp(p1, p2) < 0;
}

CRemVarTable::CRemVarTable(void) : m_map(_fncomp)
{
}

CRemVarTable::~CRemVarTable(void)
{
}

void CRemVarTable::AddVar(CRemanent *pVar)
{
	m_map[pVar->GetPath()] = pVar;
}

CRemanent* CRemVarTable::Find(const char *key) const
{
	std::map<const char*, CRemanent*>::const_iterator it = m_map.find(key);
	if(it == m_map.end())
		return NULL;
	return it->second;
}

bool CRemVarTable::GetMaxUpdateVariables(std::vector<const CRemanent*> &vars, size_t nMaxVars)
{
	unsigned long long nUpdateCount;
	vars.clear();
	std::map<const char*, CRemanent*>::const_iterator iBegin, iEnd;
	iEnd = m_map.cend();

	for(iBegin = m_map.cbegin(); iBegin != iEnd; iBegin++)
	{
		const CRemanent *pVar1 = iBegin->second;

		if((nUpdateCount = pVar1->GetUpdateCount()))
		{
			std::vector<const CRemanent*>::iterator vBegin, vEnd;
			vEnd = vars.end();

			for(vBegin = vars.begin(); vBegin != vEnd; vBegin++)
			{
				const CRemanent *pVar2 = *vBegin;

				if(pVar2->GetUpdateCount() < nUpdateCount)
					break;
			}

			vars.insert(vBegin, pVar1);

			if(vars.size() > nMaxVars)
				vars.pop_back();
		}
	}

	return true;
}

unsigned long CRemVarTable::LoadJSONValues(const Json::Value &jv)
{
	unsigned long parsed = 0;
	std::string s;
	ParseJsonMember(jv, s, parsed);
	return parsed;
}

void CRemVarTable::ParseJsonMember(const Json::Value &jv, std::string &sname, unsigned long &parsed)
{
	std::string s(sname);
	Json::ValueType vt = jv.type();

	switch(vt)
	{
	case Json::nullValue:
		break;
	case Json::intValue:
	case Json::uintValue:
	case Json::realValue:
	case Json::stringValue:
	case Json::booleanValue:
		ParseJsonScalar(jv, s, parsed);
		break;
	case Json::arrayValue:
		ParseJsonArray(jv, s, parsed);
		break;
	case Json::objectValue:
		ParseJsonObject(jv, s, parsed);
		break;
	}
}

void CRemVarTable::ParseJsonObject(const Json::Value &jv, std::string &sname, unsigned long &parsed)
{
	Json::Value::Members members = jv.getMemberNames();

	for(Json::Value::Members::const_iterator mem = members.begin(); mem != members.end(); mem++)
	{
		std::string s(sname);
		const std::string &rName = *mem;
		const Json::Value &m = jv[rName];
		if(s.size() > 0)
			s += "/";
		s += rName;
		ParseJsonMember(m, s, parsed);
	}
}

void CRemVarTable::ParseJsonArray(const Json::Value &jv, std::string &sname, unsigned long &parsed)
{
	int nIdx = 0;
	char szIndex[32];

	for(Json::Value::const_iterator val = jv.begin(); val != jv.end(); val++)
	{
		std::string s(sname);
		sprintf(szIndex, "[%d]", nIdx++);
		s += szIndex;
		ParseJsonMember(*val, s, parsed);
	}
}

void CRemVarTable::ParseJsonScalar(const Json::Value &jv, std::string &sname, unsigned long &parsed)
{
	CRemanent *pVar = Find(sname.c_str());
	if(pVar)
	{
		if(pVar->SetJSONValue(jv, true))
			parsed++;
		else
			printf("Failed to load value %s!\n", sname.c_str());
	}
	else
	{
		printf("Failed to load value %s!\n", sname.c_str());
	}
}