sax2xercesparser.cpp

java开源的企业总线.xmlBlaster

//
// ErrorHandler methods
//

/** Warning. */
void Sax2Parser::warning(const SAXParseException &ex) 
{
   if (log_.call()) log_.call(ME, string("warning"));
   string txt = getLocationString(ex) + "\n";
   handler_->warning(txt);
}
      
      
/** Error. */
void Sax2Parser::error(const SAXParseException &ex) 
{
   if (log_.call()) log_.call(ME, string("error"));
   string txt = getLocationString(ex) + "\n";
   handler_->error(txt);
}


/** Fatal error. */
void Sax2Parser::fatalError(const SAXParseException &ex) 
{
   if (log_.call()) log_.call(ME, string("fatalError"));
   string txt = getLocationString(ex) + "\n";
   handler_->fatalError(txt);
}


/** Returns a string of the location. */
string Sax2Parser::getLocationString(const SAXParseException &ex) 
{
  string systemId = getStringValue(ex.getSystemId());
  string str;
  if (systemId != "") {
    string::size_type index = systemId.find_last_of('/');
    if (index != string::npos) systemId = systemId.substr(index + 1);
    str = systemId + ":";
  }
  string message = Sax2Parser::getStringValue(ex.getMessage(), true);
  return str + "line=" + lexical_cast<std::string>(ex.getLineNumber()) 
      + "/col=" + lexical_cast<std::string>(ex.getColumnNumber()) + " " + message;
}


/**
 * Compares two strings (where name1 is a Unicode3.0 string!!) for 
 * unsensitive case compare. It returns true if the content of the
 * strings is equal (no matter what the case is). Using this method to
 * compare the strings should be portable to all platforms supported by
 * xerces.
 */
bool Sax2Parser::caseCompare(const XMLCh *name1, const char *name2) 
{
  XMLCh* name1Helper = XMLString::replicate(name1);
  XMLString::upperCase(name1Helper);
  XMLCh* name2Helper = XMLString::transcode(name2);
  XMLString::upperCase(name2Helper);
  bool ret = (XMLString::compareIString(name1Helper, name2Helper) == 0);
  Sax2Parser::releaseXMLCh(&name1Helper);
  Sax2Parser::releaseXMLCh(&name2Helper);
  return ret;
}


/**
 * returns a trimmed value (usually from an attribute) as a string
 */
