HttpXmlDocument.cc

#include "otsdaq/XmlUtilities/HttpXmlDocument.h"
#include "otsdaq/Macros/CoutMacros.h"
#include "otsdaq/Macros/StringMacros.h"
#include "otsdaq/MessageFacility/MessageFacility.h"
#include "otsdaq/XmlUtilities/ConvertFromXML.h"
#include "otsdaq/XmlUtilities/ConvertToXML.h"
// #include "otsdaq_cmsoutertracker/otsdaq-cmsoutertracker/Ph2_ACF/Utils/MessageTools.h"
 
#include <stdexcept>
#include <xercesc/dom/DOM.hpp>
#include <xercesc/dom/DOMDocument.hpp>
#include <xercesc/dom/DOMDocumentType.hpp>
#include <xercesc/dom/DOMElement.hpp>
#include <xercesc/dom/DOMImplementation.hpp>
#include <xercesc/dom/DOMImplementationLS.hpp>
#include <xercesc/dom/DOMImplementationRegistry.hpp>
// #include <xercesc/dom/DOMLSSerializer.hpp>
// #include <xercesc/dom/DOMLSOutput.hpp>
#include <xercesc/dom/DOMNodeIterator.hpp>
#include <xercesc/dom/DOMNodeList.hpp>
#include <xercesc/dom/DOMText.hpp>
#include <xercesc/validators/common/Grammar.hpp>
 
#include <xercesc/parsers/XercesDOMParser.hpp>
#include <xercesc/util/XMLUni.hpp>
#include <xercesc/util/XercesDefs.hpp>
 
#include <xercesc/framework/LocalFileFormatTarget.hpp>
#include <xercesc/util/OutOfMemoryException.hpp>
 
#include <iostream>
#include <list>
#include <sstream>
 
#include <errno.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
 
#include <chrono>  //for std::chrono
 
using namespace ots;
 
//==============================================================================
HttpXmlDocument::HttpXmlDocument(std::string cookieCode, std::string displayName)
    : XmlDocument("ROOT")
    , headerElement_(0)
    , dataElement_(0)
    , headerTagName_("HEADER")
    , dataTagName_("DATA")
    , cookieCodeTagName_("CookieCode")
    , displayNameTagName_("DisplayName")
{
    // __COUT__ << "in" << std::endl;
    //<HEADER>
    if(cookieCode != "" || displayName != "")  // add header
    {
        headerElement_ = theDocument_->createElement(CONVERT_TO_XML(headerTagName_));
        rootElement_->appendChild(headerElement_);
        if(cookieCode != "")  // add cookie code to header
            addTextElementToParent(cookieCodeTagName_, cookieCode, headerElement_);
        if(displayName != "")  // add display name to header
            addTextElementToParent(displayNameTagName_, displayName, headerElement_);
    }
 
    //<DATA>
    dataElement_ = theDocument_->createElement(CONVERT_TO_XML(dataTagName_));
    rootElement_->appendChild(dataElement_);
    // __COUT__ << "out" << std::endl;
}
 
//==============================================================================
HttpXmlDocument::HttpXmlDocument(const HttpXmlDocument& doc)
    : XmlDocument(doc)
    , headerElement_(0)
    , dataElement_(0)
    , headerTagName_(doc.headerTagName_)
    , dataTagName_(doc.dataTagName_)
    , cookieCodeTagName_(doc.cookieCodeTagName_)
    , displayNameTagName_(doc.displayNameTagName_)
{
    // __COUT__ << "in" << std::endl;
    *this = doc;
    // __COUT__ << "out" << std::endl;
}
 
