Dom.cxx

Go to the documentation of this file.

// $Header: /bes/bes/BossCvs/Calibration/xmlBase/src/Dom.cxx,v 1.2 2014/04/18 02:24:47 maqm Exp
// $ Author:  J. Bogart
//
// Implementation of xmlBase::Dom, a convenient place to put static
// utilities which enhance DOM api.
 
#include "xmlBase/Dom.h"
#include <xercesc/dom/DOMCharacterData.hpp>
#include <xercesc/dom/DOMDocument.hpp>
#include <xercesc/dom/DOMElement.hpp>
#include <xercesc/dom/DOMException.hpp>
#include <xercesc/dom/DOMNamedNodeMap.hpp>
#include <xercesc/dom/DOMNodeList.hpp>
#include <xercesc/dom/DOMTreeWalker.hpp>
#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/util/TransService.hpp>
#include <xercesc/util/XMLString.hpp>
 
#include "facilities/Util.h"
// #ifdef DEFECT_NO_STRINGSTREAM
// #include <strstream>
// #else
#include <sstream>
// #endif
 
#include <cassert>
#include <cstring>
#include <string>
 
namespace {
  XERCES_CPP_NAMESPACE_USE
 
  DOMTreeWalker* makeWalker( const DOMNode* node ) {
    if ( !node ) return 0;
    DOMDocument*  doc        = node->getOwnerDocument();
    unsigned long whatToShow = DOMNodeFilter::SHOW_ELEMENT;
 
    bool     expand = true;
    DOMNode* casted = const_cast<DOMNode*>( node );
    // Show only elements;  Expand entity references
    DOMTreeWalker* walk = doc->createTreeWalker( casted, whatToShow, 0, expand );
    return walk;
  }
} // namespace
 
namespace xmlBase {
  XERCES_CPP_NAMESPACE_USE
 
  XMLLCPTranscoder* Dom::transcoder = 0;
  char*             Dom::transBuf   = 0;
 
  unsigned int Dom::transBufSize = 1000;
  XMLCh*       Dom::xmlchBuf     = 0;
 
  unsigned int Dom::xmlchBufSize = 200;
  XMLCh*       Dom::xmlchStar    = 0;
 
  DOMElement* Dom::findFirstChildByName( const DOMElement* parent, const char* const name ) {
 
    if ( !xmlchStar ) xmlchStar = XMLString::transcode( "*" );
    if ( !( parent ) )
    { throw NullNode( "from xmlBase::Dom::findFirstChildByName. Null parent arg." ); }
 
    XMLCh* xmlchName = XMLString::transcode( name );
 
    DOMTreeWalker* walk  = makeWalker( parent );
    DOMElement*    child = static_cast<DOMElement*>( walk->firstChild() );
    if ( XMLString::equals( xmlchName, xmlchStar ) ) return child;
 
    if ( !child ) return 0;
    // otherwise cycle through children, looking for first with right tag name
    while ( !XMLString::equals( child->getNodeName(), xmlchName ) )
    {
      child = static_cast<DOMElement*>( walk->nextSibling() );
      if ( !child ) return 0;
    }
 
    XMLString::release( &xmlchName );
 
    walk->release();
    return child;
  }
 
  DOMElement* Dom::findFirstChildByName( const DOMElement* parent, const std::string name ) {
    return findFirstChildByName( parent, name.c_str() );
  }
 
  // Leave this alone for now.  Entities are not likely to cause
  // trouble here.
  DOMElement* Dom::getSiblingElement( const DOMNode* child ) {
    if ( !child ) { throw NullNode( "from xmlBase::Dom::getSiblingElement. Null argument" ); }
 
    DOMNode* sib = child->getNextSibling();
 
    while ( sib )
    {
      if ( sib->getNodeType() == DOMNode::ELEMENT_NODE )
      {
        DOMElement* eltSib = static_cast<DOMElement*>( sib );
 
        return eltSib;
      }
      sib = sib->getNextSibling();
    }
 
    return 0;
  }
 
  DOMElement* Dom::getFirstChildElement( const DOMNode* parent ) {
    const DOMElement* elt = static_cast<const DOMElement*>( parent );
    return findFirstChildByName( elt, "*" );
  }
 
  DOMElement* Dom::getElementById( const DOMDocument* doc, const std::string& id ) {
    XMLCh*      idChars = XMLString::transcode( id.c_str() );
    DOMElement* elt     = doc->getElementById( idChars );
    XMLString::release( &idChars );
    return elt;
  }
 
