HighlightComponent.cpp

Go to the documentation of this file.

#include <exception>
#include <iostream>
#include <msgpack.hpp>
#include <Poco/Random.h>
#include <unistd.h>

#include "InDataHighlight.hpp"
#include "HighlightComponent.hpp"
#include "HighlightAlgorithmException.hpp"
#include "OutDataHighlight.hpp"
#include "SerializeCacheData.hpp"

using namespace HCE::exception;

namespace HCE
{
  namespace component
  {
    HighlightStringGenerator &HighlightComponent::getHighlightStringGeneratorReference()
    {
      return highlightStringGenerator;
    }
    
    Poco::SharedPtr<DataBase> HighlightComponent::process(Poco::SharedPtr<DataBase> inData)
    {
      Poco::SharedPtr<DataBase> ret = nullptr;
      Poco::SharedPtr<InDataHighlight> inDataHiglight = inData.cast<InDataHighlight>();
      if(!inDataHiglight.isNull())
      {
        ret = Poco::SharedPtr<DataBase>(new OutDataHighlight(HCE::CT_HIGHLIGHT));
        if(!inDataHiglight->getCrossThreadBufPtr().isNull())
        {
          unsigned int index = 0;
          unsigned int highlightCounter = 0;
          unsigned long long id = 0llu;
          unsigned long long resCrc = 0llu;
          std::string outPutStr;
          ContentsStorageBase::WordPosPtrType wordMapPtr = nullptr;
          std::string &incomeContent = inDataHiglight->getCrossThreadBufPtr()->getIntData(index, id, resCrc);
          Poco::SharedPtr<InDataStruct> inDataStructPtr = inDataHiglight->getInDataStructPtr();
          Poco::SharedPtr<ContentsStorageBase> contentsStoragePtr = inDataHiglight->getContentsStorageBasePtr();
          Poco::SharedPtr<std::string> contentStringPtr = nullptr;
          if(!incomeContent.empty() && !inDataStructPtr.isNull() && !contentsStoragePtr.isNull() && inDataStructPtr->getParamsCount() > 0)
          {
            wordMapPtr = contentsStoragePtr->wordMapExctract(resCrc, incomeContent);
            contentStringPtr = Poco::SharedPtr<std::string>(new std::string(incomeContent));
            highlightStringGenerator.setHlBegin(inDataStructPtr->getParams(0).beginMarker);
            highlightStringGenerator.setHlEnd(inDataStructPtr->getParams(0).endMarker);
            highlightStringGenerator.setWordMapPtr(wordMapPtr);
            highlightStringGenerator.setContent(contentStringPtr);
            highlightStringGenerator.setMaxNumber(inDataStructPtr->getParams(0).maxNumber);
            highlightStringGenerator.highlightStringStickerReinit(inDataStructPtr);
            try
            {
              outPutStr = highlightStringGenerator.highlightStringGenerate(inDataStructPtr->getSearchStrings());
            }
            catch(HighlightAlgorithmException &excp)
            {
            }
            catch(std::length_error &excp)
            {
            }
            highlightCounter = highlightStringGenerator.getHighlightCounts();
            if(inDataHiglight->getCrossThreadBufPtr()->getIsSendWordsMapBack())
            {
              SerializeCacheData serializeCacheData((*wordMapPtr), resCrc);
              msgpack::sbuffer &localMsgPackBuff = inDataHiglight->getCrossThreadBufPtr()->getElem(index).getMsgPackBuff();
              msgpack::pack(&localMsgPackBuff, serializeCacheData);
            }
            contentsStoragePtr->wordMapRelease(resCrc, wordMapPtr);
          }
          inDataHiglight->getCrossThreadBufPtr()->setOutData(outPutStr, highlightCounter, index);
          inDataHiglight->getCrossThreadBufPtr()->signal();
        }
      }
      return ret;
    }
  }
}