//==============================================================================
HttpXmlDocument& HttpXmlDocument::operator=(const HttpXmlDocument& doc)
{
    // __COUT__ << "in" << std::endl;
    recursiveElementCopy(doc.rootElement_, rootElement_);
    // __COUT__ << "in" << std::endl;
    if(doc.headerElement_ != 0)
        headerElement_ = (xercesc::DOMElement*)rootElement_
                             ->getElementsByTagName(CONVERT_TO_XML(headerTagName_))
                             ->item(0);
    // __COUT__ << "in" << std::endl;
    dataElement_ = (xercesc::DOMElement*)rootElement_
                       ->getElementsByTagName(CONVERT_TO_XML(dataTagName_))
                       ->item(0);
    // __COUT__ << "out" << std::endl;
    return *this;
}
 
//==============================================================================
HttpXmlDocument::~HttpXmlDocument(void) {}
 
void HttpXmlDocument::setHeader(std::string cookieCode, std::string displayName)
{
    if(headerElement_)
    {
        std::stringstream ss;
        ss << __COUT_HDR_FL__
           << "Can NOT set header to doc with a header! Only allowed for docs without "
              "header element.";
        __SS_THROW__;
    }
 
    if(cookieCode != "" || displayName != "")  // add header
    {
        headerElement_ = theDocument_->createElement(CONVERT_TO_XML(headerTagName_));
        rootElement_->appendChild(headerElement_);
        if(cookieCode != "")  // add cookie code to header
            addTextElementToParent(cookieCodeTagName_, cookieCode, headerElement_);
        if(displayName != "")  // add display name to header
            addTextElementToParent(displayNameTagName_, displayName, headerElement_);
    }
}
 
//==============================================================================
xercesc::DOMElement* HttpXmlDocument::addTextElementToData(const std::string& childName,
                                                           const std::string& childValue)
{
    // __COUT__ << "in - " << childName << " value: " << childValue <<std::endl << std::endl;
    return addTextElementToParent(childName, childValue, dataElement_);
}
 
//==============================================================================
xercesc::DOMElement* HttpXmlDocument::addBinaryStringToData(const std::string& childName,
                                                            const std::string& binary)
{
    std::string convertStr = "";
    char        hexStr[3];
    for(unsigned int i = 0; i < binary.length(); ++i)
    {
        // for every byte make hex
        sprintf(hexStr, "%2.2X", ((unsigned char)binary[i]));
        hexStr[2] = '\0';
        convertStr += hexStr;
    }
 
    return addTextElementToParent(childName, convertStr, dataElement_);
}
 
//==============================================================================
unsigned int HttpXmlDocument::getChildrenCount(xercesc::DOMElement* parent)
{
    if(!parent)
        parent = dataElement_;  // default to data element
 
    xercesc::DOMNodeList* nodeList =
        parent->getChildNodes();  // get all children   within parent
    unsigned int count = 0;
 
    for(unsigned int i = 0; i < nodeList->getLength(); ++i)
    {
        if(nodeList->item(i)->getNodeType() !=
           xercesc::DOMNode::TEXT_NODE)  // ignore text node children
            ++count;
    }
 
    return count;
}
 
//==============================================================================
void HttpXmlDocument::removeDataElement(unsigned int dataChildIndex)
{
    xercesc::DOMNodeList* nodeList =
        dataElement_->getChildNodes();  // get all children within data
 
    for(unsigned int i = 0; i < nodeList->getLength(); ++i)
    {
        if(nodeList->item(i)->getNodeType() ==
           xercesc::DOMNode::TEXT_NODE)  // ignore text node children
            continue;
 
        if(!dataChildIndex)  // remove
        {
            recursiveRemoveChild((xercesc::DOMElement*)(nodeList->item(i)), dataElement_);
            return;
        }
 
        --dataChildIndex;  // find proper child
    }
 
    // here, then child doesnt exist
}  // end removeDataElement()
 
//==============================================================================
void HttpXmlDocument::copyDataChildren(HttpXmlDocument& document)
{
    // add all first level child elements of data and recurse on them
    xercesc::DOMNodeList* nodeList =
        document.dataElement_->getChildNodes();  // get all children    within data
    for(unsigned int i = 0; i < nodeList->getLength(); ++i)
    {
        if(nodeList->item(i)->getNodeType() ==
           xercesc::DOMNode::TEXT_NODE)  // ignore text node children
            continue;
 
        recursiveAddElementToParent(
            (xercesc::DOMElement*)(nodeList->item(i)), dataElement_, true /* html*/);
    }
}  // end copyDataChildren()
 
