SphinxDataSource.cpp

Go to the documentation of this file.

#include <Poco/DOM/DOMParser.h>
#include <Poco/DOM/DOMWriter.h>
#include <Poco/DOM/Document.h>
#include <Poco/DOM/NodeIterator.h>
#include <Poco/DOM/NodeFilter.h>
#include <Poco/DOM/AutoPtr.h>
#include <Poco/DOM/NamedNodeMap.h>
#include <Poco/XML/XMLWriter.h>
#include <Poco/DOM/Attr.h>

#include <Poco/SharedPtr.h>
#include <Poco/AutoPtr.h>

#include <fstream>
#include <sstream>

#include "SphinxDataSource.hpp"

namespace HCE
{
namespace sphinx
{
//-----------------------------------------------------------------------------
SphinxDataSource::SphinxDataSource(std::istream& istrSchema, std::istream& istrDocument)
:sourceSchema(istrSchema), sourceDocument(istrDocument), errorMsg(""), _IsError(false), maxDocId(0)
{
}
//-----------------------------------------------------------------------------
SphinxDataSource::~SphinxDataSource(void)
{
}
//-----------------------------------------------------------------------------
void SphinxDataSource::save(Poco::XML::Node* pNode, std::ostream& os)
{
  Poco::XML::DOMWriter writer;
  writer.setNewLine("\n");
  writer.setOptions(Poco::XML::XMLWriter::PRETTY_PRINT | Poco::XML::XMLWriter::WRITE_XML_DECLARATION);
  writer.writeNode(os, pNode);
}
//-----------------------------------------------------------------------------
bool SphinxDataSource::Process(std::ostream& os)
{
  errorMsg.clear();
  maxDocId = 0;  // maximum found document ID

  try
  {
    Poco::AutoPtr<Poco::XML::Document> pOutDoc = new Poco::XML::Document;
    Poco::AutoPtr<Poco::XML::Element> pRoot = pOutDoc->createElementNS(sphinx_data_source_const::namespaceURITag, sphinx_data_source_const::docsetTag);
    pOutDoc->appendChild(pRoot);

    Poco::XML::DOMParser parser;
    Poco::AutoPtr<Poco::XML::Document> pDoc = parser.parse(&sourceSchema);
    Poco::XML::NodeIterator it_schema(pDoc, Poco::XML::NodeFilter::SHOW_ALL);
    Poco::XML::Node* pNode = it_schema.nextNode();
    Poco::XML::Node* schemaNode = pNode;

    while (pNode)
    {
      if (pNode->nodeName() == sphinx_data_source_const::schemaTag)
      {
        schemaNode = pNode;
        break;
      }
      else
        pNode = it_schema.nextNode();
    }

    Poco::AutoPtr<Poco::XML::Element> pSchema = static_cast<Poco::XML::Element*>(pOutDoc->importNode(schemaNode, true));
    pRoot->appendChild(pSchema);

    pDoc = parser.parse(&sourceDocument);
    Poco::XML::NodeIterator it(pDoc, Poco::XML::NodeFilter::SHOW_ALL);
    pNode = it.nextNode();

    unsigned long long documents = 0; // count of documents
    unsigned long long foundMaxDocId = 0;
    while (pNode)
    {
      if (pNode->nodeName() == sphinx_data_source_const::documentTag)
      {
        Poco::AutoPtr<Poco::XML::Element> pDocument = static_cast<Poco::XML::Element*>(pOutDoc->importNode(pNode, true));
        pRoot->appendChild(pDocument);

        ++documents;

        Poco::AutoPtr<Poco::XML::NamedNodeMap> pMap =  pNode->attributes();
        if (!pMap.isNull())
        {
          for (size_t i=0;i<pMap->length();++i)
          {
            if (pMap->item(i)->nodeName()==sphinx_data_source_const::documentIdAttrTag)
            {
              try
              {
                foundMaxDocId = std::stoull(pMap->item(i)->nodeValue()); // pMap->item(i)->setNodeValue();
              }
              catch(...)
              {
                foundMaxDocId = 0;
              }
            }
          }
        }
        if (maxDocId < foundMaxDocId)
          maxDocId = foundMaxDocId;
      }
      pNode = it.nextNode();
    }

    Poco::AutoPtr<Poco::XML::Element> pHceParameters = pOutDoc->createElementNS(sphinx_data_source_const::namespaceURITag, sphinx_data_source_const::hceParametersTag);
    pRoot->appendChild(pHceParameters);

    Poco::AutoPtr<Poco::XML::Element> pHceDocs = pOutDoc->createElement(sphinx_data_source_const::hceDocsTag);
    pHceParameters->appendChild(pHceDocs);


    Poco::AutoPtr<Poco::XML::Attr> pAttrMaxDocId = pOutDoc->createAttribute(sphinx_data_source_const::maxDocIdAttrTag);
    Poco::XML::Attr* pAttrOld = pHceDocs->addAttributeNodeNP(0, pAttrMaxDocId.get());
    Poco::AutoPtr<Poco::XML::Attr> pAttrDocuments = pOutDoc->createAttribute(sphinx_data_source_const::documentsAttrTag);
    pHceDocs->addAttributeNodeNP(pAttrOld, pAttrDocuments.get());

    Poco::AutoPtr<Poco::XML::NamedNodeMap> pMap =  pHceDocs->attributes();
    if (!pMap.isNull())
    {
      for (size_t i=0;i<pMap->length();++i)
      {
        if (pMap->item(i)->nodeName()==sphinx_data_source_const::maxDocIdAttrTag)
          pMap->item(i)->setNodeValue(std::to_string(maxDocId));
        if (pMap->item(i)->nodeName()==sphinx_data_source_const::documentsAttrTag)
          pMap->item(i)->setNodeValue(std::to_string(documents));
      }
    }
    save(pOutDoc, os);

    _IsError = false;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.displayText();
    _IsError = true;
  }
  catch(std::exception& e)
  {
    errorMsg = e.what();
    _IsError = true;
  }
  return !_IsError;
}
//-----------------------------------------------------------------------------
std::ostream& operator << (std::ostream& os, const SphinxDataSource& dataSource) throw (Poco::Exception)
{
  std::stringstream out;
  const_cast<SphinxDataSource&>(dataSource).Process(out);
  if (dataSource.isError())
    throw Poco::Exception(dataSource.getErrorMsg());

  return os << out.str();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // end namespace sphinx
} // end namespace HCE