arzmq-sys 0.6.3

#include "protoXml.h"

#include <protoDebug.h>


bool ProtoXml::GetPropAsDouble(xmlNodePtr nodePtr, const char* attrName, double& value)
{
    xmlChar* attrValue = xmlGetProp(nodePtr, (xmlChar*)attrName);
    if (NULL == attrValue) 
    {
        PLOG(PL_WARN, "ProtoXml::GetPropAsDouble() error: no attr found!\n");
        return false;
    }
    bool result = true;
    if (1 != sscanf((const char*)attrValue, "%lf", &value))
    {
        PLOG(PL_WARN, "ProtoXml::GetPropAsDouble() error: invalid attr format!\n");
        result = false;
    }
    xmlFree(attrValue);
    return result;
}  // end ProtoXml::GetPropAsDouble()


bool ProtoXml::GetPropAsInt(xmlNodePtr nodePtr, const char* attrName, int& value)
{
    xmlChar* attrValue = xmlGetProp(nodePtr, (xmlChar*)attrName);
    if (NULL == attrValue) 
    {
        PLOG(PL_WARN, "ProtoXml::GetPropAsInt() error: no attr found!\n");
        return false;
    }
    bool result = true;
    if (1 != sscanf((const char*)attrValue, "%d", &value))
    {
        PLOG(PL_WARN, "ProtoXml::GetPropAsInt() error: invalid attr format!\n");
        result = false;
    }
    xmlFree(attrValue);
    return result;
}  // end ProtoXml::GetPropAsInt()

ProtoXml::IterFilterBase::Filter::Filter(const char* filterPath)
{
    filter_path[FILTER_PATH_MAX] = '\0';
    SetPath(filterPath);
}

void ProtoXml::IterFilterBase::Filter::SetPath(const char* filterPath)
{
    if (NULL != filterPath)
        strncpy(filter_path, filterPath, FILTER_PATH_MAX);
    else
        filter_path[0] = '\0';
}  // end ProtoXML::IterFilterBase::Filter::SetPath()

ProtoXml::IterFilterBase::IterFilterBase(const char* filterPath)
 : path_filter(filterPath)
{
    path_current[FILTER_PATH_MAX] = '\0';
    Reset();
}

void ProtoXml::IterFilterBase::SetFilter(const char* filterPath)
{
    path_filter_list.Destroy();
    path_filter.SetPath(filterPath);
}  // end ProtoXml::IterFilterBase::SetFilter()

bool ProtoXml::IterFilterBase::AddFilter(const char* filterPath)
{
    if (path_filter.IsSet())
    {
        Filter* filter = new Filter(filterPath);
        if (NULL == filter)
        {
            PLOG(PL_ERROR, "ProtoXml::IterFilterBase::AddFilter() new Filter error: %s\n", GetErrorString());
            return false;
        }
        path_filter_list.Insert(*filter);
    }
    else
    {
        path_filter.SetPath(filterPath);
    }
    return true;
}  // end ProtoXml::IterFilterBase::SetFilter()

void ProtoXml::IterFilterBase::Reset()
{
    path_current[0] = '\0';
    path_current_len = 0;
    path_depth = 0;
}  // end ProtoXml::IterFilterBase::Reset()

