SphinxResultData.cpp

Go to the documentation of this file.

#include <iomanip>
#include <sstream>

#include "SphinxResultData.hpp"

namespace HCE
{
namespace sphinx
{
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
std::ostream& operator << (std::ostream& os, const HexString& rhs)
{
  return os << std::setfill('0') << std::setw(rhs.length) << std::hex << rhs.value;
}
//-----------------------------------------------------------------------------
std::string toHexString(unsigned long long value, unsigned long long length)
{
  std::ostringstream ostr;
  ostr << HexString(value, length);
  return ostr.str();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
SphinxResultData::SphinxResultData(void)
:matchInfoList(), requestInfoList()
{
}
//-----------------------------------------------------------------------------
SphinxResultData::SphinxResultData(size_t matchesCount)
:matchInfoList(matchesCount), requestInfoList()
{
  resize(matchesCount);
}
//-----------------------------------------------------------------------------
SphinxResultData::SphinxResultData(size_t matchesCount, size_t attributesCount)
:matchInfoList(matchesCount), requestInfoList()
{
  resize(matchesCount, attributesCount);
}
//-----------------------------------------------------------------------------
SphinxResultData::~SphinxResultData(void)
{
}
//-----------------------------------------------------------------------------
void SphinxResultData::addMatchInfo(const SphinxMatchInfo& match)
{
  matchInfoList.push_back(SphinxResultDataItem<SphinxMatchInfo>(match));
}
//-----------------------------------------------------------------------------
void SphinxResultData::addMatchInfo(SphinxMatchInfo&& match)
{
  matchInfoList.push_back(SphinxResultDataItem<SphinxMatchInfo>(std::forward<SphinxMatchInfo>(match)));
}
//-----------------------------------------------------------------------------
size_t SphinxResultData::getMatchInfoCount(void) const
{
  size_t count = matchInfoList.size();
  for (size_t i=0;i<count;++i)
  {
    if (matchInfoList[i].isEmpty())
    {
      count = i;
      break;
    }
  }
  return count;
}
//-----------------------------------------------------------------------------
const SphinxMatchInfo& SphinxResultData::getMatchInfoItem(size_t index) const
{
  return matchInfoList[index].getItem();
}
//-----------------------------------------------------------------------------
void SphinxResultData::setMatchInfoItem(size_t index, const SphinxMatchInfo& match)
{
  matchInfoList[index].setItem(match);
}
//-----------------------------------------------------------------------------
void SphinxResultData::setMatchInfoItem(size_t index, SphinxMatchInfo&& match)
{
  matchInfoList[index].setItem(std::forward<SphinxMatchInfo>(match));
}
//-----------------------------------------------------------------------------
void SphinxResultData::addRequestInfo(const SphinxRequestInfo& request)
{
  requestInfoList.push_back(SphinxResultDataItem<SphinxRequestInfo>(request));
}
//-----------------------------------------------------------------------------
void SphinxResultData::addRequestInfo(SphinxRequestInfo&& request)
{
  requestInfoList.push_back(SphinxResultDataItem<SphinxRequestInfo>(std::forward<SphinxRequestInfo>(request)));
}
//-----------------------------------------------------------------------------
size_t SphinxResultData::getRequestInfoCount(void) const
{
  size_t count = requestInfoList.size();
  for (size_t i=0;i<count;++i)
  {
    if (requestInfoList[i].isEmpty())
    {
      count = i;
      break;
    }
  }
  return count;
}
//-----------------------------------------------------------------------------
const SphinxRequestInfo& SphinxResultData::getRequestInfoItem(size_t index) const
{
  return requestInfoList[index].getItem();
}
//-----------------------------------------------------------------------------
// cppcheck-suppress unusedFunction
void SphinxResultData::setRequestInfoItem(size_t index, const SphinxRequestInfo& request)
{
  requestInfoList[index].setItem(request);
}
//-----------------------------------------------------------------------------
void SphinxResultData::setRequestInfoItem(size_t index, SphinxRequestInfo&& request)
{
  requestInfoList[index].setItem(std::forward<SphinxRequestInfo>(request));
}
//-----------------------------------------------------------------------------
void SphinxResultData::clear(void)
{
  const size_t matchInfoCount = matchInfoList.size();
  for (size_t i=0;i<matchInfoCount;++i)
    matchInfoList[i].getItem().clear();
  matchInfoList.clear();

  const size_t requestInfoCount = requestInfoList.size();
  for (size_t i=0;i<requestInfoCount;++i)
    requestInfoList[i].getItem().clear();
  requestInfoList.clear();
}
//-----------------------------------------------------------------------------
void SphinxResultData::reset(void)
{
  const size_t matchInfoCount = matchInfoList.size();
  for (size_t i=0;i<matchInfoCount;++i)
  {
    matchInfoList[i].getItem().reset();
    matchInfoList[i].isEmpty(true);
  }

  const size_t requestInfoCount = requestInfoList.size();
  for (size_t i=0;i<requestInfoCount;++i)
  {
    requestInfoList[i].getItem().reset();
    requestInfoList[i].isEmpty(true);
  }
}
//-----------------------------------------------------------------------------
void SphinxResultData::resize(size_t matchesCount)
{
  matchInfoList.resize(matchesCount);
  reset();
}
//-----------------------------------------------------------------------------
void SphinxResultData::resize(size_t matchesCount, size_t attributesCount)
{
  matchInfoList.resize(matchesCount);
  for (size_t i=0;i<matchesCount;++i)
    matchInfoList[i].getItem().resize(attributesCount);
  reset();
}
//-------------------------------------------------------------------
void SphinxResultData::clearRequestInfo(void)
{
  requestInfoList.clear();
}
//-------------------------------------------------------------------
void SphinxResultData::dump(std::ostream& os) const
{
  const size_t requestInfoCount = getRequestInfoCount();
  for (size_t i=0;i<requestInfoCount;++i)
  {
    os << "Query stats for '" << getRequestInfoItem(i).getNodeName() << "':\n";
    const size_t wordsCount = getRequestInfoItem(i).getWordsCount();
    for (size_t j=0;j<wordsCount;++j)
    {
      os << "\t'" << getRequestInfoItem(i).getWordItem(j).word << "' found "
          << getRequestInfoItem(i).getWordItem(j).hits << " times in "
          << getRequestInfoItem(i).getWordItem(j).docs << " documents\n";
    }

    os << "max: " << getRequestInfoItem(i).getMaxResultsNumber();
    os << ", order: " << getRequestInfoItem(i).getOrderBy();
    os << ", q: '" << getRequestInfoItem(i).getQuery() << "'";
    os << ", qid: " << getRequestInfoItem(i).getQueryId();
    os << ", r: " << getRequestInfoItem(i).getTotal();
    os << ", f: " << getRequestInfoItem(i).getTotalFound();
    os << ", time: " << getRequestInfoItem(i).getTimeMsec() << std::endl;
  }
  os << "Matches:\n";
  const size_t matchInfoCount = getMatchInfoCount();
  for (size_t i=0;i<matchInfoCount;++i)
  {
    os << "\tdocId = " << getMatchInfoItem(i).getDocId() << ", weight = " << getMatchInfoItem(i).getWeight();

    const size_t attributesCount = getMatchInfoItem(i).getAttributesCount();
    for (size_t j=0;j<attributesCount;++j)
    {
      os << ", " << getMatchInfoItem(i).getAttrItem(j).name << " = " << getMatchInfoItem(i).getAttrItem(j).value;
    }
    os << std::endl;
  }
  os << std::endl;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
std::ostream& operator << (std::ostream& os, const SphinxResultData& resultData)
{
  resultData.dump(os);
  return os;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // namespace sphinx 
} // namespace HCE