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;
//  logMsg << "\nCalculateStrategyDefault::calculate\n";

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

 //     std::cout << "CalculateStrategyDefault::calculate  weight = " << resultData.getMatchInfoItem(i).getWeight() << std::endl;
 //     weightToStream(resultData.getMatchInfoItem(i).getWeight(), stringValue);  // obsolete

      stringValue << resultData.getMatchInfoItem(i).getWeight();
//      std::cout << "CalculateStrategyDefault::calculate  stringValue = " << stringValue.str() << std::endl;

      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;
//  logMsg << "\nCalculateStrategyUseFieldNames::calculate\n";

  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);
        }

  //      logMsg << std::dec << "Old (dec): " << resultData.getMatchInfoItem(i).getWeight() << "\tNew (hex): " << stringValue.str() << std::endl;
      }
      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