SphinxResultBuilder.cpp

Go to the documentation of this file.

#include "SphinxResultBuilder.hpp"
#include "Exceptions.hpp"
#include <map>

namespace HCE {
namespace sphinx{
namespace reduce_task {

using namespace Poco;

SphinxResultBuilder::SphinxResultBuilder() {
}

SphinxResultBuilder::~SphinxResultBuilder() {
}

Poco::SharedPtr<SphinxResultData> SphinxResultBuilder::build(
        Poco::SharedPtr<SphinxReduceDataStorage> &sphinxDataStorage,
        const Poco::SharedPtr<HCE::reduce::core::ReduceResultIf> &sphinxReduceResult,
        const std::vector<SphinxRequestInfo>& requestInfo)
{
    SharedPtr<SphinxResultData> newSphinxResult(new SphinxResultData());
    fillMatchInfo(sphinxDataStorage, sphinxReduceResult, newSphinxResult);
    fillRequestInfo(requestInfo, newSphinxResult);
    return newSphinxResult;
}

Poco::SharedPtr<SphinxResultData> SphinxResultBuilder::buildFromUsingKeys(
                 const Poco::SharedPtr<SphinxResultData> &sphinxResultData,
                 std::vector<std::pair<std::string, unsigned long long> > &selectWeightKeys)
{
  SharedPtr<SphinxResultData> newSphinxResult(new SphinxResultData());
  fillMatchDataBaseOnKeys(sphinxResultData, selectWeightKeys, newSphinxResult);
  fillRequestInfoBaseOnResultData(sphinxResultData, newSphinxResult);
  return newSphinxResult;
}

void SphinxResultBuilder::fillMatchInfo(
                  Poco::SharedPtr<SphinxReduceDataStorage> &sphinxDataStorage,
                  Poco::SharedPtr<HCE::reduce::core::ReduceResultIf> sphinxReduceResult,
                  Poco::SharedPtr<SphinxResultData>& newSphinxResultData)
{
  std::string key = "";
  std::string value = "";
  SphinxReduceDataStorage::DataRangeIterator matchInfoIter;

  sphinxReduceResult->reset();
  while(sphinxReduceResult->hasNext()){
    sphinxReduceResult->getNext(key, value);
    matchInfoIter = sphinxDataStorage->getData(key + value);
    if (matchInfoIter.first == matchInfoIter.second){
      throw reduce::NotFoundByKeyException("SphinxResultBuilder - not found " + key + value);
    }
    newSphinxResultData->addMatchInfo(matchInfoIter.first->second);
  }
}

void SphinxResultBuilder::fillRequestInfo(
                          const std::vector<SphinxRequestInfo>& requestInfo,
                          Poco::SharedPtr<SphinxResultData>& newSphinxResultData)
{
  for (size_t infoIndex = 0; infoIndex < requestInfo.size(); ++infoIndex){
    newSphinxResultData->addRequestInfo(requestInfo[infoIndex]);
  }
}

void SphinxResultBuilder::fillMatchDataBaseOnKeys(
                        const Poco::SharedPtr<SphinxResultData> &sphinxResultData,
                        std::vector<std::pair<std::string, unsigned long long> > &selectWeightKeys,
                        Poco::SharedPtr<SphinxResultData> &newSphinxResult)
{
  std::map<unsigned long long, SphinxMatchInfo> keysMatchInfo;
  std::map<unsigned long long, SphinxMatchInfo>::iterator bestMatchInfoIt;

  buildMatchInfoMap(keysMatchInfo, sphinxResultData);

  for (size_t matchIndex = 0; matchIndex < selectWeightKeys.size(); ++matchIndex){
    bestMatchInfoIt = keysMatchInfo.find(selectWeightKeys[matchIndex].second);
    if (bestMatchInfoIt != keysMatchInfo.end()){
      newSphinxResult->addMatchInfo(bestMatchInfoIt->second);
    }
  }
}

void SphinxResultBuilder::fillRequestInfoBaseOnResultData(
                        const Poco::SharedPtr<SphinxResultData> &sphinxResultData,
                        Poco::SharedPtr<SphinxResultData> &newSphinxResult)
{
  size_t totalRequestInfoNumber = sphinxResultData->getRequestInfoCount();
  for (size_t requestInfoIndex = 0; requestInfoIndex < totalRequestInfoNumber;
                                                        ++requestInfoIndex){
    newSphinxResult->addRequestInfo(sphinxResultData->getRequestInfoItem(requestInfoIndex));
  }
}

void SphinxResultBuilder::buildMatchInfoMap(std::map<unsigned long long, SphinxMatchInfo> &keysMatchInfo,
                                            const Poco::SharedPtr<SphinxResultData> &sphinxResultData)
{
  size_t totalMatchInfoNumber = sphinxResultData->getMatchInfoCount();
  for(size_t keyIndex = 0; keyIndex < totalMatchInfoNumber; ++keyIndex){
     SphinxMatchInfo matchInfo = sphinxResultData->getMatchInfoItem(keyIndex);
     keysMatchInfo.insert(std::make_pair(matchInfo.getDocId(), matchInfo));
  }
}


}
}
}