ContentsStorageSimple.cpp

Go to the documentation of this file.

#include <Poco/Timestamp.h>

#include "ContentsStorageSimple.hpp"
#include "Defs.hpp"

#define INTERNAL_SLEEP 4000

void ContentsStorageSimple::fillWordPosMap(Poco::SharedPtr<HCE::OutDataRefine> outDataRefine, ContentsStorageBase::WordPosPtrType ret)
{
  if(!outDataRefine.isNull() && !ret.isNull())
  {
    CRC64 crc64;
    std::map<unsigned long long, std::vector<WordPos> > wordPos;
    unsigned long long key = 0llu;
    std::vector<HCE::CWords> cwords = outDataRefine->getCWords();
    unsigned int realWordPos = 0;
    for(unsigned int i = 0; i < cwords.size(); i++)
    {
      if(cwords[i].getWordType() != HCE::WORD_TYPE::WORD && cwords[i].getWordType() != HCE::WORD_TYPE::NUMBER)
      {
        continue;
      }
      key = crc64.calc(cwords[i].getNormWord().c_str(), cwords[i].getNormWord().length());
      auto it = wordPos.find(key);
      if(it == wordPos.end())
      {
        std::vector<WordPos> localVec;
        localVec.push_back(WordPos(cwords[i].getOffset(), cwords[i].getOffset() + cwords[i].getInitWordLen(), realWordPos, 0));
        wordPos.insert(std::pair<unsigned long long, std::vector<WordPos> >(key, localVec));
      }
      else
      {
        (*it).second.push_back(WordPos(cwords[i].getOffset(), cwords[i].getOffset() + cwords[i].getInitWordLen(), realWordPos, 0));
      }
      realWordPos++;
    }
    ret->push_back(wordPos);
  }
}

ContentsStorageBase::WordPosPtrType ContentsStorageSimple::wordMapExctract(unsigned long long key, std::string &incomeContent)
{
  WordPosPtrType ret = nullptr;
  auto it = wordPosCache.find(key);
  if(it == wordPosCache.end())
  {
    ContentsStorageBase::RefinePtrType refinePtr = ContentsStorageBase::refineExctract();
    if(!refinePtr.isNull())
    {
      ret = WordPosPtrType(new std::vector<std::map<unsigned long long, std::vector<WordPos> > >);
      Poco::SharedPtr<HCE::DataBase> inData = nullptr;
      Poco::SharedPtr<HCE::DataBase> outDataContent = nullptr;
      
      inData = Poco::SharedPtr<HCE::DataBase>(new HCE::InDataRefine(HCE::CT_REFINE));
      inData.cast<HCE::InDataRefine>()->setNormalizationId(DEFAULT_NORMALIZATION_WITHOUT);
      inData.cast<HCE::InDataRefine>()->setSubjectMask(DEFAULT_SUBJECT_MASK);
      inData.cast<HCE::InDataRefine>()->setContent(incomeContent);
      outDataContent = refinePtr->process(inData);
      
      fillWordPosMap(outDataContent.cast<HCE::OutDataRefine>(), ret);
      
      inData = Poco::SharedPtr<HCE::DataBase>(new HCE::InDataRefine(HCE::CT_REFINE));
      inData.cast<HCE::InDataRefine>()->setNormalizationId(DEFAULT_NORMALIZATION_WITH);
      inData.cast<HCE::InDataRefine>()->setSubjectMask(DEFAULT_SUBJECT_MASK);
      inData.cast<HCE::InDataRefine>()->setContent(incomeContent);
      outDataContent = refinePtr->process(inData);
      ContentsStorageBase::refineRelease(refinePtr);
      
      fillWordPosMap(outDataContent.cast<HCE::OutDataRefine>(), ret);
/*      TODO
      std::pair<unsigned long long, std::pair<WordPosPtrType, Poco::SharedPtr<std::atomic_flag> > > element;
      element.first = key;
      element.second.first = ret;
      element.second.second->test_and_set(std::memory_order_acquire);
      wordPosCache.insert(element);
*/
    }    
  }
  else
  {
    while((*it).second.second->test_and_set(std::memory_order_acquire))
    {
      usleep(INTERNAL_SLEEP);
    }
    ret = (*it).second.first;
  }
  return ret;
}

void ContentsStorageSimple::wordMapRelease(unsigned long long key, ContentsStorageBase::WordPosPtrType &refinePtr)
{
  auto it = wordPosCache.find(key);
  if(it != wordPosCache.end())
  {
    (*it).second.second->clear(std::memory_order_release);
  }
  refinePtr = nullptr;
}

void ContentsStorageSimple::cacheAddElement(unsigned long long key, ContentsStorageBase::WordPosPtrType wordPos)
{
  auto it = wordPosCache.find(key);
  if(it == wordPosCache.end())
  {
    std::pair<unsigned long long, std::pair<WordPosPtrType, Poco::SharedPtr<std::atomic_flag> > > element;
    element.first = key;
    element.second.first = wordPos;
    element.second.second = Poco::SharedPtr<std::atomic_flag>(new std::atomic_flag());
    element.second.second->clear(std::memory_order_release);
    wordPosCache.insert(element);   
  }
}

// cppcheck-suppress unusedFunction  
void ContentsStorageSimple::cacheClear()
{
  for(auto it = wordPosCache.begin(); it != wordPosCache.end(); ++it)
  {
    while((*it).second.second->test_and_set(std::memory_order_acquire))
    {
      usleep(INTERNAL_SLEEP);
    }
    (*it).second.second->clear(std::memory_order_release);
  }
  wordPosCache.clear();
}

ContentsStorageSimple::ContentsStorageSimple(unsigned int refinesCount):ContentsStorageBase(refinesCount)
{
}

ContentsStorageSimple::~ContentsStorageSimple()
{
}