  std::string Dom::getNodeName( const DOMNode* node ) {
    if ( !node )
    { throw NullNode( "Null node argument supplied to xmlBase::Dom::getNodeName" ); }
    const XMLCh* name = node->getNodeName();
    if ( !name ) return std::string( "" );
 
    char* chrName = XMLString::transcode( name );
 
    std::string strName = std::string( chrName );
    XMLString::release( &chrName );
    return strName;
  }
 
  std::string Dom::getTagName( const DOMElement* elt ) { return Dom::getNodeName( elt ); }
 
  bool Dom::checkTagName( const DOMElement* element, const std::string& tagName ) {
    if ( !element )
    { throw NullNode( "Null dom element argument to xmlBase::Dom::checkTagName" ); }
    if ( tagName == std::string( "*" ) ) return true;
    XMLCh* xmlchTagName = XMLString::transcode( tagName.c_str() );
    bool   ret          = XMLString::equals( xmlchTagName, element->getTagName() );
    XMLString::release( &xmlchTagName );
    return ret;
  }
 
  void Dom::getChildrenByTagName( const DOMElement* parent, const std::string& tagName,
                                  std::vector<DOMElement*>& children, bool clear ) {
    if ( !parent )
    { throw NullNode( "from xmlBase::Dom::getChildrenByTagName. Null parent arg" ); }
    if ( clear ) children.clear();
    DOMElement* child = getFirstChildElement( parent );
    while ( child != 0 )
    {
      if ( checkTagName( child, tagName ) ) { children.push_back( child ); }
      child = getSiblingElement( child );
    }
  }
 
  void Dom::getDescendantsByTagName( const DOMElement* parent, const std::string& tagName,
                                     std::vector<DOMElement*>& children, bool clear ) {
    if ( parent == 0 )
    { throw NullNode( "from xmlBase::Dom::getChildrenByTagName. Null parent arg" ); }
    if ( clear ) children.clear();
    XMLCh* xmlchTagName = XMLString::transcode( tagName.c_str() );
    ;
    DOMNodeList* list = parent->getElementsByTagName( xmlchTagName );
    XMLString::release( &xmlchTagName );
    unsigned int nItem = list->getLength();
    for ( unsigned int iItem = 0; iItem < nItem; iItem++ )
    { children.push_back( static_cast<DOMElement*>( list->item( iItem ) ) ); }
  }
 
  void Dom::getAttributeNodeMap( const DOMNode* node, std::map<std::string, DOMNode*>& atts,
                                 bool clear ) {
 
    if ( clear ) atts.clear();
    DOMNamedNodeMap* nodeMap = node->getAttributes();
    unsigned int     nAtts   = nodeMap->getLength();
 
    for ( unsigned iAtt = 0; iAtt < nAtts; iAtt++ )
    {
      DOMNode* attNode                           = nodeMap->item( iAtt );
      atts[xmlBase::Dom::getNodeName( attNode )] = attNode;
    }
  }
 
  bool Dom::hasAttribute( const DOMNode* node, const char* attName ) {
    bool ret = false;
    if ( node == 0 ) return ret;
    if ( node->getNodeType() != DOMNode::ELEMENT_NODE ) return ret;
 
    const DOMElement* elt          = static_cast<const DOMElement*>( node );
    XMLCh*            xmlchAttName = XMLString::transcode( attName );
    ret                            = ( elt->getAttributeNode( xmlchAttName ) != 0 );
    XMLString::release( &xmlchAttName );
    return ret;
  }
 
  std::string Dom::getAttribute( const DOMElement* elt, const char* attName ) {
    if ( elt == 0 ) { throw NullNode( "from xmlBase::Dom::getAttribute. Null argument" ); }
 
    XMLCh*       xmlchAttName = XMLString::transcode( attName );
    const XMLCh* attValue     = elt->getAttribute( xmlchAttName );
    XMLString::release( &xmlchAttName );
 
    if ( attValue == 0 ) return std::string( "" );
 
    char*       chrAttValue = XMLString::transcode( attValue );
    std::string strValue    = std::string( chrAttValue );
    XMLString::release( &chrAttValue );
    return strValue;
  }
 
  std::string Dom::getAttribute( const DOMElement* elt, std::string attName ) {
 
    return getAttribute( elt, attName.c_str() );
  }
 