bool ProtoXml::IterFilterBase::UpdateCurrentPath(int nodeDepth, const char* nodeName)
{
    if (nodeDepth == path_depth)
    {
        // Replace "path_current" tail with "/nodeName"
        char* ptr = strrchr(path_current, '/');
        if (NULL == ptr) ptr = path_current;
        size_t tailLen = strlen(ptr);
        size_t nameLen = strlen(nodeName);
        if ((path_current_len - tailLen + 1 + nameLen) > FILTER_PATH_MAX)
        {
            PLOG(PL_WARN, "ProtoXml::IterFilterBase::UpdatePath() error: XML path name exceeds filter maximum\n");
            return false;
        }
        *ptr++ = '/';
        strcpy(ptr, nodeName);
        path_current_len += nameLen + 1 - tailLen;
    }
    else if (nodeDepth > path_depth)
    {
        ASSERT(1 == (nodeDepth - path_depth));
        // Append path_current with '/' + "nodeName"
        size_t nameLen = strlen((const char*)nodeName);
        if ((path_current_len + 1 + nameLen) > FILTER_PATH_MAX)
        {
            PLOG(PL_ERROR, "ProtoXml::IterParser::GetNext() error: XML path name exceeds filter maximum\n");
            return false;
        }
        //ASSERT(0 != path_current_len);
        char* ptr = path_current + path_current_len;
        *ptr++ = '/';
        strcpy(ptr, (char*)nodeName);
        path_current_len += (1 + nameLen);
        path_depth++;
    }
    else // if (nodeDepth < path_depth)
    {
        //TRACE("path_depth:%d nodeDepth:%d\n", path_depth, nodeDepth);
        char* ptr = path_current;
        for (int i = 0; i <= nodeDepth; i++)
        {
            ptr = strchr(ptr, '/');
            ASSERT(NULL != ptr);
            ptr++;
        }
        size_t headLen = ptr - path_current;
        size_t nameLen = strlen((const char*)nodeName);
        if ((headLen + nameLen) > FILTER_PATH_MAX)
        {
            PLOG(PL_ERROR, "ProtoXml::IterParser::GetNext() error: XML path name exceeds filter maximum\n");
            return false;
        }
        strcpy(ptr, nodeName);
        path_current_len = headLen + nameLen;
        path_depth = nodeDepth;
    }
    //TRACE("path_current = %s (depth:%d)\n", path_current, path_depth);
    return true;
}  // end ProtoXml::IterFilterBase::UpdateCurrentPath()

bool ProtoXml::IterFilterBase::IsMatch()
{
    // Does "path_current" match any of our path filters
    if (!path_filter.IsSet())
        return true;
    else if (0 == strcmp(path_filter.GetPath(), path_current))
        return true;
    else if (NULL != path_filter_list.FindString(path_current))
        return true;
    else
        return false;
}  // end ProtoXml::IterFilterBase::IsMatch()

ProtoXml::IterParser::IterParser(const char* filterPath)
 : IterFilterBase(filterPath), reader_ptr(NULL), prev_node(NULL)
{
}

ProtoXml::IterParser::~IterParser()
{
    Close();
}

bool ProtoXml::IterParser::Open(const char* fileName, const char* filterPath)
{
    Close();  // just in case already open
    if (NULL == (reader_ptr = xmlNewTextReaderFilename(fileName)))
    {
        PLOG(PL_ERROR, "ProtoXml::IterParser::Open() xmlNewTextReaderFilename() error: %s\n",
                       GetErrorString());
        return false;
    }
    if (NULL != filterPath)
        IterFilterBase::SetFilter(filterPath);
    return true;
}  // end ProtoXml::IterParser::Open()

void ProtoXml::IterParser::Close()
{
    if (NULL != reader_ptr)
    {
        xmlFreeTextReader(reader_ptr);
        reader_ptr = NULL;
        prev_node = NULL;
        IterFilterBase::Reset();
    }
}  // end ProtoXml::IterParser::Close()

xmlNodePtr ProtoXml::IterParser::GetNext()
{
    //TRACE("enter ProtoXml::IterParser::GetNext() prev_node:%s\n", prev_node ? (const char*)prev_node->name : "(null)");
    int result;
    // If we didn't just return a "prev_node", then read the
    // very next sequential node w/ xmlTextReaderRead(), else 
    // skip entire "prev_node" sub-tree w/ xmlTextReaderNext()
    if (NULL == prev_node)
        result = xmlTextReaderRead(reader_ptr);
    else
        result = xmlTextReaderNext(reader_ptr);
    prev_node = NULL;
    switch (result)
    {
       case 0:
            return NULL;
       case -1:
            PLOG(PL_ERROR, "ProtoXml::IterParser::GetNext() xmlTextReaderRead error!\n");
            return NULL;
        default:
            break;
    }
    do
    {
        int nodeType = xmlTextReaderNodeType(reader_ptr);
        if (XML_READER_TYPE_ELEMENT != nodeType)
            continue;
        const char* nodeName = (const char*)xmlTextReaderConstLocalName(reader_ptr);
        if (NULL == nodeName)
        {
            PLOG(PL_ERROR, "ProtoXml::IterParser::GetNext() xmlTextReaderConstLocalName() error\n");
            return NULL;
        }
        int nodeDepth =  xmlTextReaderDepth(reader_ptr);
        if (nodeDepth < 0)
        {
            PLOG(PL_ERROR, "ProtoXml::IterParser::GetNext() xmlTextReaderDepth() error\n");
            return NULL;
        }
        
        if (!IterFilterBase::UpdateCurrentPath(nodeDepth, nodeName))
        {
            PLOG(PL_WARN, "ProtoXml::IterParser::GetNext() error: unable to update current path\n");
            continue;
        }
        if (!IterFilterBase::IsMatch())
            continue;  // no match, so continue
        prev_node = xmlTextReaderExpand(reader_ptr);
        if (NULL == prev_node)
            PLOG(PL_ERROR, "ProtoXml::IterParser::GetNext() xmlTextReaderExpand() error!\n");
        return prev_node;    
           
    } while ((result = xmlTextReaderRead(reader_ptr)) > 0);
    if (result < 0)
        PLOG(PL_ERROR, "ProtoXml::IterParser::GetNext() xmlTextReaderRead() error!\n");
    return NULL;
}  // end ProtoXml::IterParser::GetNext()


