SphinxInputJsonMessage.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 <Poco/Base64Encoder.h>
#include <Poco/Base64Decoder.h>
#include <Poco/StreamCopier.h>

#include "SphinxError.hpp"
#include "SphinxInputJsonMessage.hpp"

#include "SphinxInputJsonMessageSearch.hpp"
#include "SphinxInputJsonMessageIndex.hpp"
#include "SphinxInputJsonMessageManage.hpp"

namespace HCE
{
namespace sphinx
{
//-----------------------------------------------------------------------------
SphinxInputJsonMessage::SphinxInputJsonMessage(const std::string& json)
:inherited(), messageType(SphinxInputJsonMessage::MessageType::mtSearch), messageBody(""), messageTTL(input_json_message_const::defaultTTLValue)
{
  if (!json.empty())
    unserialize(json);
}
//-----------------------------------------------------------------------------
SphinxInputJsonMessage::SphinxInputJsonMessage(SphinxInputJsonMessage::MessageType messageType_)
:inherited(), messageType(messageType_), messageBody(""), messageTTL(input_json_message_const::defaultTTLValue)
{
}
//-----------------------------------------------------------------------------
bool SphinxInputJsonMessage::serialize(std::string& json)
{
  _isError = false;
  errorMsg.clear();
  try
  {
    Poco::JSON::Object::Ptr obj = new Poco::JSON::Object();
    obj->set(input_json_message_const::messageType, static_cast<unsigned int>(messageType));
    obj->set(input_json_message_const::messageBody, messageBody);
    obj->set(input_json_message_const::messageTTL, messageTTL);

    std::stringstream ostr;
    Poco::JSON::Stringifier::stringify(obj, ostr);
    json = ostr.str();
  }
  catch(std::exception& e)
  {
    errorMsg = e.what();
    errorCode = ERROR_SERIALIZE;
    _isError = true;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
bool SphinxInputJsonMessage::unserialize(const std::string& json)
{
  messageType = SphinxInputJsonMessage::MessageType::mtSearch;
  messageTTL = input_json_message_const::defaultTTLValue;
  errorMsg.clear();
  _isError = false;
  try
  {
    Poco::JSON::Parser parser;
    Poco::Dynamic::Var res = parser.parse(json);
    Poco::JSON::Object::Ptr obj = res.extract<Poco::JSON::Object::Ptr>();

    Poco::Dynamic::Var tmp = obj->get(input_json_message_const::messageType);
    messageType = static_cast<MessageType>(convertVarToNumeric<unsigned long>(tmp, static_cast<unsigned long>(messageType)));

    tmp = obj->get(input_json_message_const::messageBody);
    if (tmp.isString())
      messageBody = tmp.convert<std::string>();

    if (messageBody.empty())
      throw Poco::Exception("Invalid body. Empty message.");

    tmp = obj->get(input_json_message_const::messageTTL);
    messageTTL = convertVarToNumeric<unsigned long>(tmp, messageTTL);
  }
  catch(Poco::JSON::JSONException& e)
  {
    errorMsg = e.message();
    errorCode = ERROR_UNSERIALIZE;
    _isError = true;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.message();
    errorCode = ERROR_UNSERIALIZE;
    _isError = true;
  }
  catch(std::exception& e)
  {
    errorMsg = e.what();
    errorCode = ERROR_UNSERIALIZE;
    _isError = true;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
std::istream& operator>>(std::istream& is, SphinxInputJsonMessage& jsonHandler)
{
  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());
  jsonHandler.unserialize(json);
  return is;
}
//-----------------------------------------------------------------------------
std::ostream& operator<<(std::ostream& os, const SphinxInputJsonMessage& jsonHandler)
{
  std::string json;
  if (const_cast<SphinxInputJsonMessage&>(jsonHandler).serialize(json))
    os << json;
  return os;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // end namespace sphinx
} // end namespace HCE