//==============================================================================
void HttpXmlDocument::outputXmlDocument(std::ostringstream* out,
                                        bool                dispStdOut /* = false */,
                                        bool                allowWhiteSpace /* = false */,
                                        bool                printErrors /* = false */)
{
    recursiveOutputXmlDocument(theDocument_->getDocumentElement(),
                               out,
                               dispStdOut,
                               "",
                               allowWhiteSpace,
                               printErrors);
}  // end outputXmlDocument()
 
//==============================================================================
void HttpXmlDocument::recursiveOutputXmlDocument(xercesc::DOMElement* currEl,
                                                 std::ostringstream*  out,
                                                 bool                 dispStdOut,
                                                 std::string          tabStr,
                                                 bool                 allowWhiteSpace,
                                                 bool                 printErrors)
{
#if 0
    auto start = std::chrono::high_resolution_clock::now();
#endif
 
    // open field tag
    if(dispStdOut)
        std::cout << tabStr << "<" << XML_TO_CHAR(currEl->getNodeName());
    if(out)
        *out << tabStr << "<" << XML_TO_CHAR(currEl->getNodeName());
 
    // insert value if text node child
    if(currEl->getFirstChild() != NULL &&
       currEl->getFirstChild()->getNodeType() ==
           xercesc::DOMNode::TEXT_NODE)  // if has a text node first, insert as value
                                         // attribute
    {
        //if is error, then double escape < > to &lt; and &gt; for better display in web browser
        std::string nodeName = std::string(XML_TO_CHAR(currEl->getNodeName()));
        //consider any field ending in case-insensitive "Error" an error field for this purpose
        bool isError = nodeName.length() >= 5 &&
                       (nodeName[nodeName.length() - 5] == 'E' ||
                        nodeName[nodeName.length() - 5] == 'e') &&
                       (nodeName[nodeName.length() - 4] == 'R' ||
                        nodeName[nodeName.length() - 4] == 'r') &&
                       (nodeName[nodeName.length() - 3] == 'R' ||
                        nodeName[nodeName.length() - 3] == 'r') &&
                       (nodeName[nodeName.length() - 2] == 'O' ||
                        nodeName[nodeName.length() - 2] == 'o') &&
                       (nodeName[nodeName.length() - 1] == 'R' ||
                        nodeName[nodeName.length() - 1] == 'r');
 
        if(dispStdOut)
            std::cout << " value='"
                      << StringMacros::escapeString(
                             XML_TO_CHAR(currEl->getFirstChild()->getNodeValue()),
                             allowWhiteSpace,
                             isError /* forHtml */)
                      << "'";
        if(out)
            *out << " value='"
                 << StringMacros::escapeString(
                        XML_TO_CHAR(currEl->getFirstChild()->getNodeValue()),
                        allowWhiteSpace,
                        isError /* forHtml */)
                 << "'";
 
        if(printErrors && isError)
            __COUT_ERR__ << "xml Error-type field '" << nodeName << "' encountered:\n"
                         << XML_TO_CHAR(currEl->getFirstChild()->getNodeValue()) << __E__;
    }
 
#if 0
    {
        auto end = std::chrono::high_resolution_clock::now();
        auto duration =
            std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
        __COUTT__ << tabStr << XML_TO_CHAR(currEl->getNodeName()) << " -- Time taken to call recurse xml out = " << duration << " milliseconds." << std::endl;
    }
#endif
 
    xercesc::DOMNodeList* nodeList = currEl->getChildNodes();  // get all children
 
#if 0
    {
        auto end = std::chrono::high_resolution_clock::now();
        auto duration =
            std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
        __COUTT__ << tabStr << XML_TO_CHAR(currEl->getNodeName()) << " -- Time taken to call recurse xml out = " << duration << " milliseconds." << std::endl;
    }
#endif
 
    // close opening field tag
    if(dispStdOut)
        std::cout << ((nodeList->getLength() == 0 ||
                       (nodeList->getLength() == 1 &&
                        currEl->getFirstChild()->getNodeType() ==
                            xercesc::DOMNode::TEXT_NODE))
                          ? "/"
                          : "")
                  << ">"
                  << " len:" << nodeList->getLength() << std::endl;
    if(out)
    {
        // Dario-style... means always full node name closing tag
        if(darioXMLStyle_ &&
           !(std::string(XML_TO_CHAR(currEl->getNodeName())) == "ROOT" ||
             std::string(XML_TO_CHAR(currEl->getNodeName())) == "HEADER" ||
             std::string(XML_TO_CHAR(currEl->getNodeName())) == "DATA" ||
             std::string(XML_TO_CHAR(currEl->getNodeName())) == "node" ||
             std::string(XML_TO_CHAR(currEl->getNodeName())) == "nodes"))
        {
            *out << ">"
                 << StringMacros::escapeString(
                        XML_TO_CHAR(currEl->getFirstChild()->getNodeValue()),
                        allowWhiteSpace)
                 << "</" << XML_TO_CHAR(currEl->getNodeName()) << ">" << std::endl;
        }
        else
        {
            *out << ((nodeList->getLength() == 0 ||
                      (nodeList->getLength() == 1 &&
                       currEl->getFirstChild()->getNodeType() ==
                           xercesc::DOMNode::TEXT_NODE))
                         ? "/"
                         : "")
                 << ">" << std::endl;
 
            if(printErrors && strcmp(XML_TO_CHAR(currEl->getNodeName()), "Error") == 0)
                __COUT_ERR__ << "xml field 'Error' encountered:\n"
                             << XML_TO_CHAR(currEl->getFirstChild()->getNodeValue())
                             << __E__;
        }
    }
 
#if 0
    {
        auto end = std::chrono::high_resolution_clock::now();
        auto duration =
            std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
        __COUTT__ << tabStr << XML_TO_CHAR(currEl->getNodeName()) << " " << nodeList->getLength() <<
            " -- Time taken to call recurse xml out = " << duration << " milliseconds." << std::endl;
    }
#endif
 
    // insert children
    std::string newTabStr = tabStr + "\t";
    for(unsigned int i = 0; i < nodeList->getLength(); ++i)
        if(nodeList->item(i)->getNodeType() !=
           xercesc::DOMNode::TEXT_NODE)  // ignore text node children
            recursiveOutputXmlDocument(
                (xercesc::DOMElement*)(nodeList->item(i)),
                out,
                dispStdOut,
                newTabStr,  //save for debug decor: + " i=" + std::to_string(i) + " ",
                allowWhiteSpace);
 
#if 0
    {
        auto end = std::chrono::high_resolution_clock::now();
        auto duration =
            std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
        __COUTT__ << tabStr << XML_TO_CHAR(currEl->getNodeName()) << " -- Time taken to call recurse xml out = " << duration << " milliseconds." << std::endl;
    }
#endif
 
    if(currEl == dataElement_ &&  //append the data string stream
       dataSs_.str().length())    //(for large data blocks that do not need to be escaped)
    {
        if(dispStdOut)
            std::cout << dataSs_.str() << std::endl;
        if(out)
            *out << dataSs_.str() << std::endl;
    }
 
    // close tag if children
    if(nodeList->getLength() > 1 ||
       (nodeList->getLength() == 1 &&
        currEl->getFirstChild()->getNodeType() != xercesc::DOMNode::TEXT_NODE))
    {
        if(dispStdOut)
            std::cout << tabStr << "</" << XML_TO_CHAR(currEl->getNodeName()) << ">"
                      << std::endl;
        if(out)
            *out << tabStr << "</" << XML_TO_CHAR(currEl->getNodeName()) << ">"
                 << std::endl;
    }
 
#if 0
    {
        auto end = std::chrono::high_resolution_clock::now();
        auto duration =
            std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
        __COUTT__ << tabStr << XML_TO_CHAR(currEl->getNodeName()) << " -- DONE Time taken to call recurse xml out = " << duration << " milliseconds." << std::endl;
    }
#endif
}  // end recursiveOutputXmlDocument()
 
