AdminClientsSerializator.cpp

Go to the documentation of this file.

#include <Poco/JSON/Object.h>
#include <Poco/JSON/Array.h>
#include <Poco/JSON/JSON.h>
#include <Poco/JSON/Stringifier.h>
#include <Poco/JSON/Parser.h>
#include <Poco/JSON/JSONException.h>
#include <Poco/Dynamic/Var.h>

#include "AdminClientsSerializator.hpp"

namespace HCE
{
namespace handlers
{
//-----------------------------------------------------------------------------
AdminClientsSerializator::AdminClientsSerializator(std::vector<ClientWorkerItem>& clients_)
: inherited(), clients(clients_), purgeCounter(0), refreshNotFoundCounter(0)
{

}
//-----------------------------------------------------------------------------
AdminClientsSerializator::AdminClientsSerializator(std::vector<ClientWorkerItem>& clients_,
    unsigned long long purgeCounter_, unsigned long long refreshNotFoundCounter_)
: inherited(), clients(clients_), purgeCounter(purgeCounter_), refreshNotFoundCounter(refreshNotFoundCounter_)
{

}
//-----------------------------------------------------------------------------
bool AdminClientsSerializator::serialize(std::string& json)
{
  resetError();
  try
  {
    Poco::JSON::Object::Ptr pObj = new Poco::JSON::Object();
    if (pObj.isNull())
      throw Poco::Exception("Object instance was not created");

    pObj->set(PURGE_COUNTER, static_cast<Poco::UInt64>(purgeCounter));
    pObj->set(REFRESH_NOT_FOUND_COUNTER, static_cast<Poco::UInt64>(refreshNotFoundCounter));
    pObj->set(CLIENTS_COUNT, clients.size());

    Poco::JSON::Array::Ptr pClients = new Poco::JSON::Array();
    if (!pClients.isNull())
    {
      for(std::vector<ClientWorkerItem>::iterator iter = clients.begin();iter!=clients.end();++iter)
      {
        Poco::JSON::Object::Ptr pClientElem = new Poco::JSON::Object();
        if (!pClientElem.isNull())
        {
          pClientElem->set(IDENTITY, (*iter).identity);
          pClientElem->set(COUNT, static_cast<Poco::UInt64>((*iter).count));
          pClientElem->set(FREQUENCY, static_cast<Poco::UInt64>((*iter).frequency));
          pClientElem->set(EXPIRY, (*iter).expiry);
          pClientElem->set(CPU, (*iter).cpu);
          pClientElem->set(IOWAIT, (*iter).iowait);
          pClients->add(pClientElem);
        }
      }
      pObj->set(CLIENTS, pClients);
    }

    std::stringstream ostr;
    Poco::JSON::Stringifier::stringify(pObj, ostr);
    json = ostr.str();

    _isError = false;
  }
  catch(Poco::Exception& e)
  {
    _isError = true;
    errorMsg = e.displayText();
    errorCode = ERROR_UNSERIALIZE;
  }
  catch(std::exception& e)
  {
    _isError = true;
    errorMsg = e.what();
    errorCode = ERROR_SERIALIZE;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
bool AdminClientsSerializator::unserialize(const std::string& json)
{
  clear();
  try
  {
    Poco::JSON::Parser parser;
    Poco::Dynamic::Var res = parser.parse(json);

    Poco::JSON::Object::Ptr pObj = res.extract<Poco::JSON::Object::Ptr>();

    if (!pObj.isNull())
    {
      Poco::Dynamic::Var tmp = pObj->get(PURGE_COUNTER);
      purgeCounter = convertVarToNumeric<unsigned long long>(tmp, 0);

      tmp = pObj->get(REFRESH_NOT_FOUND_COUNTER);
      refreshNotFoundCounter = convertVarToNumeric<unsigned long long>(tmp, 0);

      Poco::JSON::Array::Ptr pClients = pObj->getArray(CLIENTS);
      if (!pClients.isNull())
      {
        for (size_t i=0;i<pClients->size();++i)
        {
          Poco::JSON::Object::Ptr pClientElem = pClients->getObject(i);
          if (!pClientElem.isNull())
          {
            ClientWorkerItem clientWorkerItem;
            tmp = pClientElem->get(IDENTITY);
            if (tmp.isString())
              clientWorkerItem.identity = tmp.convert<std::string>();

            tmp = pClientElem->get(COUNT);
            clientWorkerItem.count = convertVarToNumeric<unsigned long long>(tmp, 0);

            tmp = pClientElem->get(FREQUENCY);
            clientWorkerItem.frequency = convertVarToNumeric<unsigned long long>(tmp, 0);

            tmp = pClientElem->get(EXPIRY);
            clientWorkerItem.expiry = convertVarToNumeric<int64_t>(tmp, 0);

            tmp = pClientElem->get(CPU);
            clientWorkerItem.cpu = convertVarToNumeric<double>(tmp, 0.0);

            tmp = pClientElem->get(IOWAIT);
            clientWorkerItem.iowait = convertVarToNumeric<double>(tmp, 0.0);

            clients.push_back(std::forward<ClientWorkerItem>(clientWorkerItem));
          }
        }
      }
    }
    _isError = false;
  }
  catch(Poco::JSON::JSONException& e)
  {
    _isError = true;
    errorMsg = e.displayText();
    errorCode = ERROR_UNSERIALIZE;
  }
  catch(Poco::Exception& e)
  {
    _isError = true;
    errorMsg = e.displayText();
    errorCode = ERROR_UNSERIALIZE;
  }
  catch(std::exception& e)
  {
    _isError = true;
    errorMsg = e.what();
    errorCode = ERROR_UNSERIALIZE;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
void AdminClientsSerializator::clear(void)
{
  resetError();
  clients.clear();
  purgeCounter = 0;
  refreshNotFoundCounter = 0;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
}// end namespace handlers 
} // end namespace HCE