|| || || || || || || ||

---

XmlFileReader.h

Go to the documentation of this file.

#ifndef Impala_Persistency_XmlFileReader_h
#define Impala_Persistency_XmlFileReader_h

// 
// Convenience class, wrapping an Xerces XML DOM parser.
// 

#include <string>
#include <vector>
#include <deque>
#include <fstream>
#include <assert.h>

#include <xercesc/util/XMLString.hpp>
#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/dom/DOMException.hpp>
#include <xercesc/util/OutOfMemoryException.hpp>
#include <xercesc/dom/DOM.hpp>
#include <xercesc/parsers/XercesDOMParser.hpp>
#include <xercesc/framework/MemBufInputSource.hpp>
#include <xercesc/framework/Wrapper4InputSource.hpp>

#include "Util/IOBufferFile.h"
#include "Persistency/DOMTreeErrorReporter.h"


namespace Impala
{
namespace Persistency
{

class XmlFileReader
{

public:
    typedef XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument DOMDocument;

    XmlFileReader()
    {
        mParser = 0;
    }

    virtual ~XmlFileReader()
    {
        FinalizeXerces();
    }

    DOMDocument*
    Read(const std::string& filePath, bool fileRequired = true)
    {
        if (!FileExists(filePath)) 
            if (fileRequired)
                throw std::runtime_error("file missing: " + filePath);
            else
                return 0;

        if (!ValidateFile(filePath)) 
            throw std::runtime_error("validation failed for file: " + filePath);

        Util::IOBufferFile ioBuf(filePath, true, true);

        return Read(filePath, &ioBuf);
    }

    DOMDocument*
    Read(const std::string& filePath, Util::IOBuffer* ioBuf)
    {
        ClearParser(); // clear in case the reader is used more than once

        if (!InitializeXerces()) 
            throw std::runtime_error("xerces initialization failed");

        DOMDocument* domDoc = ReadDomDoc(filePath, ioBuf);
        return domDoc;
    }

    virtual bool FileExists(const std::string& address)
    {
        std::ifstream xmlFile(address.c_str());
        if (xmlFile.is_open())
        {
            xmlFile.close();
            return true;
        }
        return false;
    }

    // is it readable, writable, the right format etc.
    virtual bool ValidateFile(const std::string& address)
    {
        return true;
    }

    static std::vector<XERCES_CPP_NAMESPACE_QUALIFIER DOMNode*> FindChildNodesByName(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* const node, const char* const tagName)
    {
        XERCES_CPP_NAMESPACE_QUALIFIER DOMNodeList *children = node->getChildNodes();
        XMLCh *xercesTagName = XERCES_CPP_NAMESPACE_QUALIFIER XMLString::transcode(tagName);
        std::vector<XERCES_CPP_NAMESPACE_QUALIFIER DOMNode*> result;
        for (XMLSize_t i = 0; i < children->getLength(); i++)
        {
            XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* child = children->item(i);
            const XMLCh *xChildName = child->getNodeName();
            if (XERCES_CPP_NAMESPACE_QUALIFIER XMLString::equals(child->getNodeName(), xercesTagName))
                result.push_back(child);
        }
        XERCES_CPP_NAMESPACE_QUALIFIER XMLString::release(&xercesTagName);
        return result;
    }

    // recursive search
    static XERCES_CPP_NAMESPACE_QUALIFIER DOMNodeList *FindElementsByName(const XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument* const doc, const char* const tagName)
    {
        XMLCh *xercesTagName = XERCES_CPP_NAMESPACE_QUALIFIER XMLString::transcode(tagName);
        XERCES_CPP_NAMESPACE_QUALIFIER DOMNodeList *elements = doc->getElementsByTagName(xercesTagName);
        XERCES_CPP_NAMESPACE_QUALIFIER XMLString::release(&xercesTagName);
        return elements;
    }

    static std::string GetAttributeValue(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNamedNodeMap* const attributes, const char* const attributeName)
    {
        XMLCh *xercesAttribName = XERCES_CPP_NAMESPACE_QUALIFIER XMLString::transcode(attributeName);
        XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *attrib = attributes->getNamedItem(xercesAttribName);
        XERCES_CPP_NAMESPACE_QUALIFIER XMLString::release(&xercesAttribName);
        return (attrib == 0) ? "" : GetNodeValue(attrib);
    }

private:

