DRCETasksQueue.cpp

Go to the documentation of this file.

#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 "DRCEError.hpp"
#include "DRCEMessageConst.hpp"
#include "DRCETasksQueue.hpp"

namespace HCE
{
namespace drce
{
//-----------------------------------------------------------------------------
TaskStatusData::TaskStatusData(void)
: id(0), sdate(0), state(DRCETaskRequest::TaskState::UNDEFINED), tmode(SessionOptions::ThreadMode::tmAsync)
{
}
//-----------------------------------------------------------------------------
TaskStatusData::TaskStatusData(unsigned int id_, size_t sdate_, DRCETaskRequest::TaskState state_, SessionOptions::ThreadMode tmode)
: id(id_), sdate(sdate_), state(state_), tmode(tmode)
{
}
//-----------------------------------------------------------------------------
TaskStatusData::TaskStatusData(const TaskStatusData& rhs)
: id(0), sdate(0), state(DRCETaskRequest::TaskState::UNDEFINED), tmode(SessionOptions::ThreadMode::tmAsync)
{
  (*this) = rhs;
}
//-----------------------------------------------------------------------------
TaskStatusData::TaskStatusData(TaskStatusData&& rhs)
: id(0), sdate(0), state(DRCETaskRequest::TaskState::UNDEFINED), tmode(SessionOptions::ThreadMode::tmAsync)
{
  (*this) = std::forward<TaskStatusData>(rhs);
}
//-----------------------------------------------------------------------------
TaskStatusData& TaskStatusData::operator=(const TaskStatusData& rhs)
{
  if (this!=&rhs)
  {
    id = rhs.id;
    sdate = rhs.sdate;
    state = rhs.state;
    tmode = rhs.tmode;
  }
  return *this;
}
//-----------------------------------------------------------------------------
TaskStatusData& TaskStatusData::operator=(TaskStatusData&& rhs)
{
  if (this!=&rhs)
  {
    id = std::move(rhs.id);
    sdate = std::move(rhs.sdate);
    state = std::move(rhs.state);
    tmode = std::move(rhs.tmode);
  }
  return *this;
}
//-----------------------------------------------------------------------------
void TaskStatusData::clear(void)
{
  id = 0;
  sdate = 0;
  state = DRCETaskRequest::TaskState::UNDEFINED;
  tmode = SessionOptions::ThreadMode::tmAsync;
}
//-----------------------------------------------------------------------------
std::ostream& operator<<(std::ostream& os, const TaskStatusData& rhs)
{
  os << rhs.id << " " << rhs.sdate << " " << static_cast<unsigned int>(rhs.state) << " " << static_cast<unsigned int>(rhs.tmode);
  return os;
}
//-----------------------------------------------------------------------------
std::istream& operator>>(std::istream& is, TaskStatusData& rhs)
{
  is >> rhs.id;
  is >> rhs.sdate;
  unsigned int state(0), tmode(0);
  is >> state;
  rhs.state = static_cast<DRCETaskRequest::TaskState>(state);
  is >> tmode;
  rhs.tmode = static_cast<SessionOptions::ThreadMode>(tmode);
  return is;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
DRCETasksQueue::DRCETasksQueue(void)
: DRCECommonList <TaskStatusData>(), IJsonSerializable()
{
}
//-----------------------------------------------------------------------------
bool DRCETasksQueue::serialize(std::string& json)
{
  _isError = false;
  errorCode = NO_ERROR;
  errorMsg.clear();
  try
  {
    Poco::JSON::Array::Ptr pItems = new Poco::JSON::Array();
    if (pItems.isNull())
      throw Poco::Exception(message_const::objectInstanceWasNotCreated);

    for (size_t i=0;i<getItemsCount();++i)
    {
      Poco::JSON::Object::Ptr pItemElem = new Poco::JSON::Object();

      if (!pItemElem.isNull())
      {
        TaskStatusData taskStatusData(getItem(i));
        pItemElem->set(drce_json_message_const::id, taskStatusData.id);
        pItemElem->set(drce_json_message_const::sdate, taskStatusData.sdate);
        pItemElem->set(drce_json_message_const::state, static_cast<unsigned int>(taskStatusData.state));
        pItemElem->set(drce_json_message_const::tmode, static_cast<unsigned int>(taskStatusData.tmode));
        pItems->add(pItemElem);
      }
    }

    std::stringstream ostr;
    Poco::JSON::Stringifier::stringify(pItems, 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 DRCETasksQueue::unserialize(const std::string& json)
{
  _isError = false;
  clear();
  errorCode = NO_ERROR;
  errorMsg.clear();

  try
  {
    Poco::JSON::Parser parser;
    Poco::Dynamic::Var res = parser.parse(json);

    Poco::Dynamic::Var tmp;
    Poco::JSON::Array::Ptr pItems = res.extract<Poco::JSON::Array::Ptr>();
    if (!pItems.isNull())
    {
      for (size_t i=0;i<pItems->size();++i)
      {
        Poco::JSON::Object::Ptr pItemElem = pItems->getObject(i);
        if (!pItemElem.isNull())
        {
          TaskStatusData taskStatusData;

          Poco::Dynamic::Var tmp = pItemElem->get(drce_json_message_const::id);
          taskStatusData.id = convertVarToNumeric<unsigned int>(tmp, 0);

          tmp = pItemElem->get(drce_json_message_const::sdate);
          taskStatusData.sdate = convertVarToNumeric<size_t>(tmp, 0);

          tmp = pItemElem->get(drce_json_message_const::state);
          taskStatusData.state = static_cast<DRCETaskRequest::TaskState>(convertVarToNumeric<unsigned int>(tmp, 0));

          tmp = pItemElem->get(drce_json_message_const::tmode);
          taskStatusData.tmode = static_cast<SessionOptions::ThreadMode>(convertVarToNumeric<unsigned int>(tmp, 0));

          addItem(std::forward<TaskStatusData>(taskStatusData));
        }
      }
    }
    _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;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // end namespace drce 
} // end namespace HCE