SphinxInputJsonMessageIndex.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 "SphinxError.hpp"
#include "SphinxInputJsonMessageIndex.hpp"
#include "SphinxInputJsonMessage.hpp"

namespace HCE
{
namespace sphinx
{
//-----------------------------------------------------------------------------
SphinxInputJsonMessageIndex::SphinxInputJsonMessageIndex(const std::string& json)
:inherited(), indexName(""), documentFile(""), params()
{
  if (!json.empty())
    unserialize(json);
}
//-----------------------------------------------------------------------------
// cppcheck-suppress unusedFunction
void SphinxInputJsonMessageIndex::addParameters(const std::string& paramName, const std::string& paramValue)
{
  params.push_back(std::make_pair(paramName, paramValue));
}
//-----------------------------------------------------------------------------
bool SphinxInputJsonMessageIndex::serialize(std::string& json)
{
  _isError = false;
  errorMsg.clear();
  try
  {
    Poco::JSON::Object::Ptr obj = new Poco::JSON::Object();
    obj->set(input_json_message_const::indexName, indexName);
    obj->set(input_json_message_const::documentFile, documentFile);

    Poco::JSON::Array::Ptr vec = new Poco::JSON::Array();
    obj->set(input_json_message_const::queryParameters, vec);

    for (size_t i=0;i<params.size();++i)
    {
      Poco::JSON::Object::Ptr elem = new Poco::JSON::Object();
      vec->add(elem);
      elem->set(params[i].first, params[i].second);
    }

    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 SphinxInputJsonMessageIndex::unserialize(const std::string& json)
{
  indexName.clear();
  documentFile.clear();
  params.clear();
  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::indexName);
    if (tmp.isString())
      indexName = tmp.convert<std::string>();

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

    Poco::JSON::Array::Ptr queryParameters = obj->getArray(input_json_message_const::queryParameters);
    if (!queryParameters.isNull())
    {
      for (size_t j = 0;j <queryParameters->size();++j)
      {
        tmp = queryParameters->get(j);
        if (tmp.isEmpty())
          continue;

        if (tmp.type() == typeid(Poco::JSON::Object::Ptr))
        {
          Poco::JSON::Object::Ptr elem = tmp.extract<Poco::JSON::Object::Ptr>();
          std::vector<std::string> vecNames;
          elem->getNames(vecNames);
          for (size_t i=0;i<vecNames.size();++i)
          {
            tmp = elem->get(vecNames[i]);
            if (tmp.isString())
              params.push_back(std::make_pair(vecNames[i], tmp.convert<std::string>()));
          }
        }
      }
    }
    else
      throw Poco::JSON::JSONException (std::string("array '").append(input_json_message_const::queryParameters).append("' not found"));

  }
  catch(Poco::JSON::JSONException& e)
  {
    errorMsg = e.displayText();
    errorCode = ERROR_UNSERIALIZE;
    _isError = true;
  }
  return !_isError;
}
//-----------------------------------------------------------------------------
std::istream& operator>>(std::istream& is, SphinxInputJsonMessageIndex& messageIndex)
{
  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());
  messageIndex.unserialize(json);
  return is;
}
//-----------------------------------------------------------------------------
std::ostream& operator<<(std::ostream& os, const SphinxInputJsonMessageIndex& messageIndex)
{
  std::string json;
  const_cast<SphinxInputJsonMessageIndex&>(messageIndex).serialize(json);
  return os << json;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // end namespace sphinx
} // end namespace HCE