|| || || || || || || ||

---

XmlDoc.h

Go to the documentation of this file.

#ifndef Impala_Util_XmlDoc_h
#define Impala_Util_XmlDoc_h

#include "Basis/ILog.h"

#include <xercesc/util/XMLString.hpp>
#include <xercesc/dom/DOM.hpp>

namespace Impala
{
namespace Util
{


class XmlDoc
{
public:

    typedef XERCES_CPP_NAMESPACE_QUALIFIER XMLString XMLString;
    typedef XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument DOMDocument;
    typedef XERCES_CPP_NAMESPACE_QUALIFIER DOMNode DOMNode;
    typedef XERCES_CPP_NAMESPACE_QUALIFIER DOMNodeList DOMNodeList;
    typedef XERCES_CPP_NAMESPACE_QUALIFIER DOMNamedNodeMap DOMNamedNodeMap;

    XmlDoc()
    {
    }

    virtual
    ~XmlDoc()
    {
    }

    static String
    XMLCh2String(const XMLCh* xs)
    {
        char* c = XMLString::transcode(xs);
        String res(c);
        XMLString::release(&c);
        return res;
    }

    // DOMDocument based

    // recursive search
    static DOMNodeList*
    GetElementsByName(const DOMDocument* const doc, const char* const tagName)
    {
        XMLCh *xTagName = XMLString::transcode(tagName);
        DOMNodeList* elements = doc->getElementsByTagName(xTagName);
        XMLString::release(&xTagName);
        return elements;
    }

    // DOMNode based

    static String
    GetNodeName(const DOMNode* const node)
    {
        return XMLCh2String(node->getNodeName());
    }

    static String
    GetNodeValue(const DOMNode* const node)
    {
        return XMLCh2String(node->getNodeValue());
    }

    // return val from node containing "<tag> val </tag>"
    static String
    GetElementValue(const DOMNode* const node)
    {
        DOMNode* child = node->getFirstChild();
        if (child == 0)
            return "";
        return XMLCh2String(child->getNodeValue());;
    }

    static DOMNode*
    GetChildNode(const DOMNode* const node, const char* const tagName,
                 bool required)
    {
        DOMNodeList* children = node->getChildNodes();
        XMLCh* xTagName = XMLString::transcode(tagName);
        DOMNode* result = 0;
        for (XMLSize_t i=0 ; i<children->getLength() ; i++)
        {
            DOMNode* child = children->item(i);
            const XMLCh *xChildName = child->getNodeName();
            if (XMLString::equals(child->getNodeName(), xTagName))
            {
                result = child;
                break;
            }
        }
        XMLString::release(&xTagName);
        if ((result == 0) && required)
            ILOG_INFO("No child node " + String(tagName));
        return result;
    }

    static DOMNode*
    GetChildNodeAfter(const DOMNode* const parent, const DOMNode* sibling,
                      const char* const tagName, bool required)
    {
        DOMNodeList* children = parent->getChildNodes();
        XMLCh* xTagName = XMLString::transcode(tagName);
        DOMNode* result = 0;
        bool foundSibling = false;
        for (XMLSize_t i=0 ; i<children->getLength() ; i++)
        {
            DOMNode* child = children->item(i);
            if (child == sibling)
            {
                foundSibling = true;
                continue;
            }
            const XMLCh *xChildName = child->getNodeName();
            if (XMLString::equals(child->getNodeName(), xTagName) && foundSibling)
            {
                result = child;
                break;
            }
        }
        XMLString::release(&xTagName);
        if ((result == 0) && required)
            ILOG_INFO("No child node " + String(tagName));
        return result;
    }

    static std::vector<DOMNode*>
    GetChildNodes(const DOMNode* const node, const char* const tagName)
    {
        DOMNodeList* children = node->getChildNodes();
        XMLCh* xTagName = XMLString::transcode(tagName);
        std::vector<DOMNode*> result;
        for (XMLSize_t i=0 ; i<children->getLength() ; i++)
        {
            DOMNode* child = children->item(i);
            const XMLCh *xChildName = child->getNodeName();
            if (XMLString::equals(child->getNodeName(), xTagName))
                result.push_back(child);
        }
        XMLString::release(&xTagName);
        return result;
    }

    static void
    DumpChildNames(const DOMNode* const node)
    {
        std::cout << "Dumping children of " << GetNodeName(node) << std::endl;
        DOMNodeList* children = node->getChildNodes();
        for (XMLSize_t i=0 ; i<children->getLength() ; i++)
        {
            DOMNode* child = children->item(i);
            std::cout << "  " << i << " = " << GetNodeName(child) << std::endl;
        }
    }

    static String
    GetAttributeValue(const DOMNode* const node, const char* const attributeName)
    {
        if (!node->hasAttributes())
        {
            ILOG_INFO("No attribute " + String(attributeName));
            return "";
        }
        return GetAttributeValue(node->getAttributes(), attributeName);
    }

    static String
    GetAttributeValue(const DOMNode* const node, const char* const attributeName,
                      const char* const defaultV)
    {
        if (!node->hasAttributes())
            return defaultV;
        return GetAttributeValue(node->getAttributes(), attributeName, defaultV);
    }

    static String
    GetAttributeValue(const DOMNamedNodeMap* const attributes,
                      const char* const attributeName)
    {
        XMLCh* xAttribName = XMLString::transcode(attributeName);
        DOMNode* attrib = attributes->getNamedItem(xAttribName);
        XMLString::release(&xAttribName);
        if (attrib == 0)
        {
            ILOG_INFO("No attribute " + String(attributeName));
            return "";
        }
        return GetNodeValue(attrib);
    }

    static String
    GetAttributeValue(const DOMNamedNodeMap* const attributes,
                      const char* const attributeName,
                      const char* const defaultV)
    {
        XMLCh* xAttribName = XMLString::transcode(attributeName);
        DOMNode* attrib = attributes->getNamedItem(xAttribName);
        XMLString::release(&xAttribName);
        if (attrib == 0)
            return defaultV;
        return GetNodeValue(attrib);
    }

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(XmlDoc, Util);

} //namespace Util
} //namespace Impala

#endif

---