    XERCES_CPP_NAMESPACE_QUALIFIER XercesDOMParser *mParser;

    bool InitializeXerces()
    {
        // Initialize the XML4C2 system
        try
        {
            XERCES_CPP_NAMESPACE_QUALIFIER XMLPlatformUtils::Initialize();
        }

        catch (const XERCES_CPP_NAMESPACE_QUALIFIER XMLException &/*toCatch*/)
        {
//                std::cout << "Error during Xerces-c Initialization.\n"
//                    << "  Exception message:"
//                    << StrX(toCatch.getMessage()) << std::endl;
            return false;
        }

        return true;
    }

    void ClearParser()
    {
        if (mParser != 0)
        {
            delete mParser;
            mParser = 0;
        }
    }

    DOMDocument*
    ReadDomDoc(const std::string& filePath, Util::IOBuffer* ioBuf = 0)
    {
        //
        //  Create a parser, then attach an error handler to it.
        //  The parser will call back to methods of the ErrorHandler if it
        //  discovers errors during the course of parsing the XML document.
        //
        mParser = new XERCES_CPP_NAMESPACE_QUALIFIER XercesDOMParser;
        mParser->setValidationScheme(XERCES_CPP_NAMESPACE_QUALIFIER XercesDOMParser::Val_Auto);
        mParser->setDoNamespaces(false);
        mParser->setDoSchema(false);
        mParser->setValidationSchemaFullChecking(false);
        mParser->setCreateEntityReferenceNodes(false);

        DOMTreeErrorReporter *errReporter = new DOMTreeErrorReporter();
        mParser->setErrorHandler(errReporter);

        //
        //  Parse the XML file, catching any XML exceptions that might propagate
        //  out of it.
        //
        bool errorsOccured = false;

        typedef XERCES_CPP_NAMESPACE_QUALIFIER MemBufInputSource MemBufInputSource;
        MemBufInputSource memBuf(ioBuf->GetBuffer(), ioBuf->Size(),
                                 filePath.c_str(), false);
        try
        {
            mParser->parse(memBuf);
            //mParser->parse(filePath.c_str()); // SK: error handling is niet goed, want geen exception wanneer verkeerd adres.
        }

        catch (const XERCES_CPP_NAMESPACE_QUALIFIER OutOfMemoryException&)
        {
            // log something
            std::cout << "OutOfMemoryException!!!" << std::endl;
            errorsOccured = true;
        }

        catch (const XERCES_CPP_NAMESPACE_QUALIFIER XMLException& /*e*/)
        {
            // log something
//                std::cout << "XMLException occurred while parsing; message: " << StrX(e.getMessage()) << std::endl;
            errorsOccured = true;
        }

        catch (const XERCES_CPP_NAMESPACE_QUALIFIER DOMException& e)
        {
            // log something
            std::cout << "\nDOM Error during parsing: '" << filePath << "'\n"
                << "DOMException code is:  " << e.code << std::endl;

//                const unsigned int maxChars = 2047;
//                XMLCh errText[maxChars + 1];
//                if (DOMImplementation::loadDOMExceptionMsg(e.code, errText, maxChars))
//                    std::cout << "Message is: " << StrX(errText) << std::endl;

            errorsOccured = true;
        }

        catch (...)
        {
            std::cout << "An error occurred during parsing\n " << std::endl;
            errorsOccured = true;
        }

        // If the parse was successful, get the document data from the DOM tree
        XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument *repositoryDoc = 0;
        if (!errorsOccured && !errReporter->getSawErrors())
        {
            repositoryDoc = mParser->getDocument();
        }

        //
        //  Clean up the error handler. The parser does not adopt handlers
        //  since they could be many objects or one object installed for multiple
        //  handlers.
        //
        delete errReporter;

        return repositoryDoc;
    }

    void FinalizeXerces()
    {
        ClearParser();
        XERCES_CPP_NAMESPACE_QUALIFIER XMLPlatformUtils::Terminate();
    }

    static std::string GetNodeValue(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* const node)
    {
        const XMLCh* valueX = node->getNodeValue();
        char* valueC = XERCES_CPP_NAMESPACE_QUALIFIER XMLString::transcode(valueX);
        const std::string value = std::string(valueC);
        XERCES_CPP_NAMESPACE_QUALIFIER XMLString::release(&valueC);
        return value;
    }

}; // class

}//namespace Persistency
}//namespace Impala

#endif //

---