//==============================================================================
std::string HttpXmlDocument::getMatchingValue(const std::string& field,
                                              const unsigned int occurance)
{
    unsigned int count = 0;
    return recursiveFindElementValue(
        theDocument_->getDocumentElement(), field, occurance, count);
}  //end getMatchingValue()
 
//==============================================================================
std::string HttpXmlDocument::recursiveFindElementValue(xercesc::DOMElement* currEl,
                                                       const std::string&   field,
                                                       const unsigned int   occurance,
                                                       unsigned int&        count)
{
    if(XML_TO_CHAR(currEl->getNodeName()) == field &&
       occurance == count++)  // found, done!!
    {
        if(currEl->getFirstChild() != NULL &&
           currEl->getFirstChild()->getNodeType() ==
               xercesc::DOMNode::TEXT_NODE)  // if has a text node first, return as
                                             // value attribute
            return StringMacros::escapeString(
                XML_TO_CHAR(currEl->getFirstChild()->getNodeValue()));
        else
            return "";  // empty value attribute
    }
 
    std::string retStr;
    // look through children recursively
    xercesc::DOMNodeList* nodeList = currEl->getChildNodes();  // get all children
    for(unsigned int i = 0; i < nodeList->getLength(); ++i)
        if(nodeList->item(i)->getNodeType() !=
           xercesc::DOMNode::TEXT_NODE)  // ignore text node children
        {
            retStr = recursiveFindElementValue(
                (xercesc::DOMElement*)(nodeList->item(i)), field, occurance, count);
            if(retStr != "")
                return retStr;  // found among children already, done
                                // else continue search within children recursively
        }
    return "";  // nothing found
}  //end recursiveFindElementValue()
 