ProtoXml::IterFinder::IterFinder(xmlNodePtr rootElem, const char* filterPath)
 : IterFilterBase(filterPath), root_elem(rootElem), prev_elem(rootElem), iter_depth(0)
{
}

ProtoXml::IterFinder::~IterFinder()
{
}

void ProtoXml::IterFinder::Reset(const char* filterPath)
{
    prev_elem = root_elem;
    if (NULL != filterPath)
        SetFilter(filterPath);
    IterFilterBase::Reset();
}  // end ProtoXml::IterFinder::Reset()

// Depth-first traversal of sub-tree (below root_elem)
xmlNodePtr ProtoXml::IterFinder::GetNext()
{
    //TRACE("enter ProtoXml::IterFinder::GetNext() prev_elem:%s\n", prev_elem ? (const char*)prev_elem->name : "(null)");
    if(NULL == prev_elem)
    {
        return NULL;
    }
    else if (prev_elem != root_elem)
    {
        // We need to skip the subtree of the prev_elem
        // This involves moving right or up and right
        xmlNodePtr nextElem = prev_elem->next;
        while (NULL == nextElem)
        {
            prev_elem = prev_elem->parent; // move up
            iter_depth--;
            if (prev_elem != root_elem)
                nextElem = prev_elem->next; // move right
            else
                break; // we're done (returned to root_elem)
        }
        prev_elem = nextElem;
        // Check for match before descending
        if (NULL != nextElem)
        {
            if (!UpdateCurrentPath(iter_depth, (const char*)nextElem->name))
                PLOG(PL_WARN, "ProtoXml::IterFinder::GetNext() error: unable to update current path\n");
            else if (IsMatch()) 
                return nextElem; // found match, done for now
        }
    }    
    // Descend down or across tree
    while (NULL != prev_elem) 
    {
        // First, try to move down or the right of the tree
        xmlNodePtr nextElem = prev_elem->xmlChildrenNode;
        if (NULL == nextElem)
        {
            if (prev_elem != root_elem)
            {
                nextElem = prev_elem->next;  // no children, try next sibling
            }
            else
            {
                prev_elem = NULL; // done, root_elem had no children
                return NULL;
            }
        }
        else if (prev_elem != root_elem)
        {
            iter_depth++;
        }
        // Second, if needed, move back up the tree and to the right
        while (NULL == nextElem)
        {
            // No child or sibling, so move up a level 
            // and right to parent's next sibling
            prev_elem = prev_elem->parent;   // move up
            iter_depth--;
            if (prev_elem != root_elem)
                nextElem = prev_elem->next;  // move right
            else 
                break; // we're done (returned to root_elem)
        }
        prev_elem = nextElem;
        if (NULL != nextElem)
        {
            if (!UpdateCurrentPath(iter_depth, (const char*)nextElem->name))
            {
                
                PLOG(PL_WARN, "ProtoXml::IterFinder::GetNext() error: unable to update current path\n");
                continue;
            }
            if (IsMatch()) break; // found match, done for now
        }
    } 
    return prev_elem;
}  // end ProtoXml::IterFinder::GetNext()