view host/SimpleXMLRuleLoader.cpp @ 3:86914ea77b7b

* start simple xml rule file loading

/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */

#include "SimpleXMLRuleLoader.h"

#include <QFile>
#include <QIODevice>
#include <QXmlInputSource>

SimpleXMLRuleLoader::SimpleXMLRuleLoader() :
    m_processor(0),
    m_inPlugins(false),
    m_inRules(false)
{
}

bool
SimpleXMLRuleLoader::loadFile(Processor &processor, QString fileName)
{
    QFile file(fileName);
        
    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
        std::cerr << "ERROR: SimpleXMLRuleLoader::load("
                  << fileName.toStdString()
                  << "): Failed to open file for reading" << std::endl;
        return false;
    }
    
    QXmlInputSource source(&file);
    return loadXml(processor, source);
}

bool
SimpleXMLRuleLoader::loadXml(Processor &processor, const QString &xmlData)
{
    QXmlInputSource source;
    source.setData(xmlData);
    return loadXml(processor, source);
}

bool
SimpleXMLRuleLoader::loadXml(Processor &processor, QXmlInputSource &source)
{
    QXmlSimpleReader reader;
    reader.setContentHandler(this);
    reader.setErrorHandler(this);
    m_processor = &processor;
    return reader.parse(source);
    m_processor = 0;
}

bool
SimpleXMLRuleLoader::startElement(const QString &namespaceURI,
                                  const QString &localName,
                                  const QString &qName,
                                  const QXmlAttributes &atts)
{
    QString name = qName.toLower();

    if (name == "plugins") {
        if (m_inPlugins) {
            std::cerr << "ERROR: SimpleXMLRuleLoader: Nested plugins elements" << std::endl;
            return false;
        } else {
            m_inPlugins = true;
        }
    } else if (name == "plugin") {
        int extIndex = atts.value("index").toInt();
        QString id = atts.value("id");
        int intIndex = m_processor->addPlugin(id);
        if (!intIndex) {
            std::cerr << "WARNING: SimpleXMLRuleLoader: Failed to load plugin \""
                      << id.toStdString() << "\"" << std::endl;
        } else {
            std::cerr << "INFO: SimpleXMLRuleLoader: Successfully loaded plugin \"" << id.toStdString() << "\" (internal index " << intIndex << ", external index " << extIndex << ")" << std::endl;
            m_externalInternalIndexMap[extIndex] = intIndex;
        }
    } else if (name == "rules") {
        if (m_inRules) {
            std::cerr << "ERROR: SimpleXMLRuleLoader: Nested rules elements" << std::endl;
            return false;
        } else {
            m_inRules = true;
        }
    }            

    return true;
}

bool
SimpleXMLRuleLoader::characters(const QString &s)
{
    return true;
}

bool
SimpleXMLRuleLoader::endElement(const QString &namespaceURI,
                                const QString &localName,
                                const QString &qName)
{
    QString name = qName.toLower();

    if (name == "plugins") m_inPlugins = false;
    else if (name == "rules") m_inRules = false;
    return true;
}

bool
SimpleXMLRuleLoader::error(const QXmlParseException &exception)
{
    m_errorString =
	QString("ERROR: SimpleXMLRuleLoader: %1 at line %2, column %3")
	.arg(exception.message())
	.arg(exception.lineNumber())
	.arg(exception.columnNumber());
    std::cerr << m_errorString.toLocal8Bit().data() << std::endl;
    return QXmlDefaultHandler::error(exception);
}

bool
SimpleXMLRuleLoader::fatalError(const QXmlParseException &exception)
{
    m_errorString =
	QString("FATAL ERROR: SimpleXMLRuleLoader: %1 at line %2, column %3")
	.arg(exception.message())
	.arg(exception.lineNumber())
	.arg(exception.columnNumber());
    std::cerr << m_errorString.toLocal8Bit().data() << std::endl;
    return QXmlDefaultHandler::fatalError(exception);
}