  std::string Dom::getAttribute( const DOMNode* elt, const char* attName ) {
    if ( elt == 0 ) { throw NullNode( "from xmlBase::Dom::getAttribute. Null argument" ); }
 
    if ( elt->getNodeType() != DOMNode::ELEMENT_NODE )
    { throw NullNode( "from xmlBase::Dom::getAttribute. Non-element argument" ); }
    return getAttribute( static_cast<const DOMElement*>( elt ), attName );
  }
 
  std::string Dom::getAttribute( const DOMNode* elt, std::string attName ) {
    return getAttribute( elt, attName.c_str() );
  }
 
  double Dom::getDoubleAttribute( const DOMNode* elt, std::string attName ) {
    std::string stringValue = getAttribute( elt, attName );
 
    if ( stringValue == std::string( "" ) )
    { throw NullNode( "from xmlBase::Dom::getDoubleAttribute.  non-existent attribute" ); }
    try
    {
      return facilities::Util::stringToDouble( stringValue );
    } catch ( facilities::WrongType ex )
    {
      std::cerr << ex.getMsg();
      throw WrongAttributeType( "from xmlBase::Dom::getDoubleAttribute" );
    }
  }
 
  unsigned Dom::getDoublesAttribute( const DOMNode* elt, std::string attName,
                                     std::vector<double>& values, bool clear ) {
    unsigned                 nVals = 0;
    std::vector<std::string> tokens;
    if ( clear ) values.clear();
    std::string stringValue = getAttribute( elt, attName );
    if ( stringValue.size() == 0 ) return nVals;
 
    facilities::Util::stringTokenize( stringValue, std::string( " " ), tokens );
 
    try
    {
      unsigned nToken = tokens.size();
      for ( unsigned iToken = 0; iToken < nToken; iToken++ )
      {
        values.push_back( facilities::Util::stringToDouble( tokens[iToken] ) );
        nVals++;
      }
    } catch ( facilities::WrongType ex )
    {
      std::cerr << ex.getMsg();
      throw WrongAttributeType( "from xmlBase::Dom::getDoublesAttribute" );
    }
    return nVals;
  }
  unsigned Dom::getFloatsAttribute( const DOMNode* elt, std::string attName,
                                    std::vector<float>& values, bool clear ) {
    unsigned                 nVals = 0;
    std::vector<std::string> tokens;
    if ( clear ) values.clear();
    std::string stringValue = getAttribute( elt, attName );
    if ( stringValue.size() == 0 ) return nVals;
 
    facilities::Util::stringTokenize( stringValue, std::string( " " ), tokens );
 
    try
    {
      unsigned nToken = tokens.size();
      for ( unsigned iToken = 0; iToken < nToken; iToken++ )
      {
        values.push_back( facilities::Util::stringToDouble( tokens[iToken] ) );
        nVals++;
      }
    } catch ( facilities::WrongType ex )
    {
      std::cerr << ex.getMsg();
      throw WrongAttributeType( "from xmlBase::Dom::getDoublesAttribute" );
    }
    return nVals;
  }
 
  int Dom::getIntAttribute( const DOMNode* elt, std::string attName ) {
    std::string stringValue = getAttribute( elt, attName );
 
    if ( stringValue == std::string( "" ) )
    { throw NullNode( "from xmlBase::Dom::getIntAttribute.  non-existent attribute" ); }
    try
    { return facilities::Util::stringToInt( stringValue ); } catch ( facilities::WrongType ex )
    {
      std::cerr << ex.getMsg();
      throw WrongAttributeType( "from xmlBase::Dom::getIntAttribute" );
    }
  }
 
  unsigned Dom::getIntsAttribute( const DOMNode* elt, std::string attName,
                                  std::vector<int>& values, bool clear ) {
    unsigned                 nVals = 0;
    std::vector<std::string> tokens;
    if ( clear ) values.clear();
    std::string stringValue = getAttribute( elt, attName );
    if ( stringValue.size() == 0 ) return nVals;
 
    facilities::Util::stringTokenize( stringValue, std::string( " " ), tokens );
 
    try
    {
      unsigned nToken = tokens.size();
      for ( unsigned iToken = 0; iToken < nToken; iToken++ )
      {
        values.push_back( facilities::Util::stringToInt( tokens[iToken] ) );
        nVals++;
      }
    } catch ( facilities::WrongType ex )
    {
      std::cerr << ex.getMsg();
      throw WrongAttributeType( "from xmlBase::Dom::getIntsAttribute" );
    }
    return nVals;
  }
 
