xmlconfigfile.cpp

Go to the documentation of this file.

/*
    Sheep - A Rigid Body Dynamics Engine
    Copyright (C) 2001-2004 Francois Beaune
    Contact: http://toxicengine.sourceforge.net/

    This file is part of Sheep.

    Sheep is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    Sheep is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Sheep; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include "xmlconfigfile.h"  // include first
#include "xercesmanager.h"
#include "xercesutils.h"

#include <pathan/XPathEvaluator.hpp>
#include <pathan/XPathExpression.hpp>
#include <pathan/XPathNSResolver.hpp>
#include <pathan/XPathResult.hpp>
#include <xercesc/sax/SAXParseException.hpp>

#include <cassert>

using namespace sheep;
using namespace std;
using namespace xercesc;

XMLConfigFile::XMLConfigFile(const string &filename,
                             ErrorHandler *error_handler /*= 0*/)
{
    initialize(
        filename,
        "",     // no validation
        error_handler
    );
}

XMLConfigFile::XMLConfigFile(const string &filename,
                             const string &schema_filename,
                             ErrorHandler *error_handler /*= 0*/)
{
    initialize(
        filename,
        schema_filename,
        error_handler
    );
}

XMLConfigFile::~XMLConfigFile() {
    delete m_nsresolver;
    delete m_evaluator;
    delete m_parser;

    XercesManager::Shutdown();
}

int XMLConfigFile::Count(const string &xpathexpr) const {
    XPathResult *result = query(xpathexpr);

    assert(result);

    return result->getSnapshotLength();
}

namespace {
    class DefaultErrorHandler : public ErrorHandler {
    public:
        virtual void warning(const SAXParseException &e) {
            throw XMLConfigFile::ParseErrorException(StrX(e.getMessage()));
        }

        virtual void error(const SAXParseException &e) {
            throw XMLConfigFile::ParseErrorException(StrX(e.getMessage()));
        }

        virtual void fatalError(const SAXParseException &e) {
            throw XMLConfigFile::ParseErrorException(StrX(e.getMessage()));
        }

        virtual void resetErrors() {}
    };
}

void XMLConfigFile::initialize(const string &filename,
                               const string &schema_filename,
                               ErrorHandler *error_handler)
{
    XercesManager::Initialize();

    // Create the parser.
    m_parser = new XercesDOMParser();

    // Configure the parser.
    if(schema_filename.size() > 0) {
        m_parser->setValidationScheme(XercesDOMParser::Val_Always);
        m_parser->setDoNamespaces(true);
        m_parser->setDoSchema(true);
        m_parser->setValidationSchemaFullChecking(true);
        m_parser->setExternalNoNamespaceSchemaLocation(schema_filename.c_str());
    } else {
        m_parser->setValidationScheme(XercesDOMParser::Val_Never);
    }

    // Install the provided error handler, or the default error handler if none is provided.
    ErrorHandler *default_error_handler = 0;
    if(error_handler)
        m_parser->setErrorHandler(error_handler);
    else {
        default_error_handler = new DefaultErrorHandler();
        m_parser->setErrorHandler(default_error_handler);
    }

    // Parse the XML file and create the DOM document.
    try {
        m_parser->parse(filename.c_str());
    }
    catch(const XMLException &e) {
        throw ParseErrorException(StrX(e.getMessage()));
    }
    catch(const DOMException &e) {
        throw ParseErrorException(StrX(e.msg));
    }

    // Delete the default error handler if one has been created.
    delete default_error_handler;

    // Get the root element of the document.
    m_rootelement = m_parser->getDocument()->getDocumentElement();

    // Create an XPathEvaluator class. This class is used as a factory for creating
    // XPathExpression and XPathNSResolver (it is rarely used for evaluation in the
    // latest spec [31/10/2001], however, and is somewhat misnamed).
    m_evaluator = XPathEvaluator::createEvaluator();

    // Create an XPathNSResolver using the XPathEvaluator factory class. The
    // XPathNSResolver class binds XML namespace prefixes to the full namespace string.
    m_nsresolver = m_evaluator->createNSResolver(m_rootelement);
}

XPathResult *XMLConfigFile::query(const string &xpathexpr) const {
    // Create an XPathExpression using the XPathEvaluator factory class.
    // Pass as parameters the XPath expression and the appropriate XPathNSResolver.
    // The XPath request any childNode nodes off the parentNode who have a subchildNode child.
    XPathExpression *parsed_expression;
    try {
        parsed_expression = m_evaluator->createExpression(
            XStr(xpathexpr),
            m_nsresolver
        );
    }
    catch(const XPathException &e) {
        throw QueryErrorException(e.getString());
    }

    // The XPath expression is parsed and stored. It may now be applied to any number of documents.
    // The parsed expression is evaluated on the document. We request a
    // node set as output. The result is placed in the variable result.
    XPathResult *result = 0;    // keep the compiler happy, because we pass this variable
                                // to the XPathExpression::evaluate() method (for unknown reasons)
    try {
        result = parsed_expression->evaluate(
            m_rootelement,
            XPathResult::ORDERED_NODE_SNAPSHOT_TYPE,
            result  // don't know why we must pass this argument, it is not actually used by the method
        );
    }
    catch(const XPathException &e) {
        throw QueryErrorException(e.getString());
    }

    return result;
}

string XMLConfigFile::get_string(const string &xpathexpr) const {
    XPathResult *result = query(xpathexpr);

    if(result->getSnapshotLength() != 1)
        throw QueryErrorException("Query resulted in zero or multiple answers.");

    return StrX(result->snapshotItem(0)->getNodeValue());
}

---