---

IgXMLReader.cc

Go to the documentation of this file.

//<<<<<< INCLUDES                                                       >>>>>>

#include "Iguana/Studio/interface/IgXMLReader.h"

#include <xercesc/parsers/XercesDOMParser.hpp>
#include <xercesc/dom/DOMDocument.hpp>
#include <xercesc/sax/HandlerBase.hpp>
#include <xercesc/util/XMLString.hpp>
#include <xercesc/util/PlatformUtils.hpp>
// #include <classlib/utils/DebugAids.h>

//<<<<<< PRIVATE DEFINES                                                >>>>>>

#if defined(XERCES_NEW_IOSTREAMS)
#include <iostream>
#else
#include <iostream.h>
#endif

//<<<<<< PRIVATE CONSTANTS                                              >>>>>>
//<<<<<< PRIVATE TYPES                                                  >>>>>>
//<<<<<< PRIVATE VARIABLE DEFINITIONS                                   >>>>>>
//<<<<<< PUBLIC VARIABLE DEFINITIONS                                    >>>>>>
//<<<<<< CLASS STRUCTURE INITIALIZATION                                 >>>>>>
//<<<<<< PRIVATE FUNCTION DEFINITIONS                                   >>>>>>
//<<<<<< PUBLIC FUNCTION DEFINITIONS                                    >>>>>>
//<<<<<< MEMBER FUNCTION DEFINITIONS                                    >>>>>>

XERCES_CPP_NAMESPACE_USE

IgXMLReader::IgXMLReader ()
{
        try
        {
                XMLPlatformUtils::Initialize ();
                //XERCES_CPP_NAMESPACE_QUALIFIER XercesDOMParser* m_parser = new XercesDOMParser ();
                //parser->setValidationScheme (XercesDOMParser::Val_Always);    
                //parser->setDoNamespaces (true);
        
                //      ErrorHandler* errHandler = (ErrorHandler*) new HandlerBase();
                //      parser->setErrorHandler(errHandler);
        }
        catch (const XMLException& toCatch) 
        {
                char* message = XMLString::transcode(toCatch.getMessage());
                std::cout << "Error during initialization! :\n"
                        << message << "\n";
                XMLString::release(&message);
        }
}

IgXMLReader::~IgXMLReader ()
{
}

XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument*
IgXMLReader::read (const std::string &fileName)
{
        XercesDOMParser* parser = new XercesDOMParser ();
        try 
        {
                parser->parse (fileName.c_str ());
                if (parser->getErrorCount())
                {
                        return 0;
                }
                return parser->getDocument ();
        }
        catch (const XMLException& toCatch) 
        {
                char* message = XMLString::transcode (toCatch.getMessage ());
                std::cerr << "Exception message is: \n"
                                << message << "\n";
                XMLString::release(&message);
                return 0;
        }
        catch (const DOMException& toCatch) 
        {
                char* message = XMLString::transcode(toCatch.msg);
                std::cerr << "Exception message is: \n"
                                << message << "\n";
                XMLString::release(&message);
                return 0;
        }
        catch (...) 
        {
                std::cerr << "Unexpected Exception \n" ;
                return 0;
        }
}

void
IgXMLReader::retrieveTexts (DOMNode* node, std::vector<std::string>& textList, bool isOnlyRoot)
{
        // if 'isonlyroot' is chosen, the passed node is treated as a root node, 
        // so only it's children are examined and not also its neighbours
        if (isOnlyRoot && node)
        {
                retrieveTexts (node->getFirstChild (), textList);
        }
        else
        {
                retrieveTexts (node, textList);
        }
}

void
IgXMLReader::retrieveTexts (DOMNode* node, std::vector<std::string>& textList)
{
        // recursively collect the information in the tags and return it in a vector 
        // of strings ordered by their appearence. depth-first/preorder traversal
        if (node)
        {
                if (node->getNodeType () == DOMNode::TEXT_NODE)
                {
                        // values should not start with tab, whitespace or a new line
                        std::string data = XMLString::transcode (node->getNodeValue ());
                        if (!data.empty () && data[0] != '\t' && data[0] != '\n' && data[0] != ' ')
                        {
                                textList.push_back (data);
                        }
                }
                
                if (node->hasChildNodes ())
                {
                        retrieveTexts (node->getFirstChild (), textList);
                }
                
                node = node->getNextSibling ();
                if (node)
                {
                        retrieveTexts (node, textList);
                }
        }
}

DOMNode*
IgXMLReader::getOneElementByTagName (DOMNode* root, XMLCh* string)
{
        // this method only returns a DOMNode if its tag appears _once_
        DOMNodeList* list = 0;
        DOMNode* result = 0;
        
        if (root)
        {
                list = dynamic_cast<DOMElement *> (root)->getElementsByTagName (string);
                
                
                if (list && list->getLength () == 1)
                {
                        result = list->item (0);
                }
                else
                {
                        std::cerr << "There should only be one node! No node returned!" << std::endl;
                }
        }
        return result;
}

// copied from Alignment/CocoaUtilities/ALIUtils
int
IgXMLReader::isNumber (const std::string& str)
{
        int isnum = 1;
        int numE = 0;
        for (uint ii = 0; ii < str.length(); ii++)
        {
                if (!isdigit(str[ii]) && str[ii]!='.' && str[ii]!='-' && str[ii]!='+')
                {
                        //--- check for E(xponential)
                        if (str[ii] == 'E' || str[ii] == 'e' )
                        {
                                if (numE != 0 || ii == str.length() - 1)
                                {
                                        isnum = 0;
                                        break;
                                }
                                numE++;
                        } 
                        else
                        {
                                isnum = 0; 
                                break;
                        }
                }
        }       
        return isnum;
}

// copied from Alignment/CocoaUtilities/ALIUtils
float 
IgXMLReader::getFloat (const std::string& str) 
{
        //----------- first check that it is a number
        
        if (!isNumber (str))
        {
                std::cerr << "!!!! EXITING: trying to get the float from a string that is not a number " << str << std::endl;
                exit (1);
        }
        return atof (str.c_str ());
}

// copied from PhysicsTools/MVATrainer/XMLDocument
bool 
IgXMLReader::getBool (std::string value)
{
        for (unsigned int i = 0; i < value.size(); i++)
        {
                if (value[i] >= 'A' && value[i] <= 'Z')
                {
                        value[i] += 'a' - 'A';
                }
        }

        if (value == "1" || value == "y" || value == "yes" ||
            value == "true" || value == "ok")
        {
                return true;
        }
        else if (value == "0" || value == "n" || value == "no" || value == "false")
        {
                return false;
        }
        else
        {
                std::cerr << "!!!! EXITING: provided string was not a boolean representation: " << value << std::endl;
                exit (1);
        }
}

---