sax2xercesparser.cpp

java开源的企业总线.xmlBlaster

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

#ifndef _UTIL_PARSER_SAX2XERCESPARSER_C
#define _UTIL_PARSER_SAX2XERCESPARSER_C

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

#if defined(_WIN32)
  #pragma warning(disable:4786)
#endif

#include <util/parser/Sax2XercesParser.h>
#include <xercesc/sax/SAXException.hpp>
#include <xercesc/sax2/SAX2XMLReader.hpp>
#include <xercesc/sax2/XMLReaderFactory.hpp>
#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/framework/MemBufInputSource.hpp>
#include <util/XmlBlasterException.h>
#include <util/Global.h>
#include <util/lexical_cast.h>
#include <iostream>
//#include <cstdlib> //<stdlib.h>

namespace org { namespace xmlBlaster { namespace util { namespace parser {

using namespace std;

static const int ENCODERBUFFERSIZE = 16*1024;

Sax2Parser::Sax2Parser(org::xmlBlaster::util::Global& global, XmlHandlerBase *handler) : 
    I_Parser(handler), ME("Sax2Parser"), global_(global), log_(global.getLog("org.xmlBlaster.util.xml")),
    xmlBlasterTranscoder_(0)
{
   if (log_.call()) log_.trace(ME, "Creating new Sax2Parser");

   //"UTF-8" is currently not supported with our std::string usage!
   encoding_ = global_.getProperty().getStringProperty("xmlBlaster/encoding", "iso-8859-1");

   XMLTransService::Codes resCode;
   xmlBlasterTranscoder_ = XMLPlatformUtils::fgTransService->makeNewTranscoderFor(encoding_.c_str(), resCode, ENCODERBUFFERSIZE);
   if (resCode != 0/*XMLTransService::Codes::Ok*/) {
      log_.error(ME, "Creation of XMLTranscoder with encoding='" + encoding_ + "' failed with error code " + lexical_cast<string>((int)resCode) +
                     ". Please check your SAX parser setting '-xmlBlaster/encoding'");
      throw XmlBlasterException(USER_CONFIGURATION, ME, "Creation of XMLTranscoder with encoding='" + encoding_ + "' failed with " + lexical_cast<string>((int)resCode));
   }
   else {
      if (log_.trace()) log_.trace(ME, "Created XMLTranscoder res=" + lexical_cast<string>((int)resCode) + " with encoding=" + encoding_);
   }
}

Sax2Parser::~Sax2Parser()
{
   delete xmlBlasterTranscoder_;
}

std::string Sax2Parser::usage() 
{
   std::string text = string("");
   //text += string("\n");
   text += string("\nThe xerces SAX XML parser plugin configuration:");
   text += string("\n   -xmlBlaster/encoding [iso-8859-1]");
   text += string("\n                       The parser encoding to use for xmlBlaster specific QoS and key SAX parsing");
   text += string("\n");
   return text;
}

void Sax2Parser::init(const string &xmlLiteral) 
{
   if (xmlLiteral.size() > 0) {
      parse(xmlLiteral);
   }
}
      
/**
 * Does the actual parsing
 * @param xmlData Quality of service in XML notation
 */
void Sax2Parser::parse(const string &xmlData) 
{
   //if (log_.call()) log_.call(ME, "parse");
   //if (log_.trace()) log_.trace(ME, string("parse content:'") + xmlData + string("'"));
 
   SAX2XMLReader *parser = NULL;
   //XMLCh* encodingHelper = NULL;
   try {
      parser = XMLReaderFactory::createXMLReader();
      parser->setContentHandler(this);
      parser->setErrorHandler(this);
      parser->setLexicalHandler(this);

      // "UTF-8"  "iso-8859-1"
      //string xmlData1 = string("<?xml version=\"1.0\" encoding=\""+encoding_+"\"?>\n") + xmlData;
      const string &xmlData1 = xmlData;
      //log_.info(ME, "Parsing now: " + xmlData1);
      
      MemBufInputSource inSource((const XMLByte*)xmlData1.c_str(), (unsigned int)(xmlData1.size()), "xmlBlaster", false);
      
      XMLCh tempStr[100];
      XMLString::transcode(encoding_.c_str(), tempStr, 99);
      inSource.setEncoding(tempStr);
      //encodingHelper = XMLString::transcode(encoding.c_str());
      //inSource.setEncoding(encodingHelper);
      //Sax2Parser::releaseXMLCh(&encodingHelper);

      parser->parse(inSource);
      delete parser;
   }
   catch (StopParseException&) {
      // If it does not work, it could be wrapped into SAXParseException
      log_.error(ME, string("StopParseException: ") +
                              "Parsing execution stopped half the way ");
      if (log_.trace()) {
         string help = XmlBlasterException::getStackTrace();
         log_.plain(ME, help);
      }
      delete parser; // just in case it did not 
      return;
   }
   catch (XmlBlasterException& ex) {
      throw ex;
   }
   catch (SAXParseException &err) {
      string loc = getLocationString(err) + string(": ") + getStringValue(err.getMessage());
      delete parser;
      throw XmlBlasterException(USER_ILLEGALARGUMENT, ME + "::parse", string("SAXParseException") + loc);
   }
   catch (SAXNotRecognizedException &err) {
      string msg = getStringValue(err.getMessage());
      delete parser;
      throw XmlBlasterException(USER_ILLEGALARGUMENT, ME + "::parse", string("SAXNotRecognizedException: ") + msg);
        }
   catch (SAXNotSupportedException &err) {
      string msg = getStringValue(err.getMessage());
      delete parser;
      throw XmlBlasterException(USER_ILLEGALARGUMENT, ME + "::parse", string("SAXNotSupportedException: ") + msg);
        }
   catch (const XMLException &err) {
      string msg = getStringValue(err.getMessage());
      delete parser;
      throw XmlBlasterException(USER_ILLEGALARGUMENT, ME + "::parse", string("XMLException: ") + msg);
   }
   catch (SAXException &err) {
      string msg = getStringValue(err.getMessage());
      delete parser;
      throw XmlBlasterException(USER_ILLEGALARGUMENT, ME + "::parse", string("SAXException: ") + msg);
   }
   catch (const std::exception& err) { // catches all of bad_alloc, bad_cast, runtime_error, ...
      string msg = err.what() + string(": ") + xmlData;
      delete parser;
      throw XmlBlasterException(USER_ILLEGALARGUMENT, ME + "::parse", string("std:exception: ") + msg);
   }
   catch (const string& err) {
     string msg = err;
     delete parser;
     throw XmlBlasterException(INTERNAL_UNKNOWN, ME + "::parse", string("string exception. message:") + err + ": " + xmlData);
   }
   catch (const char* err) {
     string msg = err;
     delete parser;
     throw XmlBlasterException(INTERNAL_UNKNOWN, ME + "::parse", string("char *exception. message:") + err + ": " + xmlData);
   }
   catch (...) {
     delete parser;
     throw XmlBlasterException(INTERNAL_UNKNOWN, ME + "::parse", string("Unknown parse exception: ") + xmlData);
   }
}

/** Receive notification of the end of the document. */
void Sax2Parser::endDocument() 
{
   if (log_.call()) log_.call(ME, string("endDocument"));
   handler_->endDocument();
}

/** Receive notification of the end of an element. */
void Sax2Parser::endElement(const XMLCh *const /*uri*/, const XMLCh *const /*localname*/, const XMLCh *const qname)
{
   //if (log_.call()) log_.call(ME, string("endElement"));
   handler_->endElement(getStringValue(qname));
}

/** Receive notification of the beginning of the document. */
void Sax2Parser::startDocument()
{
   //if (log_.call()) log_.call(ME, string("startDocument"));
   handler_->startDocument();
}

/** Receive notification of the start of an element. */
void Sax2Parser::startElement(const XMLCh *const /*uri*/, const XMLCh *const /*localname*/, const XMLCh *const qname, const Attributes &attrs)
{
   //if (log_.call()) log_.call(ME, "startElement <" + name + ">");
   AttributeMap tmpMap;
   handler_->startElement(getStringValue(qname), getAttributeMap(tmpMap, attrs));
}

/** Receive notification of the end of a CDATA section. */
void Sax2Parser::endCDATA()
{
   //if (log_.call()) log_.call(ME, string("endCDATA"));
   handler_->endCDATA();
}

/** Receive notification of the start of a CDATA section. */
void Sax2Parser::startCDATA()
{
   //if (log_.call()) log_.call(ME, string("startCDATA"));
   handler_->startCDATA();
}

/** Receive notification of character data inside an element. */
void Sax2Parser::characters(const XMLCh *const chars, const unsigned int length)
{
   //if (log_.call()) log_.call(ME, string("characters"));
   string tmp;
   bool doTrim = false;
   tmp.assign(getStringValue(chars, doTrim), 0, length);
   handler_->characters(tmp);
}