  std::string Dom::getText( const DOMNode* textNode ) {
    short int nType = textNode->getNodeType();
 
    if ( ( nType != DOMNode::TEXT_NODE ) && ( nType != DOMNode::COMMENT_NODE ) &&
         ( nType != DOMNode::CDATA_SECTION_NODE ) )
    { throw WrongNodeType( "from xmlBase::Dom::getText, argument not text node" ); }
    const XMLCh* t = textNode->getNodeValue();
    if ( t == 0 ) return std::string( "" );
    char*       chrText = XMLString::transcode( t );
    std::string text    = std::string( chrText );
    XMLString::release( &chrText );
 
    return text;
  }
 
  std::string Dom::getTextContent( const DOMElement* elt ) {
    if ( elt->getNodeType() != DOMNode::ELEMENT_NODE )
    { throw WrongNodeType( "from xmlBase::Dom::getTextContent, argument not element node" ); }
    return ( getText( elt->getFirstChild() ) );
  }
 
  void Dom::addAttribute( DOMElement* elt, std::string name, double value ) {
    if ( elt == 0 ) { throw NullNode( "from xmlBase::Dom::addAttribute.  null argument" ); }
 
    // #ifdef DEFECT_NO_STRINGSTREAM
    //     std::strstream s;
    //     s << value << '\0';
    // #else
    std::ostringstream s;
    s << value;
    // #endif
 
    std::string str        = s.str();
    XMLCh*      xmlchValue = XMLString::transcode( str.c_str() );
    XMLCh*      xmlchName  = XMLString::transcode( name.c_str() );
 
    try
    { elt->setAttribute( xmlchName, xmlchValue ); } catch ( DOMException ex )
    {
      char* msg = XMLString::transcode( ex.msg );
      std::cerr << "DOMException in xmlBase::Dom::addAttribute(double)" << std::endl;
      std::cerr << "Msg: " << std::string( msg ) << "Code: " << ex.code << std::endl;
      XMLString::release( &msg );
      throw ex;
    }
    XMLString::release( &xmlchName );
    XMLString::release( &xmlchValue );
  }
 
  void Dom::addAttribute( DOMElement* elt, std::string name, int value ) {
    if ( elt == 0 ) { throw NullNode( "from xmlBase::Dom::addAttribute.  Null argument" ); }
 
    // #ifdef DEFECT_NO_STRINGSTREAM
    //     std::strstream s;
    //     s << value << '\0';
    // #else
    std::ostringstream s;
    s << value;
    // #endif
 
    std::string str = s.str();
 
    XMLCh* xmlchValue = XMLString::transcode( str.c_str() );
    XMLCh* xmlchName  = XMLString::transcode( name.c_str() );
 
    try
    { elt->setAttribute( xmlchName, xmlchValue ); } catch ( DOMException ex )
    {
      char* msg = XMLString::transcode( ex.msg );
      std::cerr << "DOMException in xmlBase::Dom::addAttribute(int)" << std::endl;
      std::cerr << "Msg: " << std::string( msg ) << "Code: " << ex.code << std::endl;
      XMLString::release( &msg );
      throw ex;
    }
 
    XMLString::release( &xmlchName );
    XMLString::release( &xmlchValue );
  }
 
  void Dom::addAttribute( DOMElement* elt, std::string name, unsigned int value ) {
    if ( elt == 0 ) { throw NullNode( "from xmlBase::Dom::addAttribute.  Null argument" ); }
 
    // #ifdef DEFECT_NO_STRINGSTREAM
    //     std::strstream s;
    //     s << value << '\0';
    // #else
    std::ostringstream s;
    s << value;
    // #endif
 
    std::string str = s.str();
 
    XMLCh* xmlchValue = XMLString::transcode( str.c_str() );
    XMLCh* xmlchName  = XMLString::transcode( name.c_str() );
 
    try
    { elt->setAttribute( xmlchName, xmlchValue ); } catch ( DOMException ex )
    {
      char* msg = XMLString::transcode( ex.msg );
      std::cerr << "DOMException in xmlBase::Dom::addAttribute(unsigned int)" << std::endl;
      std::cerr << "Msg: " << std::string( msg ) << "Code: " << ex.code << std::endl;
      XMLString::release( &msg );
      throw ex;
    }
    XMLString::release( &xmlchName );
    XMLString::release( &xmlchValue );
  }
 
