HighlightStringGenerator.cpp

Go to the documentation of this file.

#include "HighlightAlgorithmException.hpp"
#include "HighlightStringGenerator.hpp"

using namespace HCE::exception;

HighlightStringGenerator::HighlightStringGenerator():maxNumber(0xFFFFFFFF), wordMapPtr(nullptr), contentPtr(nullptr), hlBegin(""), hlEnd(""), highlightStringStickerPtr(nullptr)
{
}

HighlightStringGenerator::~HighlightStringGenerator()
{
}

std::vector<WordPos> HighlightStringGenerator::stickWordOffsetMaps(std::vector<std::map<unsigned int, WordPos> > &wordOffsetMaps)
{
  std::vector<WordPos> ret;
  std::map<unsigned int, WordPos> resultingMap;
  std::map<unsigned int, WordPos>::iterator resultingMapIt;
  if(wordOffsetMaps.size() > 0)
  {
    resultingMap = wordOffsetMaps[0];
    for(unsigned int i = 1; i < wordOffsetMaps.size(); i++)
    {
      for(auto it = wordOffsetMaps[i].begin(); it != wordOffsetMaps[i].end(); ++it)
      {
        if(it->first != it->second.beginOffset)
        {
          throw HighlightAlgorithmException("Error !!! in <wordOffsetMaps>, there's key not correspond WordPos.beginOffset field");
        }
        if((resultingMapIt = resultingMap.find(it->first)) != resultingMap.end())
        {
          if(resultingMapIt->second.endOffset < it->second.endOffset)
          {
            resultingMapIt->second.endOffset = it->second.endOffset;
          }
        }
        else
        {
          resultingMap.insert(std::pair<unsigned int, WordPos>(it->first, it->second));
        }
      }
    }
    joinOverlapElements(resultingMap, ret);
  }
  return ret;
}

void HighlightStringGenerator::joinOverlapElements(std::map<unsigned int, WordPos> &resultingMap, std::vector<WordPos> &ret)
{
  if(!resultingMap.empty())
  {
    ret.push_back(resultingMap.begin()->second);
    unsigned int retIndex = 1;
    auto it = resultingMap.begin();
    ++it;
    for(; it != resultingMap.end(); ++it)
    {
      if(it->second.beginOffset <= ret[retIndex - 1].endOffset)
      {
        if(it->second.endOffset > ret[retIndex - 1].endOffset)
        {
          ret[retIndex - 1].endOffset = it->second.endOffset;
        }
      }
      else
      {
        ret.push_back(it->second);
        retIndex++;
      }
    }
  }
}

std::string HighlightStringGenerator::highlightStringGenerate(std::vector<std::vector<std::pair<SearchType, std::string> > > &vecSearchStrings)
{
  std::string ret;
  if(!contentPtr.isNull() && !contentPtr->empty())
  {
    if(!highlightStringStickerPtr.isNull())
    {
      highlightStringStickerPtr->setHighlightedCounter(0);
    }    
    std::vector<std::map<unsigned int, WordPos> > wordOffsetMaps;
    for(unsigned int i = 0; i < vecSearchStrings.size(); i++)
    {
      if(vecSearchStrings[i].empty())
      {
        continue;
      }
      if(i >= highlightingAlgorithms.size() || highlightingAlgorithms[i].isNull())
      {
        std::string exceptionString = "Here no highlight Algorithm for [" + std::to_string(i) + "] Search string";
        throw HighlightAlgorithmException(exceptionString);
      }
      std::map<unsigned int, WordPos> wordOffsetMap;
      highlightingAlgorithms[i]->process(vecSearchStrings[i], contentPtr, wordMapPtr, wordOffsetMap);
      wordOffsetMaps.push_back(wordOffsetMap);
    }
    std::vector<WordPos> wordOffsets = stickWordOffsetMaps(wordOffsetMaps);
// Here's place for cutting algorithm    
    if(!highlightStringStickerPtr.isNull())
    {
      ret = highlightStringStickerPtr->fillOutPutStr(wordOffsets, (*contentPtr));
    }
  }
  return ret;
}
std::string HighlightStringGenerator::generateHighlightingAlgorithmsString(const std::string &separator)
{
  std::string ret;
  for(unsigned int i = 0; i < highlightingAlgorithms.size(); i++)
  {
    if(i > 0)
    {
      ret += separator;
    }
    ret += highlightingAlgorithms[i]->getName();
  }
  return ret;
}