SphinxWeightCalculator.cpp

Go to the documentation of this file.

#include <iostream>
#include <sstream>
#include <utility>
#include <string.h>

#include "SphinxWeightCalculator.hpp"
#include "SphinxResultDataSerializator.hpp"

namespace HCE
{
namespace sphinx
{
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CalculateStrategy::weightToStream(const std::string& input, std::ostream& os) throw (std::exception)
{
  if (input.empty())
    os << HexString(0);
  else
    os << HexString(std::stoull(input));
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
Poco::SharedPtr<CalculateStrategy> CalculateStrategyFactory::create(const std::string& weightAlgirithm)
{
  Poco::SharedPtr<CalculateStrategy> strategy = nullptr;
  try
  {
    if (weightAlgirithm.empty())
      throw 1;

    switch(std::stoul(weightAlgirithm))
    {
      case CalculateStrategy::StrategyTypes::stUseFieldNames: strategy = new CalculateStrategyUseFieldNames();
        break;
      default: strategy = new CalculateStrategyDefault();
    }
  }
  catch(...)
  {
    strategy = new CalculateStrategyDefault();
  }
  return strategy;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void SphinxWeightCalculator::calculate(const std::vector<std::string>& orderFields, SphinxResultData& resultData)
{
  if (!strategy.isNull())
  {
    strategy->calculate(orderFields, resultData);
    logString = strategy->getLogString();
  }
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CalculateStrategyDefault::calculate(const std::vector<std::string>& orderFields, SphinxResultData& resultData)
{
  std::stringstream logMsg;

  try
  {
    const size_t matchesCount = resultData.getMatchInfoCount();
    for (size_t i=0;i<matchesCount;++i)
    {
      std::stringstream stringValue;
      stringValue << resultData.getMatchInfoItem(i).getWeight();

      SphinxMatchInfo matchInfo(std::forward<const SphinxMatchInfo&>(resultData.getMatchInfoItem(i)));
      matchInfo.setWeight(stringValue.str());
      resultData.setMatchInfoItem(i, std::forward<SphinxMatchInfo>(matchInfo));
    }
  }
  catch(std::exception& e)
  {
    logMsg.str("");
    logMsg << e.what();
  }
  logString = logMsg.str();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CalculateStrategyUseFieldNames::calculate(const std::vector<std::string>& orderFields, SphinxResultData& resultData)
{
  std::stringstream logMsg;

  try
  {
    const size_t matchesCount = resultData.getMatchInfoCount();
    for (size_t i=0;i<matchesCount;++i)
    {
      std::stringstream stringValue;
      if (orderFields.empty())
      {
        weightToStream(resultData.getMatchInfoItem(i).getWeight(), stringValue);
      }
      else
      {
        for (size_t k=0;k<orderFields.size();++k)
        {
          // search_result_json_const::calcWeight;
          // TODO
          weightToStream(resultData.getMatchInfoItem(i).getFieldByName(orderFields[k]).value, stringValue);
        }
      }
      SphinxMatchInfo matchInfo(std::forward<const SphinxMatchInfo&>(resultData.getMatchInfoItem(i)));
      matchInfo.setWeight(stringValue.str());
      resultData.setMatchInfoItem(i, std::forward<SphinxMatchInfo>(matchInfo));
    }
  }
  catch(std::exception& e)
  {
    logMsg.str("");
    logMsg << e.what();
  }
  logString = logMsg.str();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // namespace sphinx 
} // namespace HCE