  void Dom::addAttribute( DOMElement* elt, std::string name, const char* value ) {
 
    if ( elt == 0 ) { throw NullNode( "from xmlBase::Dom::addAttribute.  Null argument" ); }
 
    XMLCh* xmlchValue = XMLString::transcode( value );
    XMLCh* xmlchName  = XMLString::transcode( name.c_str() );
 
    try
    { elt->setAttribute( xmlchName, xmlchValue ); } catch ( DOMException ex )
    {
      char* msg = XMLString::transcode( ex.msg );
      std::cerr << "DOMException in xmlBase::Dom::addAttribute(char*)" << std::endl;
      std::cerr << "Msg: " << std::string( msg ) << "Code: " << ex.code << std::endl;
      std::cerr.flush();
      XMLString::release( &msg );
      throw ex;
    }
 
    XMLString::release( &xmlchName );
    XMLString::release( &xmlchValue );
  }
 
  void Dom::addAttribute( DOMElement* elt, std::string name, std::string value ) {
 
    if ( elt == 0 ) throw NullNode( "from xmlBase::Dom::addAttribute. Null argument" );
 
    addAttribute( elt, name, value.c_str() );
  }
 
  /*
      Serialize a node (and any children) to the specified ostream.
      prefix is for now ignored, but see note following.
 
      The only node types which actually do get written are
           element (and its attributes and children)
           text
           comment
 
      NB:  For this first pass, printElement outputs all the
           supported node types just as they appeared in the
           serialization before parsing *if* the parse was
           non-validating.  If it *was* validating (or if
           the DOM representation was built programmatically
           rather than by parsing a file) then ignorable
           white space will have been thrown away (in the
           validated case) or there won't have been any to
           begin with (programmatically-built case)
           so the printed version will be a horrific single
           line except that line breaks appearing within
           comments or text nodes will be preserved.
 
           Ideally would like to be able to query the DOM
           or have an argument passed in to tell us whether
           ignorable white space has been thrown away, in which
           case we should attempt to pretty print by putting
           newlines in in reasonable places and keeping track
           of a sensible indentation level.
 
           For now, make two different functions.  See
           prettyPrintElement below.
  */
  void Dom::printElement( DOMNode* node, std::ostream& out ) {
 
    if ( node == 0 ) { throw NullNode( "from xmlBase::Dom::printElement. Null argument" ); }
 
    switch ( node->getNodeType() )
    {
    case DOMNode::ELEMENT_NODE: {
      // output start tag
      {
        std::string tagName = getNodeName( node );
        out << '<' << tagName;
      }
      // ...with attributes
 
      typedef std::map<std::string, DOMNode*> AttMap;
      AttMap                                  atts;
      AttMap::const_iterator                  it;
      getAttributeNodeMap( node, atts );
 
      for ( it = atts.begin(); it != atts.end(); it++ )
      {
        std::string attName = ( *it ).first;
        out << ' ' << attName << '=';
        out << '"' << getAttribute( node, attName ) << '"';
      }
 
      // iterate through children
      DOMNode* child = node->getFirstChild();
      if ( child != 0 )
      { // there are children
        out << '>';
        while ( child != 0 )
        {
          Dom::printElement( child, out );
          child = child->getNextSibling();
        }
        // output end tag, long form
        {
          std::string endName = getNodeName( node );
          out << "</" << endName << ">";
        }
      }
      else
      { // no children; use short form for the empty tag
        out << " />";
      }
    }
    break;
    case DOMNode::TEXT_NODE:
      // just put it out as is
      { out << getText( node ); }
      break;
 
    case DOMNode::CDATA_SECTION_NODE: {
      out << "<![CDATA[" << getText( node ) << "]]>";
    }
    break;
 
    case DOMNode::COMMENT_NODE:
      // glast.prs doesn't have any comments (but should!)
      { out << "<!-- " << getText( node ) << "-->"; }
      break;
    default:
      // ignore anything else
      break;
    }
  }
 