//==============================================================================
void HttpXmlDocument::getAllMatchingValues(const std::string&        field,
                                           std::vector<std::string>& retVec)
{
    recursiveFindAllElements(theDocument_->getDocumentElement(), field, &retVec);
}  //end getAllMatchingValues()
 
//==============================================================================
void HttpXmlDocument::recursiveFindAllElements(xercesc::DOMElement*      currEl,
                                               const std::string&        field,
                                               std::vector<std::string>* retVec)
{
    if(XML_TO_CHAR(currEl->getNodeName()) == field && currEl->getFirstChild() != NULL &&
       currEl->getFirstChild()->getNodeType() ==
           xercesc::DOMNode::TEXT_NODE)  // if has a text node first, return as value
                                         // attribute
        retVec->push_back(XML_TO_CHAR(currEl->getFirstChild()->getNodeValue()));
 
    // look through children recursively
    xercesc::DOMNodeList* nodeList = currEl->getChildNodes();  // get all children
    for(unsigned int i = 0; i < nodeList->getLength(); ++i)
        if(nodeList->item(i)->getNodeType() !=
           xercesc::DOMNode::TEXT_NODE)  // ignore text node children
            recursiveFindAllElements(
                (xercesc::DOMElement*)(nodeList->item(i)), field, retVec);
}  //end recursiveFindAllElements()
 
//==============================================================================
xercesc::DOMElement* HttpXmlDocument::getMatchingElement(const std::string& field,
                                                         const unsigned int occurance)
{
    return getMatchingElementInSubtree(
        theDocument_->getDocumentElement(), field, occurance);
}  //end getMatchingElement()
 
//==============================================================================
xercesc::DOMElement* HttpXmlDocument::getMatchingElementInSubtree(
    xercesc::DOMElement* parentEl, const std::string& field, const unsigned int occurance)
{
    unsigned int count = 0;
    return recursiveFindElement(parentEl, field, occurance, count);
}  //end getMatchingElementInSubtree()
 
