src/ValidateSAX2ContentHandler.hpp

Go to the documentation of this file.

#ifndef _ValidateSAX2ContentHandler_HPP_
#define _ValidateSAX2ContentHandler_HPP_

#include <xercesc/sax2/ContentHandler.hpp>

#include <ios>
#include <vector>
#include <set>

using namespace xercesc;

XERCES_CPP_NAMESPACE_USE


class SAX2ContentHandler : public ContentHandler {
private:
        bool failed;

        bool isUndirected;

        std::string name;

        std::string source;

        std::string description;

        std::streamsize doublePrecision;

        std::streamsize ignoredDigits;

        double doubleZero;

        bool firstVertex;

        std::vector<std::vector<double> >::size_type numberOfParsedVertices;

        std::set<std::vector<double>::size_type> edgesDefinedInTheFirstVertex;

        std::vector<double> costsOfEdgesDefinedInTheFirstVertex;

        std::vector<std::vector<double> >::size_type n;

        std::vector<std::vector<bool> > parsedEntries;

        std::vector<std::vector<double> > adjacencyMatrix;

        std::string buffer;

        double cost;

        SAX2ContentHandler(const SAX2ContentHandler &sAX2ContentHandler);

        SAX2ContentHandler &operator=(const SAX2ContentHandler &sAX2ContentHandler);

        void init();

public:
        SAX2ContentHandler();

    ~SAX2ContentHandler();

    inline bool getFailed() const {
        return (failed);
    }

        inline std::string getName() const {
                return (name);
        }

        inline std::string getSource() const {
                return (source);
        }

        inline std::string getDescription() const {
                return (description);
        }

        inline std::streamsize getDoublePrecision() const {
                return (doublePrecision);
        }

        inline std::streamsize getIgnoredDigits() const {
                return (ignoredDigits);
        }

        inline double getDoubleZero() const {
                return (doubleZero);
        }

        inline std::vector<std::vector<double> > getAdjacencyMatrix() {
                return (adjacencyMatrix);
        }

        void setDocumentLocator(const Locator *const locator);

        void resetDocument();

        void startDocument();

        void endDocument();

        void startPrefixMapping(const XMLCh *const prefix, const XMLCh *const uri);

        void endPrefixMapping(const XMLCh *const prefix);

        void skippedEntity(const XMLCh *const name);

        void startElement(
                        const XMLCh *const uri,
                const XMLCh *const localname,
                const XMLCh *const qname,
                const Attributes &attributes);

        void endElement(
                        const XMLCh *const uri,
                        const XMLCh *const localname,
                        const XMLCh *const qname);

        void characters(const XMLCh *const chars, const XMLSize_t length);

        void ignorableWhitespace(const XMLCh *const chars, const XMLSize_t length);

        void processingInstruction(const XMLCh *const target, const XMLCh *const data);
};


#endif