  // Assume we need to do the indenting and line breaks
  void Dom::prettyPrintElement( DOMNode* node, std::ostream& out, std::string prefix ) {
 
    if ( node == 0 )
    { throw NullNode( "from xmlBase::Dom::prettyPrintElement. Null argument" ); }
 
    out << prefix;
    switch ( node->getNodeType() )
    {
 
    case DOMNode::ELEMENT_NODE: {
      // output start tag
      std::string tagName = getNodeName( node );
      out << '<' << tagName;
 
      // ...with attributes
      typedef std::map<std::string, DOMNode*> AttMap;
      AttMap                                  atts;
      AttMap::const_iterator                  it;
 
      getAttributeNodeMap( node, atts );
 
      for ( it = atts.begin(); it != atts.end(); it++ )
      {
        std::string attName = ( *it ).first;
        out << ' ' << attName << '=';
        out << '"' << getAttribute( node, attName ) << '"';
      }
 
      // iterate through children
      DOMNode* child = node->getFirstChild();
      if ( child != 0 )
      { // there are children
        out << '>' << std::endl;
        while ( child != 0 )
        {
          // new indent level
          Dom::prettyPrintElement( child, out, prefix + "  " );
          child = child->getNextSibling();
        }
        // output end tag, long form
        {
          std::string endName = getNodeName( node );
          out << prefix << "</" << endName << ">" << std::endl;
        }
      }
      else
      { // no children; use short form for the empty tag
        out << " />" << std::endl;
      }
    }
    break;
    case DOMNode::TEXT_NODE:
      // just put it out as is
      // Note this won't indent correctly if the text node
      // contains multiple lines.
      // Similarly, it's too much work to avoid sometimes putting out
      // an "extra" blank line in the vicinity of text.
      // Current code puts the extra <cr> before
      // the text node.
      { out << getText( node ); }
 
      break;
 
    case DOMNode::CDATA_SECTION_NODE: {
      // Probably need to put opening and closing sequences in by hand..
      out << "<![CDATA[" << getText( node ) << "]]>";
    }
    break;
 
    case DOMNode::COMMENT_NODE:
      // glast.prs doesn't have any comments (but should!)
      // Note this won't indent correctly if the text node
      // contains multiple lines.  Could have utility routine
      // to do this, to be called for comments and text nodes
      { out << "<!-- " << getText( node ) << "-->" << std::endl; }
 
      break;
    default:
      // ignore anything else
      break;
    }
  }
 
  void Dom::prune( DOMElement* elt ) {
    DOMElement* child = findFirstChildByName( elt, "*" );
    while ( child != 0 )
    {
      DOMElement* sib = getSiblingElement( child );
      prune( child );
      elt->removeChild( child );
      child = sib;
    }
  }
  char* Dom::transToChar( const XMLCh* const str ) {
    return transToChar( str, XMLString::stringLen( str ) );
  }
 
  char* Dom::transToChar( const XMLCh* const str, unsigned int len ) {
    // Passing null argument is a fatal error.
    // No, it's not
    //    assert(str != 0);
    if ( str == 0 ) return 0;
 
    if ( !transcoder )
    {
      int status = initTrans();
      if ( !status ) return 0;
    }
 
    // Find length of str to pass to transcode(..) rather than
    // just passing output buffer size.  This is important because
    // (for Xerces 1.3 anyway) the transcode routine will try to read
    // this many bytes from the input buffer, conceivably causing
    // an access violation if it's more than the actual input
    // buffer length
 
    if ( len + 1 > transBufSize )
    { // return old buffer; allocate a bigger one
      char* tBuf = new char[len + 1];
      if ( !tBuf ) return 0;
      transBufSize = len + 1;
      delete[] transBuf;
      transBuf = tBuf;
    }
 
    bool ok;
    ok = Dom::transcoder->transcode( str, transBuf, len );
    return ( ok ? transBuf : 0 );
  }
 
  XMLCh* Dom::transToXMLCh( const char* const src ) {
    // Passing null string is a fatal error
    // No, it's not
    if ( src == 0 ) return 0;
    if ( !transcoder )
    {
      int status = initTrans();
      if ( !status ) return 0;
    }
    // as with transToChar above, find actual length of char*
    // and pass that to Xerces utility for 3rd (maxChars) argument.
    unsigned int len = strlen( src ) + 1;
    if ( len > xmlchBufSize )
    {
      XMLCh* tBuf = new XMLCh[len];
      if ( !tBuf ) return 0;
      xmlchBufSize = len;
      delete[] xmlchBuf;
      xmlchBuf = tBuf;
    }
 
    bool ok;
 
    ok = transcoder->transcode( src, xmlchBuf, len );
    return ( ok ? xmlchBuf : 0 );
  }
 
  int Dom::initTrans() {
    transcoder = XMLPlatformUtils::fgTransService->makeNewLCPTranscoder(
        XMLPlatformUtils::fgMemoryManager );
    if ( !transcoder ) return 0; // and complain?!? Shouldn't ever happen
    transBuf = new char[transBufSize];
    if ( !transBuf )
    {
      delete transcoder;
      return 0;
    }
    xmlchBuf = new XMLCh[xmlchBufSize];
    if ( !xmlchBuf )
    {
      delete[] transBuf;
      delete transcoder;
      return 0;
    }
    return 1;
  }
 
} // end namespace xmlBase