util/parser/Sax2XercesParser.h

Go to the documentation of this file.

/*-----------------------------------------------------------------------------
Name:      Sax2XercesParser.h
Project:   xmlBlaster.org
Copyright: xmlBlaster.org, see xmlBlaster-LICENSE file
Comment:   Default handling of Sax callbacks
-----------------------------------------------------------------------------*/

#ifndef _UTIL_PARSER_SAX2XERCESPARSER_H
#define _UTIL_PARSER_SAX2XERCESPARSER_H

#if defined(XMLBLASTER_MSXML_PLUGIN)
#  error Implement Microsoft XML parser for /DXMLBLASTER_MSXML_PLUGIN
#else  // XMLBLASTER_XERCES_PLUGIN

#include <util/xmlBlasterDef.h>
#include <util/parser/I_Parser.h>
#include <util/plugin/I_Plugin.h>
#include <string>
#include <xercesc/util/TransService.hpp>
#include <xercesc/sax2/Attributes.hpp>
#include <xercesc/sax2/DefaultHandler.hpp>
#include <xercesc/util/XMLString.hpp>
#include <util/StopParseException.h>

#if defined(XERCES_HAS_CPP_NAMESPACE)
        // Since Xerces 2.2 namespace is introduced:
   XERCES_CPP_NAMESPACE_USE
#endif

namespace org { namespace xmlBlaster { namespace util { namespace parser {
    
class Dll_Export Sax2Parser : public I_Parser, public DefaultHandler,
                              public virtual org::xmlBlaster::util::plugin::I_Plugin
{
   
private:
   std::string ME;
   org::xmlBlaster::util::Global& global_;
   org::xmlBlaster::util::I_Log&    log_;
   XMLTranscoder* xmlBlasterTranscoder_;
   std::string encoding_;

   // Private copy ctor and assignement
   Sax2Parser(const Sax2Parser& data);
   Sax2Parser& operator=(const Sax2Parser& data);

public:
   Sax2Parser(org::xmlBlaster::util::Global& global, XmlHandlerBase *handler);

   ~Sax2Parser();
   
   /*
    * This method parses the XML std::string using the SAX parser.
    * @param xmlLiteral The XML std::string
    */
   void init(const std::string &xmlLiteral);
   
   void parse(const std::string &xmlData);

protected:

   std::string getLocationString(const SAXParseException &ex);

   AttributeMap& getAttributeMap(AttributeMap& attrMap, const Attributes &attrs);

   bool caseCompare(const XMLCh *name1, const char *name2) ;

   std::string getStringValue(const XMLCh* const value, bool doTrim=true) const;

   bool getStringAttr(const Attributes& attrs, const XMLCh* const name, std::string& value, bool doTrim=true) const;

 public:

   static void releaseXMLCh(XMLCh** data);
 
   static void releaseXMLCh(char** data);

   void characters(const XMLCh *const chars, const unsigned int length);
   
   void endDocument();

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

   void   startDocument();

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


   // implementation of the ErrorHandler interface
   void   error(const SAXParseException &exc);

   void   fatalError(const SAXParseException &exc);

   void   warning(const SAXParseException &exc);

   void   endCDATA();

   // void   endDTD()

   // void   endEntity(const XMLCh *const name)

   void   startCDATA();

   // these are probably not really needed here ...

   // void startDTD (const XMLCh *const name, const XMLCh *const publicId, const XMLCh *const systemId) {};

   // void startEntity(const XMLCh *const name) {};

   // void elementDecl(const XMLCh *const name, const XMLCh *const model) {};

   // void attributeDecl (const XMLCh *const eName, const XMLCh *const aName, const XMLCh *const type, const XMLCh *const mode, const XMLCh *const value) {};

   // void internalEntityDecl (const XMLCh *const name, const XMLCh *const value) {};
   // void externalEntityDecl (const XMLCh *const name, const XMLCh *const publicId, const XMLCh *const systemId) {};

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

   // void resetDocument() {};

   // void setDocumentLocator(const Locator *const locator) {};

   // void startPrefixMapping(const XMLCh *const prefix, const XMLCh *const uri) {};

   // void endPrefixMapping(const XMLCh *const prefix) {};

   // void skippedEntity(const XMLCh *const name) {};

   // implementation of the EntityResolver interface.
   // InputSource* resolveEntity(const XMLCh *const publicId, const XMLCh *const systemId) { return NULL; };

   // void resetErrors() {};

   // implementation of DTDHandler interface.
   // void notationDecl(const XMLCh *const name, const XMLCh *const publicId, const XMLCh *const systemId) {};

   // void resetDocType() {};

   // void unparsedEntityDecl(const XMLCh *const name, const XMLCh *const publicId, const XMLCh *const systemId, const XMLCh *const notationName) {};

   //implementation of LexicalHandler interface.
   // void comment(const XMLCh *const chars, const unsigned int length) {};

   // void ignorableWhitespace(const XMLCh *const chars, const unsigned int length);

   std::string getType() { static std::string type = "XERCES"; return type; }

   std::string getVersion() { static std::string version = "1.0"; return version; }

   static std::string usage();
};
}}}} // namespace

#endif // XMLBLASTER_XERCES_PLUGIN
# endif // _UTIL_PARSER_SAX2XERCESPARSER_H