SphinxMatchInfo.cpp

Go to the documentation of this file.

#include "SphinxMatchInfo.hpp"
#include "SphinxResultData.hpp"

namespace HCE
{
namespace sphinx
{
//-------------------------------------------------------------------
AttrInfo::AttrInfo(const AttrInfo& rhs)
: name(""), value("")
{
  (*this) = rhs;
}
//-------------------------------------------------------------------
AttrInfo::AttrInfo(AttrInfo&& rhs)
: name(""), value("")
{
  (*this) = std::forward<AttrInfo>(rhs);
}
//-------------------------------------------------------------------
AttrInfo& AttrInfo::operator=(const AttrInfo& rhs)
{
  if (this != &rhs)
  {
    name = rhs.name;
    value = rhs.value;
  }
  return *this;
}
//-------------------------------------------------------------------
AttrInfo& AttrInfo::operator=(AttrInfo&& rhs)
{
  if (this != &rhs)
  {
    name = std::move(rhs.name);
    value = std::move(rhs.value);
  }
  return *this;
}
//-------------------------------------------------------------------
//-------------------------------------------------------------------
SphinxMatchInfo::SphinxMatchInfo(void)
:docId(0), weight(""), attributes()
{
}
//-------------------------------------------------------------------
SphinxMatchInfo::SphinxMatchInfo(size_t attributesCount)
:docId(0), weight(""), attributes(attributesCount)
{
}
//-------------------------------------------------------------------
SphinxMatchInfo::SphinxMatchInfo(const SphinxMatchInfo& rhs)
:docId(0), weight(""), attributes(rhs.getAttributes().size())
{
  (*this) = rhs;
}
//-------------------------------------------------------------------
SphinxMatchInfo::SphinxMatchInfo(SphinxMatchInfo&& rhs)
:docId(0), weight(""), attributes(rhs.getAttributes().size())
{
  (*this) = std::forward<SphinxMatchInfo>(rhs);
}
//-------------------------------------------------------------------
void SphinxMatchInfo::setWeightFromNumeric(unsigned long long weight, unsigned long long length)
{
  setWeightFromHexString(toHexString(weight, length));
}
//-------------------------------------------------------------------
void SphinxMatchInfo::setWeightFromHexString(const std::string& weight)
{
  setWeight(weight);
}
//-------------------------------------------------------------------
// cppcheck-suppress unusedFunction
void SphinxMatchInfo::setWeightFromDecString(const std::string& weight, unsigned long long length)
{
  unsigned long long value = 0;
  try
  {
    value = std::stoull(weight);
  }
  catch(std::exception&)
  {

  }
  setWeightFromNumeric(value, length);
}
//-------------------------------------------------------------------
SphinxMatchInfo& SphinxMatchInfo::operator=(const SphinxMatchInfo& rhs)
{
  if (this != &rhs)
  {
    docId = rhs.getDocId();
    weight = rhs.getWeight();
    attributes = rhs.getAttributes();
  }
  return *this;
}
//-------------------------------------------------------------------
SphinxMatchInfo& SphinxMatchInfo::operator=(SphinxMatchInfo&& rhs)
{
  if (this != &rhs)
  {
    docId = std::move(rhs.getDocId());
    weight = std::move(rhs.getWeight());
    attributes = std::move(rhs.getAttributes());
  }
  return *this;
}
//-------------------------------------------------------------------
void SphinxMatchInfo::addAttrInfo(const AttrInfo& attrInfo)
{
  attributes.push_back(SphinxResultDataItem<AttrInfo>(attrInfo));
}
//-------------------------------------------------------------------
void SphinxMatchInfo::addAttrInfo(AttrInfo&& attrInfo)
{
  attributes.push_back(SphinxResultDataItem<AttrInfo>(std::forward<AttrInfo>(attrInfo)));
}
//-------------------------------------------------------------------
void SphinxMatchInfo::addAttrInfo(const std::string& name, const std::string& value)
{
  addAttrInfo(std::forward<AttrInfo>(AttrInfo(name, value)));
}
//-------------------------------------------------------------------
const AttrInfo SphinxMatchInfo::getFieldByName(const std::string& attrName) const
{
  AttrInfo attrInfo;
  for (size_t i=0;i<attributes.size();++i)
  {
    if (attributes[i].getItem().name == attrName)
    {
      attrInfo = attributes[i].getItem();
      break;
    }
  }
  return attrInfo;
}
//-------------------------------------------------------------------
size_t SphinxMatchInfo::getAttributesCount(void) const
{
  size_t count = attributes.size();
  for (size_t i=0;i<count;++i)
  {
    if (attributes[i].isEmpty())
    {
      count = i;
      break;
    }
  }
  return count;
}
//-------------------------------------------------------------------
const AttrInfo& SphinxMatchInfo::getAttrItem(size_t index) const
{
  return attributes[index].getItem();
}
//-------------------------------------------------------------------
void SphinxMatchInfo::setAttrItem(size_t index, const AttrInfo& attr)
{
  attributes[index].setItem(attr);
}
//-------------------------------------------------------------------
void SphinxMatchInfo::setAttrItem(size_t index, AttrInfo&& attr)
{
  attributes[index].setItem(std::forward<AttrInfo>(attr));
}
//-------------------------------------------------------------------
void SphinxMatchInfo::clear(void)
{
  docId = 0;
  weight.clear();
  attributes.clear();
}
//-------------------------------------------------------------------
void SphinxMatchInfo::reset(void)
{
  docId = 0;
  weight.clear();
  const size_t count = attributes.size();
  for (size_t i=0;i<count;++i)
    attributes[i].isEmpty(true);
}
//-------------------------------------------------------------------
void SphinxMatchInfo::resize(size_t sz)
{
  attributes.resize(sz);
  reset();
}
//-------------------------------------------------------------------
//-------------------------------------------------------------------
} // namespace sphinx 
} // namespace HCE