---

Dom.cxx

Go to the documentation of this file.

// $Header: /nfs/slac/g/glast/ground/cvs/xml/src/Dom.cxx,v 1.19 2001/11/01 20:01:35 jrb Exp $
// Author:  J. Bogart
//
// Implementation of xml::Dom, a convenient place to put static
// utilities which enhance DOM api.

#include "xml/Dom.h"
#include "dom/DOM_Element.hpp"
#include "dom/DOM_NodeList.hpp"
#include "dom/DOM_CharacterData.hpp"
#include "dom/DOM_NamedNodeMap.hpp"
#include "util/TransService.hpp"
#include "util/PlatformUtils.hpp"
#include <strstream>
#include <string>
#include <cstring>

namespace xml {
  XMLLCPTranscoder*  Dom::transcoder = 0;
  char*              Dom::transBuf = 0;
  int                Dom::transBufSize = 1000;
  XMLCh*             Dom::xmlchBuf = 0;
  int                Dom::xmlchBufSize = 200;

  DOM_Element Dom::findFirstChildByName(const DOM_Element& parent, 
                                        const char* const name) {
    
    DOMString domstr = DOMString(name);
    DOM_NodeList list = parent.getElementsByTagName(domstr);
    int len = list.getLength();
    int iChild;
    
    for (iChild = 0; iChild < len; iChild++) {
      if (  ((domstr.equals("*"))   ||
             (domstr.equals((list.item(iChild)).getNodeName()) ) ) &&
            (list.item(iChild).getParentNode() == (DOM_Node) parent) ) {
        DOM_Node    child_tmp = list.item(iChild);
        DOM_Element& child = static_cast<DOM_Element&>(child_tmp);
        return DOM_Element(child);
      }
    }
    return DOM_Element();
  }

  DOM_Element Dom::findFirstChildByName(const DOM_Element& parent, 
                                        const std::string name) {
    return findFirstChildByName(parent, name.c_str());
  }

  DOM_Element Dom::getSiblingElement(const DOM_Node& child) {
    if (child == DOM_Node()) return DOM_Element();

    DOM_Node sib = child.getNextSibling();

    while (sib != DOM_Node()) {
      if (sib.getNodeType() == DOM_Node::ELEMENT_NODE) {
        return (DOM_Element(static_cast<DOM_Element &> (sib)) );
      }
      sib = sib.getNextSibling();
    }
    return DOM_Element();
  }
    
  DOM_Element  Dom::getFirstChildElement(const DOM_Node& parent) {
    DOM_Node childNode = parent.getFirstChild();

    if (childNode == DOM_Node()) return DOM_Element();
    else if (childNode.getNodeType() == DOM_Node::ELEMENT_NODE) {
      return (DOM_Element(static_cast<DOM_Element &>(childNode)) );
    }
    else return getSiblingElement(childNode);
  }

  std::string   Dom::getAttribute(const DOM_Element& elt, char* attName) {
    DOMString attValue = elt.getAttribute(DOMString(attName));
    if (attValue == DOMString()) return std::string("");

    std::string strValue = std::string(transToChar(attValue));
    return strValue;

  }

  std::string   Dom::getAttribute(const DOM_Element& elt, 
                                  std::string attName) {
    return getAttribute(elt, attName.c_str());
  }
  std::string  Dom::getAttribute(const DOM_Node& elt, 
                            char* attName) {
    if (elt.getNodeType() != DOM_Node::ELEMENT_NODE) {
      return std::string("");
    }
    return getAttribute(static_cast<const DOM_Element&>(elt), attName);
  }

  std::string  Dom::getAttribute(const DOM_Node& elt, 
                            std::string attName) {
    return getAttribute(elt, attName.c_str());
  }

  void  Dom::addAttribute(DOM_Element& elt, std::string name, 
                                 double value) {
    std::strstream s;
    s << value << '\0';

    elt.setAttribute(DOMString(name.c_str()), DOMString(s.str()));
  }

  void  Dom::addAttribute(DOM_Element& elt, const DOMString& name, 
                                 double value) {
    std::strstream s;
    s << value << '\0';

    elt.setAttribute(name, DOMString(s.str()));
  }

  void  Dom::addAttribute(DOM_Element& elt, std::string name, 
                                 int value) {
    std::strstream s;
    s << value << '\0';

    elt.setAttribute(DOMString(name.c_str()), DOMString(s.str()));
  }

  void  Dom::addAttribute(DOM_Element& elt, std::string name, 
                                 unsigned int value) {
    std::strstream s;
    s << value << '\0';

    elt.setAttribute(DOMString(name.c_str()), DOMString(s.str()));
  }

  void  Dom::addAttribute(DOM_Element& elt, std::string name, 
                                 const char* value) {
    elt.setAttribute(DOMString(name.c_str()), DOMString(value));
  }

