BxBinxSaxParser.h

/********************************************************************
 * Binx
 * $Id: BxBinxSaxParser_8h-source.html,v 1.1.1.1 2006/04/19 14:19:02 edikt2 Exp $
 *
 * Class for parsing the BinX document using the SAX engine
 *
 *
 * edikt::BinX
 * www.edikt.org
 * support@edikt.org
 *
 * Copyright (c) 2005 The University of Edinburgh.
 *
 ********************************************************************/

#ifndef BXBINXSAXPARSER_H
#define BXBINXSAXPARSER_H

#include <xercesc/sax2/Attributes.hpp>
#include <xercesc/sax2/DefaultHandler.hpp>

XERCES_CPP_NAMESPACE_USE

#include "BxDataset.h"
#include "BxBinxParser.h"
#include "BxSaxHandler.h"
#include "BxDataObjectStack.h"

/*
 * A BinX parser implementation supported by a SAX engine.
 * This class is an implementation of class BxBinxParser.
 *
 * <BR>
 * After parsing a BinX document, the whole meta-dataset is built in memory pointed to by
 * BxBinxParser::datasetRoot_.  The caller is responsible to obtain this pointer by calling getDataset()
 * method and destroy it after use.  Internally, this is used by the BxBinXFile class to parse
 * a BinX document and the dataset tree is destroyed by its destructor.
 * <BR>
 * \internal
    The original DOM parser relies on BxBinxSchema::search method for locating a tag element.
    This parser is more deterministic in the way to identify each element section. For example,
    It checks only for <defineType> in a <definitions> section, all other possibilities are
    rejected as invalid.  This strictly follows the BinX schema and can be used for validation
    as well as parsing.  Obviously the deterministic method is more efficient.  As the elements
    are recognised by the SAX parser which knows nothing about BinX, it is necessary to tell
    which context the current node resides so as to assign the following parsing to proper
    element recogniser.  This is done by function pointer replacement during parsing.  For
    example, after parsing <definitions> element, the function pointer for parsing next element
    is assigned to be parseDefinitionsStart which is responsible to identify <defineType> only.
 *
 * <BR><B>Since:</B>  BinX version 1.1.
 */
class DECLSPEC BxBinxSaxParser : public BxBinxParser, DefaultHandler
{
public:
        // The default constructor
    BxBinxSaxParser();

        // The destructor
    virtual ~BxBinxSaxParser();

    // event handlers for SaxHandler
    void startDocument();
    void endDocument() {}
    void startElement(const XMLCh* const, const XMLCh* const localname, const XMLCh* const, const Attributes& attrs);
    void endElement(const XMLCh* const, const XMLCh* const localname, const XMLCh* const);
    void characters(const XMLCh* const, const unsigned int) {}
    void ignorableWhitespace(const XMLCh* const, const unsigned int) {}
    //  Handlers for the SAX ErrorHandler interface
    void warning(const SAXParseException& exception);
    void error(const SAXParseException& exception);
    void fatalError(const SAXParseException& exception);
    void resetErrors();

    virtual char* className() const { return "BxBinxSaxParser"; }

    virtual bool parse(const char* xmlFile);

private:
        // Private operations

        /* Unimplemented constructor and assignment operator */
        // The copy constructor
    BxBinxSaxParser(const BxBinxSaxParser&);

        // The assignment operator
    void operator=(const BxBinxSaxParser&);

    bool parseFile(const char*);

    void parseXmlStart(const char*, const Attributes&);
    void parseBinxStart(const char*, const Attributes&);
    void parseDefinitionsStart(const char*, const Attributes&);
    void parseParametersStart(const char*, const Attributes&);
    void parseDatasetStart(const char*, const Attributes&);
    void parseArrayStart(const char*, const Attributes&);
    void parseUnionStart(const char*, const Attributes&);

    void parseXmlEnd(const char*);
    void parseBinxEnd(const char*);
    void parseDefinitionsEnd(const char*);
    void parseParametersEnd(const char*);
    void parseDatasetEnd(const char*);
    void parseArrayEnd(const char*);
    void parseUnionEnd(const char*);

    void parseCommonAttributes(const Attributes&, BxDataObject*);
    void parseStringAttributes(const Attributes&, BxDataObject*);
    void parseStructAttributes(const Attributes&, BxDataObject*);
    void dispatchDataObject();
    BxDataObject* createPrimitiveDataObject(const char*);
    char* getAttribute(const Attributes&, const char*);

    BxByteOrder makeByteOrder(char*);


        // Private data

    BxSaxHandler* pSaxHandler_;    //SAX event handler
    char* sDiscriminantValue_; //temporary string for discriminantValue attribute
    char* typeName_;    //temporarily save typeName for <defineType> element
    bool errors_;        //sax error handler recorder
    bool unknownElement_;   //set to true if unknown tag met
    int descendants_;   //keep how many descendants in unknown element
    PointerStack stack_; //stack to keep parsed tree
    BxByteOrder bo_;     //temporarily for byteOrder on <binx> level

    void (BxBinxSaxParser::*parseStart)(const char*, const Attributes&); //function pointer to parse each element
    void (BxBinxSaxParser::*parseEnd)(const char*); //function pointer to parse each element
};

#endif

---