SAXHelper.h

#pragma once

#include <stack>

#include <Poco/SAX/ContentHandler.h>
#include <Poco/SAX/DTDHandler.h>

#include "util/Loggable.h"

namespace Poco {

class Path;

namespace XML {

class Locator;

}
}

namespace BeeeOn {

struct SAXElement {
        SAXElement();
        SAXElement(
                const Poco::XML::XMLString &localName,
                const Poco::XML::XMLString &qName,
                const Poco::XML::XMLString &uri
        );

        bool isRoot() const;
        bool is(const Poco::XML::XMLString &localName,
                const Poco::XML::XMLString &qName,
                const Poco::XML::XMLString &uri) const;

        const Poco::XML::XMLString localName;
        const Poco::XML::XMLString qName;
        const Poco::XML::XMLString uri;
        Poco::XML::XMLString content;
};

class SAXHelper :
                public Poco::XML::ContentHandler,
                public Poco::XML::DTDHandler,
                public Loggable {
public:
        SAXHelper();
        virtual ~SAXHelper();
        
        virtual void processingInstruction(
                        const Poco::XML::XMLString &target,
                        const Poco::XML::XMLString &data);

        virtual void skippedEntity(const Poco::XML::XMLString &name);

        virtual void ignorableWhitespace(
                        const Poco::XML::XMLChar c[],
                        int start,
                        int length) override;

        virtual void characters(const Poco::XML::XMLChar c[],
                        int start, int length) override;

        void startDocument() override;
        
        void endDocument() override;

        void startElement(const Poco::XML::XMLString &uri,
                        const Poco::XML::XMLString &localName,
                        const Poco::XML::XMLString &qName,
                        const Poco::XML::Attributes &attrList) override;
        
        void endElement(const Poco::XML::XMLString &uri,
                        const Poco::XML::XMLString &localName,
                        const Poco::XML::XMLString &qName) override;

        virtual void startPrefixMapping(
                        const Poco::XML::XMLString &prefix,
                        const Poco::XML::XMLString &uri) override;

        virtual void endPrefixMapping(const Poco::XML::XMLString &prefix) override;
        
        void setDocumentLocator(const Poco::XML::Locator *loc) override;

        virtual void notationDecl(const Poco::XML::XMLString &name,
                        const Poco::XML::XMLString *publicId,
                        const Poco::XML::XMLString *systemId) override;

        virtual void unparsedEntityDecl(const Poco::XML::XMLString &name,
                        const Poco::XML::XMLString *publicId,
                        const Poco::XML::XMLString &systemId,
                        const Poco::XML::XMLString &notationName) override;

        static void parse(const Poco::Path &path, SAXHelper &helper);

protected:
        virtual bool expectElement(const SAXElement &element) const;

        virtual void startElement(const SAXElement &element,
                        const Poco::XML::Attributes &attrList);

        virtual void endElement(const SAXElement &element);

        virtual bool expectContent(int length) const;

        virtual void preprocessContent(
                        const Poco::XML::XMLChar c[],
                        int &start,
                        int &length);

        void trimContent(const Poco::XML::XMLChar c[],
                        int &start,
                        int &length);

        void appendContent(const Poco::XML::XMLChar c[],
                        int start, int length);

        void appendContent(const Poco::XML::XMLString &s);

        bool getAndTrimAttribute(const Poco::XML::Attributes &attrList,
                        const Poco::XML::XMLString &name,
                        Poco::XML::XMLString &value) const;

        bool getAttributeAsDouble(const Poco::XML::Attributes &attrList,
                        const Poco::XML::XMLString &name,
                        double &value) const;

        bool getAttributeAsInt(const Poco::XML::Attributes &attrList,
                        const Poco::XML::XMLString &name,
                        int &value) const;

        void error(const std::string &message) const;

        void fatal(const std::string &message) const;

        const std::string beginMessage() const;

        const Poco::XML::Locator &locator() const;

        const std::deque<SAXElement> &path() const;

        const SAXElement &current() const;

        const SAXElement &parent() const;

        template <typename T>
        bool isPathFromRoot(const T &name) const
        {
                return m_path.size() > 1
                        && m_path[0].isRoot()
                        && checkPath(1, name);
        }

        template <typename T, typename ...Ts>
        bool isPathFromRoot(const T &name, const Ts &... ts) const
        {
                return m_path.size() > 1
                        && m_path[0].isRoot()
                        && checkPath(1, name, ts...);
        }

private:
        bool checkPath(unsigned int i) const
        {
                return i == m_path.size();
        }

        template <typename T>
        bool checkPath(unsigned int i, const T &name) const
        {
                return i < m_path.size()
                        && matchPathElement(m_path[i], name)
                        && checkPath(i + 1);
        }

        template <typename T, typename ...Ts>
        bool checkPath(unsigned int i, const T &name, const Ts &... ts) const
        {
                return i < m_path.size()
                        && matchPathElement(m_path[i], name)
                        && checkPath(i + 1, ts...);
        }

        template <typename T>
        bool matchPathElement(const SAXElement &element, const T &name) const
        {
                return element.localName == name || name == std::string("*");
        }

private:
        const Poco::XML::Locator *m_locator;
        std::deque<SAXElement> m_path;
};

}