SphinxResultDataSerializator.hpp

Go to the documentation of this file.

#ifndef SPHINX_RESULT_DATA_SERIALIZATOR_HPP
#define SPHINX_RESULT_DATA_SERIALIZATOR_HPP

#include "SphinxResultData.hpp"
#include "JsonSerializable.hpp"

namespace HCE
{
namespace sphinx
{
//-----------------------------------------------------------------------------
namespace search_result_json_const
{
  // match info field names
  const std::string docId = "Id";
  const std::string weight = "W";
  const std::string attrArray = "At";
  const std::string matchInfo = "MI";

  // request info field names
  const std::string nodeName = "node";
  const std::string query = "q";
  const std::string queryId = "qid";
  const std::string maxResultsNumber = "max";
  const std::string orderBy = "order";
  const std::string total = "r";
  const std::string totalFound = "f";
  const std::string timeMsec = "time";

  // word info field names
  const std::string word = "w";
  const std::string hits = "h";
  const std::string docs = "d";
  const std::string wordArray = "WI";
  const std::string requestInfo = "RI";

  // sphinx weight field added in attributes
  const std::string sphinxWeight = "sw";
  const std::string sphinxDocumentId = "id";

  // fields for extend culculate weight algirithm
  const std::string calcWeight = "weight";
  const std::string calcDocId = "doc_id";
  const std::string calcNodeNumber = "node_number";
  const std::string calcNodeName = "node_name";

} // end namespace search_result_json_const
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class SphinxWeightPacker
{
  const char delimiter = ':';
  unsigned int fieldsCount;
  unsigned int fieldWidth;
public:
  explicit SphinxWeightPacker(unsigned int fieldsCount_=0, unsigned int fieldWidth_=HEX_STRING_LENGTH) : fieldsCount(fieldsCount_), fieldWidth(fieldWidth_) {}
  std::string pack(const std::string& data, unsigned int minNumberFieldsPacking);
  std::string unpack(const std::string& data);
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
enum  // list const use for setting JSON type of SphinxResultDataSerializator
{
  NO_FILL=0,
  FILL_MATCH_INFO=1,
  FILL_REQUEST_INFO=2,
  FILL_ATTRIBUTES=4,
  FILL_WORD_INFO=8
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class SphinxResultDataSerializator : public IJsonSerializable
{
public:
  typedef unsigned int JsonType;

public:
  explicit SphinxResultDataSerializator(SphinxResultData& resultData);
  SphinxResultDataSerializator(SphinxResultData& resultData, const std::string& json);
  SphinxResultDataSerializator(SphinxResultData& resultData, SphinxResultDataSerializator::JsonType jsonType);
  ~SphinxResultDataSerializator(void);

  bool serialize(SphinxResultDataSerializator::JsonType jsonType, std::string& json, unsigned int fieldCount=0, unsigned int minNumberFieldsPacking=0);
  bool serialize(std::string& json, unsigned int fieldCount, unsigned int minNumberFieldsPacking);
  bool serialize(std::string& json);
  bool unserialize(const std::string& json);

  void setJsonType(SphinxResultDataSerializator::JsonType jsonType_) {jsonType=jsonType_;}
  SphinxResultDataSerializator::JsonType getJsonType(void) const {return jsonType;}

private:
  SphinxResultData& resultData;
  JsonType jsonType;

typedef IJsonSerializable inherited;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class SphinxDefaultJSON
{
public:
  explicit SphinxDefaultJSON(unsigned int matchesCount=0, unsigned int attributesCount=0,
      unsigned int maxResultNumber=0);
  ~SphinxDefaultJSON() {}

  bool makeJSON(unsigned int matchesCount=0, unsigned int attributesCount=0,
      unsigned int maxResultNumber=0);

  const std::string& getJSON(void) const {return json;}
  const std::string& getErrorMsg(void) const {return errorMsg;}
  unsigned int getErrorCode(void) const {return errorCode;}
  bool isError(void) const {return _isError;}
private:
  bool fillResultData(SphinxResultData& resultData, unsigned int matchesCount, unsigned int attributesCount, unsigned int maxResultNumber);
private:
  std::string json;
  std::string errorMsg;
  unsigned int errorCode;
  bool _isError;

  friend std::ostream& operator<<(std::ostream& os, const SphinxDefaultJSON& defaultJson);
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // namespace sphinx 
} // namespace HCE 

#endif // SPHINX_RESULT_DATA_SERIALIZATOR_HPP