//==============================================================================
xercesc::DOMElement* HttpXmlDocument::recursiveFindElement(xercesc::DOMElement* currEl,
                                                           const std::string&   field,
                                                           const unsigned int   occurance,
                                                           unsigned int&        count)
{
    if(XML_TO_CHAR(currEl->getNodeName()) == field &&
       occurance == count++)  // found, done!!
    {
        if(currEl->getFirstChild() != NULL &&
           currEl->getFirstChild()->getNodeType() ==
               xercesc::DOMNode::TEXT_NODE)  // if has a text node first, return as
                                             // value attribute
            return currEl;
        else
            return 0;  // empty value attribute
    }
 
    xercesc::DOMElement* retEl;
    // look through children recursively
    xercesc::DOMNodeList* nodeList = currEl->getChildNodes();  // get all children
    for(unsigned int i = 0; i < nodeList->getLength(); ++i)
        if(nodeList->item(i)->getNodeType() !=
           xercesc::DOMNode::TEXT_NODE)  // ignore text node children
        {
            retEl = recursiveFindElement(
                (xercesc::DOMElement*)(nodeList->item(i)), field, occurance, count);
            if(retEl)
                return retEl;  // found among children already, done
                               // else continue search within children recursively
        }
    return 0;  // nothing found
}  //end recursiveFindElement()
 
//==============================================================================
void HttpXmlDocument::recursiveAddElementToParent(xercesc::DOMElement* child,
                                                  xercesc::DOMElement* parent,
                                                  bool                 html)
{
    std::string childText = "";
 
    std::string childName =
        XML_TO_CHAR(child->getNodeName());  // XML_TO_CHAR(currEl->getNodeName());
 
    if(child->getFirstChild() != NULL &&
       child->getFirstChild()->getNodeType() ==
           xercesc::DOMNode::
               TEXT_NODE)  // if has a text node first, insert as value attribute
    {
        childText = XML_TO_CHAR(child->getFirstChild()->getNodeValue());
        if(0 &&
           html)  //RAR stopped doing this escape as of Feb-2025 because it seems to double escape html characters like &#009; into &amp;#009; which doesnt work at the browser (tested with MacroMakerSupervisor)
        {
            __COUTS__(20) << "pre escape childText " << childText << std::endl;
            childText = StringMacros::escapeString(childText, true /* allowWhiteSpace*/);
            __COUTS__(20) << "post escape childText " << childText << std::endl;
        }
    }
    __COUTS__(20) << "childName " << childName << " childText " << childText << std::endl;
 
    // insert child
    xercesc::DOMElement* newParent = addTextElementToParent(childName, childText, parent);
 
    // insert rest of child tree
    xercesc::DOMNodeList* nodeList = child->getChildNodes();  // get all children of child
    for(unsigned int i = 0; i < nodeList->getLength(); ++i)
    {
        if(nodeList->item(i)->getNodeType() ==
           xercesc::DOMNode::TEXT_NODE)  // ignore text node children
            continue;
 
        recursiveAddElementToParent(
            (xercesc::DOMElement*)(nodeList->item(i)), newParent, html);
    }
}  //end recursiveAddElementToParent()
 
//==============================================================================
void HttpXmlDocument::getAllMatchingElements(const std::string&                 field,
                                             std::vector<xercesc::DOMElement*>& retVec)
{
    recursiveFindAllElements(theDocument_->getDocumentElement(), field, &retVec);
}  //end getAllMatchingElements()
 
