SphinxDataFile.cpp

Go to the documentation of this file.

#include <Poco/DOM/DOMParser.h>
#include <Poco/DOM/DOMWriter.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/SharedPtr.h>
#include <Poco/AutoPtr.h>

#include <fstream>
#include <sstream>

#include "SphinxDataFile.hpp"
#include "SphinxDataSource.hpp"
#include "SphinxMessageConst.hpp"

namespace HCE
{
namespace sphinx
{
//-----------------------------------------------------------------------------
SphinxDataFile::SphinxDataFile(void)
:pOutDoc(nullptr), errorMsg(""), _IsError(false)
{
  pOutDoc = new Poco::XML::Document;
  pRoot = pOutDoc->createElementNS(sphinx_data_source_const::namespaceURITag, sphinx_data_source_const::docsetTag);
  pOutDoc->appendChild(pRoot);
}
//-----------------------------------------------------------------------------
bool SphinxDataFile::append(std::istream& is)
{
  errorMsg.clear();
  try
  {
    Poco::XML::InputSource sourceDoc(is);
    Poco::XML::DOMParser parser;
    Poco::AutoPtr<Poco::XML::Document> pDoc = parser.parse(&sourceDoc);
    Poco::XML::NodeIterator it_doc(pDoc, Poco::XML::NodeFilter::SHOW_ALL);
    Poco::XML::Node* pNode = it_doc.nextNode();
    Poco::XML::Node* docNode = pNode;

    while (pNode)
    {
      if (pNode->nodeName() == sphinx_data_source_const::documentTag)
      {
        docNode = pNode;
        Poco::AutoPtr<Poco::XML::Element> pDocElem = static_cast<Poco::XML::Element*>(pOutDoc->importNode(docNode, true));
        pRoot->appendChild(pDocElem);
      }
      pNode = it_doc.nextNode();
    }

    _IsError = false;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.displayText();
    _IsError = true;
  }

  return !_IsError;
}
//-----------------------------------------------------------------------------
void SphinxDataFile::save(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, pOutDoc);
}
//-----------------------------------------------------------------------------
std::ostream& operator << (std::ostream& os, const SphinxDataFile& dataFile)
{
  const_cast<SphinxDataFile&>(dataFile).save(os);
  return os;
}
//-----------------------------------------------------------------------------
size_t SphinxDataFile::documentCount(std::istream& is)
{
  size_t count = 0;
  errorMsg.clear();
  try
  {
    Poco::XML::InputSource sourceDoc(is);
    Poco::XML::DOMParser parser;
    Poco::AutoPtr<Poco::XML::Document> pDoc = parser.parse(&sourceDoc);
    Poco::XML::NodeIterator it_doc(pDoc, Poco::XML::NodeFilter::SHOW_ALL);
    Poco::XML::Node* pNode = it_doc.nextNode();

    while (pNode)
    {
      if (pNode->nodeName() == sphinx_data_source_const::documentTag)
      {
        Poco::AutoPtr<Poco::XML::NamedNodeMap> pMap = pNode->attributes();
        if (!pMap.isNull())
        {
          for (size_t i=0;i<pMap->length();++i)
          {
            if (pMap->item(i)->nodeValue().empty())
              pMap->item(i)->setNodeValue("0");
          }
          ++count;
        }
      }
      pNode = it_doc.nextNode();
    }
    _IsError = false;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.displayText();
    _IsError = true;
  }
  return count;
}
//-----------------------------------------------------------------------------
bool SphinxDataFile::validateData(std::istream& is)
{
  errorMsg.clear();
  try
  {
    Poco::XML::InputSource sourceDoc(is);
    Poco::XML::DOMParser parser;
    Poco::AutoPtr<Poco::XML::Document> pDoc = parser.parse(&sourceDoc);
    Poco::XML::NodeIterator it_doc(pDoc, Poco::XML::NodeFilter::SHOW_ALL);
    Poco::XML::Node* pNode = it_doc.nextNode();

    while (pNode)
    {
      if (pNode->nodeName() == sphinx_data_source_const::documentTag)
      {
        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 && pMap->item(i)->nodeValue().empty())
              throw Poco::Exception(message_const::badXmlSource+message_const::space+pNode->nodeName()+message_const::point+
                  message_const::space+pMap->item(i)->nodeName()+message_const::space+message_const::valueIsEmpty);

            else if (pMap->item(i)->nodeName()==sphinx_data_source_const::documentIdAttrTag && !pMap->item(i)->nodeValue().empty())
            {
              try
              {
                std::stoull(pMap->item(i)->nodeValue());
              }
              catch(std::exception& e)
              {
                throw Poco::Exception(message_const::badXmlSource+message_const::space+pNode->nodeName()+message_const::point+
                    message_const::space+pMap->item(i)->nodeName()+message_const::space+message_const::cannotBeConvertToUnsignedLongLong);
              }
            }
          }
        }
        else
          throw Poco::Exception(message_const::badXmlSource+message_const::space+pNode->nodeName()+message_const::space+message_const::haveEmptyAttributeList);
      }
      pNode = it_doc.nextNode();
    }
    _IsError = false;
  }
  catch(Poco::Exception& e)
  {
    errorMsg = e.displayText();
    _IsError = true;
  }
  return !_IsError;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // namespace sphinx
} // namespace HCE