HandlerProperties.cpp

Go to the documentation of this file.

#include <fstream>
#include <stdexcept>
#include <Poco/File.h>
#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 "HandlerProperties.hpp"
#include "HandlerTypes.hpp"

namespace HCE
{
namespace handlers
{
//-----------------------------------------------------------------------------
HandlerProperties::HandlerProperties(void)
: inherited(), IJsonSerializable()
{
}
//-----------------------------------------------------------------------------
bool HandlerProperties::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");

                for (ConstIterator iter=begin();iter!=end();++iter)
                {
                    pObj->set((*iter).first, (*iter).second);
                }

                std::stringstream ostr;
                Poco::JSON::Stringifier::stringify(pObj, ostr);
                json = ostr.str();
        }
        catch(Poco::Exception& e)
        {
                setIsError(true);
                setErrorMsg(e.displayText());
                setErrorCode(ERROR_UNSERIALIZE);
        }
        catch(std::exception& e)
        {
                setIsError(true);
                setErrorMsg(e.what());
                setErrorCode(ERROR_SERIALIZE);
        }
        return !isError();
}
//-----------------------------------------------------------------------------
bool HandlerProperties::unserialize(const std::string& json)
{
  resetError();
  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())
    {
      std::vector<std::string> names;
      pObj->getNames(names);

      for (size_t i=0;i<names.size();++i)
      {
        Poco::Dynamic::Var tmp = pObj->get(names[i]);
        if (!tmp.isEmpty())
        {
          if (tmp.isString())
          {
            setItem(names[i], tmp.convert<std::string>());
          }
          else if(tmp.isNumeric())
          {
            if (tmp.isInteger())
            {
              if (tmp.isSigned())
              {
                setItem(names[i], static_cast<long int>(tmp.convert<Poco::Int64>()));
              }
              else
              {
                setItem(names[i], static_cast<unsigned long int>(tmp.convert<Poco::UInt64>()));
              }
            }
            else
            {
              setItem(names[i], tmp.convert<double>());
            }
          }
        }
      }
    }
  }
  catch(Poco::JSON::JSONException& e)
  {
    setIsError(true);
    setErrorMsg(e.displayText());
    setErrorCode(ERROR_UNSERIALIZE);
  }
  catch(Poco::Exception& e)
  {
    setIsError(true);
    setErrorMsg(e.displayText());
    setErrorCode(ERROR_UNSERIALIZE);
  }
  catch(std::exception& e)
  {
    setIsError(true);
    setErrorMsg(e.what());
    setErrorCode(ERROR_UNSERIALIZE);
  }
  return !isError();
}
//-----------------------------------------------------------------------------
bool HandlerProperties::load(const std::string& fileName)
{
  bool result = false;
  resetError();
  try
  {
    Poco::File jsonFile(fileName);
    if (jsonFile.exists())
    {
      if (!jsonFile.isFile())
        throw std::runtime_error(fileName+" is not file");

      if (!jsonFile.canRead())
        throw std::runtime_error(fileName+" is cannot be read");

      std::ifstream ifs(fileName.c_str());
      if (!ifs.is_open())
        throw std::runtime_error(fileName+" is not opened");

      ifs >> (*this);
      ifs.close();
    }
    result = !isError();
  }
  catch(std::exception& e)
  {
    setIsError(true);
    setErrorCode(ERROR_LOAD_JSON_FILE);
    setErrorMsg(e.what());
  }
  return result;
}
//-----------------------------------------------------------------------------
bool HandlerProperties::save(const std::string& fileName)
{
  std::ofstream ofs(fileName, std::fstream::trunc);
  ofs << (*this);
  ofs.close();
  return Poco::File(fileName).exists();
}
//-----------------------------------------------------------------------------
std::istream& operator>>(std::istream& is, HandlerProperties& handlerProperties)
{
  std::string json;
  is.seekg(0, std::ios::end);
  json.resize(is.tellg());
  is.seekg(0, std::ios::beg);
  is.read(const_cast<char*>(json.c_str()), json.size());
  handlerProperties.unserialize(json);
  return is;
}
//-----------------------------------------------------------------------------
std::ostream& operator<<(std::ostream& os, const HandlerProperties& handlerProperties)
{
        std::string json;
        const_cast<HandlerProperties&>(handlerProperties).serialize(json);
        return os << json;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // end namespace handlers
} // end namespace HCE