  void  Dom::addAttribute(DOM_Element& elt, std::string name, 
                                 std::string value) {
    elt.setAttribute(DOMString(name.c_str()), DOMString(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(DOM_Node& node, std::ostream& out) {

    switch(node.getNodeType()) {
    case DOM_Node::ELEMENT_NODE:
      {
        // output start tag
        {
          DOMString tagName = node.getNodeName();
          char *pName = transToChar(tagName);
          out << '<' << pName;
        }
        // ...with attributes
        DOM_NamedNodeMap attMap = node.getAttributes();
        int   nAtt = attMap.getLength();
        int   iAtt;
        for (iAtt = 0; iAtt <nAtt; iAtt++) {
          DOM_Node att = attMap.item(iAtt);
          DOMString  attString = att.getNodeName();
          char *pAtt = transToChar(attString);
          out << ' ' << pAtt << '=';
          attString = att.getNodeValue();
          pAtt = transToChar(attString);
          out << '"' << pAtt << '"';
        }
      
        // iterate through children
        DOM_Node 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
          {
            DOMString endName = node.getNodeName();
            char *    pEnd = transToChar(endName);
            out << "</" << pEnd << ">";
          }
        }
        else {  // no children; use short form for the empty tag
          out << " />";
        } 
      }
      break;
    case DOM_Node::TEXT_NODE:
      // just put it out as is
      {
        DOMString txtValue = node.getNodeValue();
        char *    pTxt = transToChar(txtValue);
        out << pTxt;
      }
      break;

    case DOM_Node::CDATA_SECTION_NODE:
      {
        DOMString txtValue = node.getNodeValue();
        char *    pTxt = transToChar(txtValue);
        // Probably need to put opening and closing sequences in by hand..
        out << "<![CDATA[" << pTxt << "]]>";
      }
      break;
      

    case DOM_Node::COMMENT_NODE :
      // glast.prs doesn't have any comments (but should!)
      {
        DOMString commentValue = node.getNodeValue();
        char *   pComment = transToChar(commentValue);
        out << "<!-- " << pComment << "-->";
      }
      break;
    default:
      // ignore anything else
      break;
    }
  }

  // Assume we need to do the indenting and line breaks
  void Dom::prettyPrintElement(DOM_Node& node, std::ostream& out,
                               std::string prefix) {
    
    out << prefix;
    switch(node.getNodeType()) {

    case DOM_Node::ELEMENT_NODE:
      {
        // output start tag
        DOMString tagName = node.getNodeName();
        char *pName   = transToChar(tagName);
        out << '<' << pName;

        // ...with attributes
        DOM_NamedNodeMap attMap = node.getAttributes();
        int   nAtt = attMap.getLength();
        int   iAtt;
        for (iAtt = 0; iAtt <nAtt; iAtt++) {
          DOM_Node att = attMap.item(iAtt);
          DOMString  attString = att.getNodeName();
          char      *pAtt = transToChar(attString);
          out << ' ' << pAtt << '=';

          attString = att.getNodeValue();
          pAtt = transToChar(attString);
          out << '"' << pAtt << '"';
        }
      
        // iterate through children
        DOM_Node 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
          {
            DOMString endName = node.getNodeName();
            char *    pEnd = transToChar(endName);
            out << prefix << "</" << pEnd << ">" << std::endl;
          }
        }
        else {  // no children; use short form for the empty tag
          out << " />" << std::endl;
        } 
      }
      break;
    case DOM_Node::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.
      {
        DOMString txtValue = node.getNodeValue();
        char *    pTxt = transToChar(txtValue);
        out << pTxt;
      }

      break;

    case DOM_Node::CDATA_SECTION_NODE:
      {
        DOMString txtValue = node.getNodeValue();
        char *    pTxt = transToChar(txtValue);
        // Probably need to put opening and closing sequences in by hand..
        out << "<![CDATA[" << pTxt << "]]>";
      }
      break;
      
    case DOM_Node::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
      {
        DOMString commentValue = node.getNodeValue();
        char *   pComment = transToChar(commentValue);
        out << "<!-- " << pComment << "-->" << std::endl;
      }

      break;
    default:
      // ignore anything else
      break;
    }
  }

  void Dom::prune(DOM_Element elt) {
    DOM_Element child = findFirstChildByName(elt, "*");
    while (child != DOM_Element()) {
      DOM_Element sib = getSiblingElement(child);
      prune(child);
      elt.removeChild(child);
      child = sib;
    }
  }

  char *Dom::transToChar(const XMLCh* const str, int len) {
    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);
  }


  char *Dom::transToChar(DOMString str) {

    return transToChar(str.rawBuffer(), str.length());
  }

  XMLCh* Dom::transToXMLCh(const char* const src) {
    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.
    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();
    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 xml

---