string Sax2Parser::getStringValue(const XMLCh* const value, bool doTrim) const
{
   /* Works only with US-ASCII:
   char* help = 0;
   try {
      string ret;
      help = XMLString::transcode(value);
      if (help != 0) {
         if (doTrim) ret = StringTrim::trim(help);
         else ret = string(help);
         Sax2Parser::releaseXMLCh(&help);
      }
   }
   catch (...) {
      if (help != 0)
         Sax2Parser::releaseXMLCh(&help);
      cerr << "Caught exception in getStringValue(XMLCh=" << value << ")" << endl;
      // throw;
   }
   */
   if (value == NULL) {
      return "";
   }

/*
Converts from the encoding of the service to the internal XMLCh* encoding.
unsigned int
XMLUTF8Transcoder::transcodeFrom(const  XMLByte* const          srcData
                                , const unsigned int            srcCount
                                ,       XMLCh* const            toFill
                                , const unsigned int            maxChars
                                ,       unsigned int&           bytesEaten
                                ,       unsigned char* const    charSizes)
*/
/*
Converts from the internal XMLCh* encoding to the encoding of the service.
Parameters:
    srcData     the source buffer to be transcoded
    srcCount    number of characters in the source buffer
    toFill      the destination buffer
    maxBytes    the max number of bytes in the destination buffer
    charsEaten  after transcoding, this will hold the number of chars that were processed from the source buffer
    options     options to pass to the transcoder that explain how to respond to an unrepresentable character

Returns:
    Returns the number of chars put into the target buffer 
unsigned int
XMLUTF8Transcoder::transcodeTo( const   XMLCh* const    srcData
                                , const unsigned int    srcCount
                                ,       XMLByte* const  toFill
                                , const unsigned int    maxBytes
                                ,       unsigned int&   charsEaten
                                , const UnRepOpts       options)

*/

   unsigned int charsEatenFromSource = 0;
   unsigned int counter = 0;
   string result;
   unsigned int charsToRead = XMLString::stringLen(value);
   do {
      char resultXMLString_Encoded[ENCODERBUFFERSIZE+4];
      *resultXMLString_Encoded = 0;
      charsEatenFromSource = 0;
      int charsPutToTarget = xmlBlasterTranscoder_->transcodeTo(value+counter,
                                    XMLString::stringLen(value)-counter,
                                    (XMLByte*) resultXMLString_Encoded,
                                    ENCODERBUFFERSIZE,
                                    charsEatenFromSource,
                                    XMLTranscoder::UnRep_Throw );

      /*
      log_.info(ME,"TRANSCODE TMP: got '" + result +
                   "' charsToRead= " + lexical_cast<string>(charsToRead) +
                   "' ENCODERBUFFERSIZE= " + lexical_cast<string>(ENCODERBUFFERSIZE) +
                   " charsEaten=" + lexical_cast<string>(charsEatenFromSource) +
                   " counter=" + lexical_cast<string>(counter) +
                   " charsPutToTarget=" + lexical_cast<string>(charsPutToTarget));
      */
      if (charsEatenFromSource < 1)
         break;
      result += string(resultXMLString_Encoded, charsPutToTarget);
      counter += charsEatenFromSource;
   }
   while(charsEatenFromSource < charsToRead); //charsEatenFromSource== ENCODERBUFFERSIZE || charsPutToTarget == ENCODERBUFFERSIZE);

   //log_.info(ME,"TRANSCODE DONE: got '" + result + "' ENCODERBUFFERSIZE= " + lexical_cast<string>(ENCODERBUFFERSIZE) + " charsEaten=" + lexical_cast<string>(charsEatenFromSource));

   if (doTrim) StringTrim::trim(result);

   return result;
}


AttributeMap& Sax2Parser::getAttributeMap(AttributeMap& attrMap, const Attributes &attrs)
{
   int len = attrs.getLength();
   for (int i = 0; i < len; i++) {
      attrMap[getStringValue(attrs.getQName(i))] = getStringValue(attrs.getValue(i));
   }
   return attrMap;
}

/**
 * gets the attribute specified by 'name' in the attribute list specified by 'list'. The result is put in 
 * the 'value' argument which is passed by reference. It returns 'true' if the attribute was found in the
 * specified attribute list or 'false' if it was not. In the later case, the value is untouched by this 
 * method.
 */
bool Sax2Parser::getStringAttr(const Attributes& attrs, const XMLCh* const name, string& value, bool doTrim) const
{
   const XMLCh* tmp = attrs.getValue(name);
   if (!tmp) return false;

   char* help1 = NULL;
   try {
      help1 = XMLString::transcode(tmp);
      if (!help1) return false;
      if (doTrim) {
         value.assign(StringTrim::trim(help1));
      }
      else value.assign(help1);
   }
   catch (...) {}
   Sax2Parser::releaseXMLCh(&help1);
   return true;
}


void Sax2Parser::releaseXMLCh(XMLCh** data)
{
#if XERCES_VERSION_MAJOR > 1 && XERCES_VERSION_MINOR > 1
   XMLString::release(data);
#else
   delete [] *data;
   *data = 0;
#endif
}

void Sax2Parser::releaseXMLCh(char** data)
{
#if XERCES_VERSION_MAJOR > 1 && XERCES_VERSION_MINOR > 1
   XMLString::release(data);
#else
   delete [] *data;
   *data = 0;
#endif
}

#endif  // XMLBLASTER_XERCES_PLUGIN

}}}} // namespace
#endif // _UTIL_PARSER_SAX2XERCESPARSER_C