entity_test.cxx File Reference

#include <xercesc/dom/DOM.hpp>
#include <xercesc/framework/LocalFileInputSource.hpp>
#include <xercesc/framework/MemBufInputSource.hpp>
#include <xercesc/util/XMLString.hpp>
#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/util/XMLUni.hpp>
#include <xercesc/sax/ErrorHandler.hpp>
#include <xercesc/sax/SAXParseException.hpp>
#include <xercesc/parsers/XercesDOMParser.hpp>
#include <string>
#include <iostream>

Go to the source code of this file.

Classes
class	XmlErrorHandler

Functions
void	Process (DOMDocument *doc, char *eltName)
int	main (int argc, char *argv[])

Function Documentation

main()

int main	(	int	argc,
		char *	argv[] )

Definition at line 42 of file entity_test.cxx.

                                 {
  
  std::string infile;
  if (argc < 2) { 
    infile=std::string("/u/ey/jrb/dev500/vanilla/xmlBase/v5r1/xml/simpleDoc.xml");
  }
  else {
    infile = std::string(argv[1]);
  }
 
  try {
    XMLPlatformUtils::Initialize();
  }
  catch(const XMLException& toCatch)
  {  // may want to redirect in Gaudi environment
    char*  charMsg = XMLString::transcode(toCatch.getMessage());
    std::string msg = std::string(charMsg);
    XMLString::release(&charMsg);
    //        std::string msg(Dom::transToChar(toCatch.getMessage()));
    std::cerr << "Error during Xerces-c Initialization.\n"
              << "  Exception message:" << msg << std::endl;
    return 0;
  }
 
  const char* inChars = infile.c_str();
  XMLCh* xmlchPath = XMLString::transcode(inChars);
  XercesDOMParser* parser = new XercesDOMParser();
 
  XmlErrorHandler* errorHandler = new XmlErrorHandler();
  parser->setErrorHandler(errorHandler);
 
  // The following made no difference in the output
  //  parser->useScanner(XMLUni::fgDGXMLScanner);
  // According to documentation we shouldn't need this, but
  // can't hurt
  parser->setValidationScheme(AbstractDOMParser::Val_Auto);
  
 
  std::cout << "create entity reference flag has default (true) value" << 
    std::endl;
  parser->parse(xmlchPath);
  DOMDocument* doc = parser->getDocument();
  std::cout << "Document successfully parsed" << std::endl;
  std::cout << "processing local elements.. " << std::endl;
  Process(doc, "const");
  std::cout << std::endl << "processing external elements.. " << std::endl;
  Process(doc, "extConst");
 
  parser->reset();
  parser->setCreateEntityReferenceNodes(false);
 
  std::cout << std::endl << std::endl \
            << "create entity reference flag has value false" << std::endl;
  parser->parse(xmlchPath);
  DOMDocument* expandDoc = parser->getDocument();
  std::cout << "Document successfully parsed" << std::endl;
  std::cout << "processing local elements.. " << std::endl;
  Process(expandDoc, "const");
  std::cout << "processing external elements.. " << std::endl;
  Process(expandDoc, "extConst");
 
}

Process()

void Process	(	DOMDocument *	doc,
		char *	eltName )

Definition at line 105 of file entity_test.cxx.

                                              {
  XMLCh* xmlchEltName = XMLString::transcode(eltName);
  XMLCh* xmlchName = XMLString::transcode("name");
  XMLCh* xmlchValue = XMLString::transcode("value");
  XMLCh* xmlchModified = XMLString::transcode("modified");
  if (!doc) {
    std::cerr << "invalid document " << std::endl;
    return;
  }
 
  // Find all elements with supplied tag name
  DOMNodeList* constList = doc->getElementsByTagName(xmlchEltName);
  unsigned int nElt = constList->getLength();
  for (unsigned int iElt = 0; iElt < nElt; iElt++) {
    try {  
      bool mismatch = false;
      DOMNode* item = constList->item(iElt);
      DOMElement* itemElt = dynamic_cast<DOMElement *>(item);
      DOMElement* byIdElt;
      std::cout << std::endl << eltName << " #" << iElt 
                << " Address as node:  " 
                << item << " and as element: " << itemElt << std::endl;
      const XMLCh* xmlchNamevalue = itemElt->getAttribute(xmlchName);
      if (XMLString::stringLen(xmlchNamevalue) > 0 ) {
        char* namevalue = XMLString::transcode(xmlchNamevalue);
        std::cout << "element has name " << namevalue << std::endl;
        byIdElt = doc->getElementById(xmlchNamevalue);
        std::cout << "Address from getElementById: " << byIdElt << std::endl;
        if (byIdElt != itemElt) {
          mismatch = true;
          std::cout << "**** Address mismatch " << std::endl << std::endl;
        }
        XMLString::release(&namevalue);
      }
      std::cout << "Modifying value attribute using DOM_Element address" << std::endl;
      itemElt->setAttribute(xmlchValue, xmlchModified);
      if (mismatch) {
        std::cout << "Modifying value attribute using looked-up address" 
                  << std::endl;
        byIdElt->setAttribute(xmlchValue, xmlchModified);
 
      }
    }
    catch (DOMException ex) {
      int code = ex.code;
      std::cout << "***** Processing failed for element #" << iElt 
                << " with DOMException, code = " 
                << code << std::endl << std::endl;
    }
  }
  
}

Referenced by main().