XMLHelpers.cxx

Go to the documentation of this file.

#include "AtlfastAlgs/XMLHelpers.h"

namespace Atlfast{
  
  // ============================================
  
  char* getText(DOMNode* node){
    if (node->getNodeType()==DOMNode::ELEMENT_NODE){
      DOMNodeList* children = node->getChildNodes();
      for(XMLSize_t cptr = 0; cptr < children->getLength();++cptr){
        
        DOMNode* cnode = children->item(cptr);
        
        if (cnode->getNodeType()==DOMNode::TEXT_NODE){
          DOMText* textNode = static_cast<DOMText*>(cnode);
          return XMLString::transcode(textNode->getData());
        }
      }
    }
    return 0;
  }
  
  std::vector<DOMNode*>  getAllChildTagsByName(DOMNode* node, std::string name) {
    DOMNodeList* children = node->getChildNodes();
    
    std::vector<DOMNode*> nodes;
    for(XMLSize_t ptr = 0; ptr < children->getLength(); ++ptr){
      DOMNode* node = children->item(ptr);
      char* nodeName = XMLString::transcode(node->getNodeName());
      if ( strcmp(nodeName, name.c_str()) == 0){
        nodes.push_back(node);
      }
      XMLString::release(&nodeName);
    }
    
    // std::cout<<"found "<<nodes.size()<<" for name "<<name<<std::endl;
    return nodes;
  }
  
  // ============================================
  
  DOMNode* getFirstChildTagByName(DOMNode* node, std::string name) {
    DOMNodeList* children = node->getChildNodes();
    
    for(XMLSize_t ptr = 0; ptr < children->getLength(); ++ptr){
      DOMNode* node = children->item(ptr);
      char* nodeName = XMLString::transcode(node->getNodeName());
      bool useThisNode = strcmp(nodeName, name.c_str()) == 0;
      XMLString::release(&nodeName);
      if ( useThisNode ) return node;
    }
    
    return 0;
  }
  
  // ============================================

  void getFirstValue(DOMNode* node, std::string tagname, std::string&  value){
    
    DOMNode* cnode = getFirstChildTagByName(node, tagname);
    if(cnode != 0){
      char *textPtr = getText(cnode);
      value = textPtr;
      delete [] textPtr;
    }else{
      std::cout<<"setFirstValue(): tagname "<<tagname
               <<" not found"<<std::endl;   
    }
  }  
  
  // ============================================
  
  void getFirstValue(DOMNode* node, std::string tagname, double& value){
    
    DOMNode* cnode = getFirstChildTagByName(node, tagname);
    if(cnode != 0){
      char *textPtr = getText(cnode);
      value = atof(textPtr);
      delete [] textPtr;
    }else{
      std::cout<<"setFirstValue(): tagname "<<tagname
               <<" not found"<<std::endl;   
    }
  }  
  
  // ============================================
  
  void getFirstValue(DOMNode* node, std::string tagname, int& value){
    
    DOMNode* cnode = getFirstChildTagByName(node,tagname);
    if(cnode != 0){
      char *textPtr = getText(cnode);
      value = atoi(textPtr);
      delete [] textPtr;
    }else{
      std::cout<<"setFirstValue(): tagname "<<tagname
               <<" not found"<<std::endl;   
    }
  }  
  
  // ============================================
  
  void getAllValues(DOMNode* node, std::string tagname, std::vector<double>& values){
    
    // Empty the vector first
    values.clear();

    DOMNode* cnode = getFirstChildTagByName(node,tagname);
    if(cnode != 0){

      char* xtmp = getText(cnode);
      std::string input_values(xtmp);
      xercesc::XMLString::release( &xtmp );
      
      std::stringstream ss(input_values,
                           std::stringstream::in | std::stringstream::out);
      
      double value = 0;
      while (!ss.eof()){
        ss >> value;
        values.push_back(value);
      }
    }else{
      std::cout<<"setFirstValue(): tagname "<<tagname
               <<" not found"<<std::endl;   
    }
  }  
    
  // ============================================
  
  DOMDocument* parseFileForDocument(const char* xmlFile) {
    
    std::cout<<"Starting parseFileForDocument: "<<xmlFile<<std::endl;
    
    try {
      XMLPlatformUtils::Initialize();
    }
    catch (const XMLException& toCatch) {
      char* message = XMLString::transcode(toCatch.getMessage());
      std::cout << "Error during initialization! :\n"
                << message << "\n";
      XMLString::release(&message);
      return 0;
    }
    
    XercesDOMParser* parser = new XercesDOMParser();
    // parser->setValidationScheme(XercesDOMParser::Val_Always);    // optional.
    parser->setDoNamespaces(true);    // optional
    
    ErrorHandler* errHandler = (ErrorHandler*) new HandlerBase();
    parser->setErrorHandler(errHandler);
    
    std::cout<<"Parse - start\n";
    try {
      parser->parse(xmlFile);
      std::cout<<"Parse - end\n";
    }
    catch (const XMLException& toCatch) {
      char* message = XMLString::transcode(toCatch.getMessage());
      std::cout << "Exception message is: \n"
                << message << "\n";
      XMLString::release(&message);
      return 0;
    }
    catch (const DOMException& toCatch) {
      char* message = XMLString::transcode(toCatch.msg);
      std::cout << "Exception message is: \n"
                << message << "\n";
      XMLString::release(&message);
      return 0;
    }
    catch (...) {
      std::cout << "Unexpected Exception \n" ;
      return 0;
    }
    
    
    // Changing what happens here (SJHD 25/07/2006)
    // The ownership of the DOMDocument must transfer away from
    // the Parser at this point, so that the parser can be released
    // but the document's info can continue to be accessed. The
    // DOMDocument is then deleted at a later stage to release the
    // (huge amount of) associated memory.

    DOMDocument* dom = parser->adoptDocument();
    
    // Getting rid of error-handler and parser
    delete errHandler;
    delete parser;
    
    if (dom == 0){
      std::cout<<"Zero DOM pointer, bailing out...\n";
      return 0;
    }else return dom;
    
  }
  
  // ============================================
  
  std::vector<char*> getTagVals(DOMElement* docElement, const char* tagname){
    DOMNodeList* tags = 
      docElement->getElementsByTagName(XMLString::transcode(tagname));
    
    std::cout<<"Found "<<tags->getLength()<<" tags with name "<<tagname<<std::endl;
    std::vector<char*> tagVals;
    
    for(XMLSize_t ptr = 0; ptr < tags->getLength();++ptr){
      
      DOMNode* node = tags->item(ptr);
      std::vector<DOMText*> textNodes;
      if (node->getNodeType()==DOMNode::ELEMENT_NODE){
        DOMNodeList* children = node->getChildNodes();
        for(XMLSize_t cptr = 0; cptr < children->getLength();++cptr){
          
          DOMNode* cnode = children->item(cptr);
          
          if (cnode->getNodeType()==DOMNode::TEXT_NODE){
            textNodes.push_back(static_cast<DOMText*>(cnode));
          }
        }
        if (textNodes.size() != 1){
          std::cout<<"Error: found "<<textNodes.size()<<" text nodes"<<std::endl;
        }
        std::vector<DOMText*>::const_iterator itr = textNodes.begin();
        std::vector<DOMText*>::const_iterator end = textNodes.end();
        for(;itr!=end;++itr){
          tagVals.push_back(XMLString::transcode((*itr)->getData()));
        }
      } 
    }
    return tagVals;
  }
  
} //namespace Atlfast

---