Reader.cc

Go to the documentation of this file.

#include <utl/Reader.h>
#include <utl/ReaderErrorReporter.h>
#include <utl/XercesUtil.h>
#include <utl/ErrorLogger.h>
#include <utl/AugerUnits.h>
#include <utl/AugerException.h>

#include <xercesc/dom/DOM.hpp>
#include <xercesc/dom/DOMImplementation.hpp>
#include <xercesc/dom/DOMImplementationLS.hpp>
#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/parsers/XercesDOMParser.hpp>
#include <xercesc/sax/HandlerBase.hpp>
#include <xercesc/framework/MemBufInputSource.hpp>
#include <xercesc/framework/MemBufFormatTarget.hpp>

#include <boost/filesystem.hpp>

using namespace xercesc;
using namespace std;


namespace utl {

  ReaderErrorReporter* Reader::fgErrReporter = nullptr;

  bool Reader::fgInitialized = false;


  Reader::Reader(const string& name, const EValidationType validationType)
  {
    Initialize();
    fTopBranch = Parse(name, validationType, Reader::eFromFile);
  }


  Reader::Reader(const ReaderStringInput& inputString, const EValidationType validationType)
  {
    Initialize();
    fTopBranch = Parse(inputString.GetInputString(), validationType, Reader::eFromMemBuf);
  }


  Reader::Reader(Branch& branch)
  {
    Initialize();
    if (branch.HasTopBranch())
      fTopBranch = branch.GetTopBranch();
  }


  void
  Reader::Initialize()
  {
    if (fgInitialized)
      return;

    fgInitialized = true;
    XMLPlatformUtils::Initialize();
    fgErrReporter = new ReaderErrorReporter();

#if 0
    // usually segfaults if reclaim of xerces memory is attempted
    if (std::atexit(Terminate))
      WARNING("Could not register Xerces cleanup at exit.");
#endif
  }


  void
  Reader::Terminate()
  {
    INFO("Xerces memory cleanup.");
    delete fgErrReporter;
    fgErrReporter = nullptr;
    XMLPlatformUtils::Terminate();
  }


  string
  Reader::GetUri()
    const
  {
    string name;
    if (fTopBranch) {
      DOMDocument* const doc = fTopBranch.GetDOMNode()->getOwnerDocument();
      if (doc) {
        const XMLCh* const uri = doc->getDocumentURI();
        if (uri)
          name = XercesPtrC(XMLString::transcode(uri)).Get();
      }
    }
    return name;
  }


  Branch
  Reader::Parse(const string& input,
                const EValidationType validationType,
                const EInputType inputType)
  {
    XercesDOMParser* parser = new XercesDOMParser;

    parser->setDoSchema(false);
    parser->setValidationScheme(XercesDOMParser::Val_Never);
    parser->setCreateEntityReferenceNodes(false);

    switch (validationType) {
    case eDTD:
      parser->setValidationScheme(XercesDOMParser::Val_Auto);
      break;
    case eSCHEMA:
      parser->setDoSchema(true);
      parser->setValidationScheme(XercesDOMParser::Val_Always);
      parser->setValidationSchemaFullChecking(true);
      parser->setDoNamespaces(true);
      break;
    case eNONE:
      parser->setValidationScheme(XercesDOMParser::Val_Never);
      break;
    default:
      ERROR("You have selected an invalid validation mode");
      exit(EXIT_FAILURE);
      break;
    }

    parser->setErrorHandler(fgErrReporter);

    try {

      if (inputType == eFromFile)
        parser->parse(input.c_str());
      else {
        const MemBufInputSource memSource((const XMLByte*)input.c_str(),
                                          input.size(), "", false);
        parser->parse(memSource);
      }

      if (fgErrReporter->getSawErrors()) {

        const DOMNamedNodeMap* const topAtts =
          parser->getDocument()->getDocumentElement()->getAttributes();

        for (unsigned int i = 0; i < topAtts->getLength(); ++i) {

          const DOMNode* const attribute = topAtts->item(i);
          const string attName = AsString(attribute->getNodeName());

          const string postNs = attName.substr(attName.find_first_of(":") + 1);

          if (postNs == "noNamespaceSchemaLocation") {

            const string validationFile = AsString(attribute->getNodeValue());
            ostringstream msg;

            if (!boost::filesystem::exists(validationFile)) {
              msg << "Could not find the schema validation file \""
                  << validationFile << "\" ";
              if (inputType == eFromFile)
                msg << "which was requested the by configuration file \"" << input << "\".";
            } else {
              if (inputType == eFromFile)
                msg << "Schema validation failed for file \"" << input << "\". ";
              else
                msg << "Schema validation failed after parameter replacement";

              msg << "The following errors were reported while parsing: "
                  << fgErrReporter->getMessages().str() << '\n';
              if (inputType == eFromMemBuf) {
                msg << "Here is the XML as it reads after parameter replacement:\n"
                    << input;
              }
            }
            delete parser;
            parser = nullptr;
            ERROR(msg);
            throw XMLValidationException(msg.str());
          }
        }

        ostringstream warn;
        warn << "No schema (.xsd) document is available for ";
        if (inputType == eFromFile)
          warn << "file '" << input << "'. ";
        else {
          warn << "in-memory string";
          const int maxOutputSize = 200;
          if (input.size() > maxOutputSize)
            warn << " (truncated): \"" << input.substr(0, maxOutputSize) << "\". ";
          else
            warn << ": \"" << input << "\". ";
        }
        warn << "It will not be validated!";
        WARNING(warn);
        fgErrReporter->resetErrors();
      }

    } catch (const XMLException& e) {

       ostringstream msg;
       msg << "An error occurred during parsing, message: "
           << AsString(e.getMessage());
       ERROR(msg);
       delete parser;
       parser = nullptr;
       throw XMLParseException(msg.str());
     }

     // initialize top branch to the document element, taking ownership of the document.
     const auto doc = parser->adoptDocument();
     Branch branch(doc, doc->getDocumentElement());
     delete parser;
     return branch;
  }


  ostream&
  operator<<(ostream& os, const Branch& b)
  {
    return os << b.String() << '\n';
  }

}