//==============================================================================
void HttpXmlDocument::recursiveFindAllElements(xercesc::DOMElement*               currEl,
                                               const std::string&                 field,
                                               std::vector<xercesc::DOMElement*>* retVec)
{
    if(XML_TO_CHAR(currEl->getNodeName()) == field && currEl->getFirstChild() != NULL &&
       currEl->getFirstChild()->getNodeType() ==
           xercesc::DOMNode::TEXT_NODE)  // if has a text node first, return as value
                                         // attribute
        retVec->push_back(currEl);
 
    // look through children recursively
    xercesc::DOMNodeList* nodeList = currEl->getChildNodes();  // get all children
    for(unsigned int i = 0; i < nodeList->getLength(); ++i)
        if(nodeList->item(i)->getNodeType() !=
           xercesc::DOMNode::TEXT_NODE)  // ignore text node children
            recursiveFindAllElements(
                (xercesc::DOMElement*)(nodeList->item(i)), field, retVec);
}  //end recursiveFindAllElements()
 
//==============================================================================
bool HttpXmlDocument::loadXmlDocument(const std::string& filePath)
{
    // __COUT__<< "Loading theDocument_ from file: " << filePath <<
    // std::endl;
 
    struct stat fileStatus;
 
    if(stat(filePath.c_str(), &fileStatus) != 0)
    {
        //__SS__ << "File not accessible: " << filePath << std::endl;
        //__SS_THROW__;
        return false;  // not an error for file to not exist
    }
 
    // reset xml platform and theDocument_
    terminatePlatform();
    initPlatform();
 
    xercesc::XercesDOMParser* parser = new xercesc::XercesDOMParser;
    // Configure xercesc::DOM parser.
    parser->setValidationScheme(xercesc::XercesDOMParser::Val_Auto);
    parser->setDoNamespaces(true);
    parser->setDoSchema(true);
    parser->useCachedGrammarInParse(false);
 
    try
    {
        parser->parse(filePath.c_str());
 
        // theDocument_ memory object owned by the parent parser object
        theDocument_ = parser->adoptDocument();  // instead of getDocument() so parser
                                                 // will not free theDocument_ when
                                                 // released
 
        // Get the top-level element: Name is "root". No attributes for "root"
        rootElement_ = theDocument_->getDocumentElement();
        if(!rootElement_)
        {
            __SS__ << "empty XML theDocument_: " << filePath << std::endl;
            __SS_THROW__;
            throw(std::runtime_error("empty XML theDocument_"));
        }
 
        recursiveFixTextFields(
            rootElement_);  // remove space and new lines from value attribute
 
        xercesc::DOMNodeList* nodeList =
            theDocument_->getElementsByTagName(CONVERT_TO_XML(headerTagName_));
        if(nodeList->getLength())  // may not always be header element
            headerElement_ =
                (xercesc::DOMElement*)(theDocument_
                                           ->getElementsByTagName(
                                               CONVERT_TO_XML(headerTagName_))
                                           ->item(0));
        else
            headerElement_ = 0;
 
        dataElement_ = (xercesc::DOMElement*)(theDocument_
                                                  ->getElementsByTagName(
                                                      CONVERT_TO_XML(dataTagName_))
                                                  ->item(0));  // always is data
    }
    catch(xercesc::XMLException& e)
    {
        __SS__ << "Error parsing file: " << filePath << std::endl;
        __SS_THROW__;
        __COUT__ << "Error parsing file." << std::endl;
        return false;
    }
    delete parser;
 
    return true;
}  //end loadXmlDocument()
 
//==============================================================================
void HttpXmlDocument::recursiveFixTextFields(xercesc::DOMElement* currEl)
{
    xercesc::DOMNodeList* nodeList = currEl->getChildNodes();  // get all children
 
    // recurse through children
    for(unsigned int i = 0; i < nodeList->getLength(); ++i)
        if(nodeList->item(i)->getNodeType() ==
           xercesc::DOMNode::TEXT_NODE)  // fix text nodes
            ((xercesc::DOMElement*)(nodeList->item(i)))
                ->setTextContent(CONVERT_TO_XML(  // change text value to escaped version
                    StringMacros::escapeString(XML_TO_CHAR(
                        ((xercesc::DOMElement*)(nodeList->item(i)))->getNodeValue()))));
        else
            recursiveFixTextFields((xercesc::DOMElement*)(nodeList->item(i)));
}  //end recursiveFixTextFields()