BESXMLUtils.cc

// BESXMLUtils.cc
 
// This file is part of bes, A C++ back-end server implementation framework
// for the OPeNDAP Data Access Protocol.
 
// Copyright (c) 2004-2009 University Corporation for Atmospheric Research
// Author: Patrick West <pwest@ucar.edu> and Jose Garcia <jgarcia@ucar.edu>
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// 
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
// 
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
//
// You can contact University Corporation for Atmospheric Research at
// 3080 Center Green Drive, Boulder, CO 80301
 
// (c) COPYRIGHT University Corporation for Atmospheric Research 2004-2005
// Please read the full copyright statement in the file COPYRIGHT_UCAR.
//
// Authors:
//      pwest       Patrick West <pwest@ucar.edu>
//      jgarcia     Jose Garcia <jgarcia@ucar.edu>
 
#include "BESXMLUtils.h"
#include "BESUtil.h"
#include "BESDebug.h"
 
using std::vector;
using std::string;
using std::map;
 
#define MODULE "xmlutils"
#define prolog string("BESXMLUtils::").append(__func__).append("() - ")

void BESXMLUtils::XMLErrorFunc(void *context, const char *msg, ...)
{
    va_list args;
    va_start( args, msg );
    char mymsg[1024];
    vsnprintf(mymsg, sizeof mymsg, msg, args);
    va_end(args); // Added jhrg 9/17/15
    vector<string> *myerrors = (vector<string> *) context;
    myerrors->push_back(mymsg);
}

void BESXMLUtils::GetProps(xmlNode *node, map<string, string> &props)
{
    if (!node) {
        return;
    }
 
    if (node->properties == nullptr) {
        return;
    }
 
    xmlAttr *curr_prop = node->properties;
    while (curr_prop) {
        string prop_name = (char *) curr_prop->name;
        BESUtil::removeLeadingAndTrailingBlanks(prop_name);
        string prop_val;
        xmlNode *curr_val = curr_prop->children;
        if (curr_val && curr_val->content) {
            prop_val = BESUtil::xml2id((char *) curr_val->content);
            BESUtil::removeLeadingAndTrailingBlanks(prop_val);
        }
        props[prop_name] = prop_val;
 
        curr_prop = curr_prop->next;
    }
}

void BESXMLUtils::GetNodeInfo(xmlNode *node, string &name, string &value, map<string, string> &props)
{
    if (node) {
        name = (char *) node->name;
        BESUtil::removeLeadingAndTrailingBlanks(name);
        BESXMLUtils::GetProps(node, props);
        xmlNode *child_node = node->children;
        bool done = false;
        while (child_node && !done) {
            if (child_node->type == XML_TEXT_NODE) {
                if (child_node->content) {
                    BESDEBUG(MODULE, prolog << "child_node->content: " << child_node->content << std::endl);
                    value = BESUtil::xml2id((char *)child_node->content);
                    BESUtil::removeLeadingAndTrailingBlanks(value);
                    BESDEBUG(MODULE, prolog << "value: " << value << std::endl);
                }
                else {
                    value = "";
                }
                done = true;
            }
            child_node = child_node->next;
        }
    }
}

xmlNode *
BESXMLUtils::GetFirstChild(xmlNode *node, string &child_name, string &child_value, map<string, string> &child_props)
{
    xmlNode *child_node = nullptr;
    if (node) {
        child_node = node->children;
        bool done = false;
        while (child_node && !done) {
            if (child_node->type == XML_ELEMENT_NODE) {
                done = true;
                BESXMLUtils::GetNodeInfo(child_node, child_name, child_value, child_props);
            }
            else {
                child_node = child_node->next;
            }
        }
    }
    return child_node;
}

xmlNode *
BESXMLUtils::GetNextChild(xmlNode *child_node, string &next_name, string &next_value, map<string, string> &next_props)
{
    if (child_node) {
        child_node = child_node->next;
        bool done = false;
        while (child_node && !done) {
            if (child_node->type == XML_ELEMENT_NODE) {
                done = true;
                BESXMLUtils::GetNodeInfo(child_node, next_name, next_value, next_props);
            }
            else {
                child_node = child_node->next;
            }
        }
    }
    return child_node;
}

xmlNode *
BESXMLUtils::GetChild(xmlNode *node, const string &child_name, string &child_value, map<string, string> &child_props)
{
    xmlNode *child_node = nullptr;
    if (node) {
        child_node = node->children;
        bool done = false;
        while (child_node && !done) {
            if (child_node->type == XML_ELEMENT_NODE) {
                string name = (char *) child_node->name;
                BESUtil::removeLeadingAndTrailingBlanks(name);
                if (name == child_name) {
                    done = true;
                    BESXMLUtils::GetNodeInfo(child_node, name, child_value, child_props);
                }
                else {
                    child_node = child_node->next;
                }
            }
            else {
                child_node = child_node->next;
            }
        }
    }
    return child_node;
}