XMLHelpers.cc

Go to the documentation of this file.

// This file is part of the "NcML Module" project, a BES module designed
// to allow NcML files to be used to be used as a wrapper to add
// AIS to existing datasets of any format.
//
// Copyright (c) 2009 OPeNDAP, Inc.
// Author: Michael Johnson  <m.johnson@opendap.org>
//
// For more information, please also see the main website: http://opendap.org/
//
// 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
//
// Please see the files COPYING and COPYRIGHT for more information on the GLPL.
//
// You can contact OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112.

#include "XMLHelpers.h"

namespace ncml_module
{


  string
  XMLUtil::xmlCharToString(const xmlChar* theCharsOrNull)
  {
    const char* asChars = reinterpret_cast<const char*>(theCharsOrNull);
    return ( (asChars)?(string(asChars)):(string("")) );
  }

  void
  XMLUtil::xmlCharToString(string& stringToFill, const xmlChar* pChars)
  {
    stringToFill = xmlCharToString(pChars);
  }

 // Interpret the args as the start and stop iterator of chars.
 // But check for empty on it.
  string
  XMLUtil::xmlCharToStringFromIterators(const xmlChar* startIter, const xmlChar* endIter)
  {
    // Just be safe, no use for exceptions.
    if (!startIter || !endIter || (startIter > endIter) )
      {
        return string("");
      }

    // These are interpreted as const char* iterators.
    return string(
        reinterpret_cast<const char*>(startIter),
        reinterpret_cast<const char*>(endIter));
  }


  XMLAttribute::XMLAttribute(const string& localNameA,
      const string& valueA,
      const string& prefixA,
      const string& nsURIA)
  : localname(localNameA)
  , prefix(prefixA)
  , nsURI(nsURIA)
  , value(valueA)
  {
  }

  XMLAttribute::XMLAttribute(const xmlChar** chunkOfFivePointers)
  {
    fromSAX2NamespaceAttributes(chunkOfFivePointers);
  }

  XMLAttribute::XMLAttribute(const XMLAttribute& proto)
  : localname(proto.localname)
  , prefix(proto.prefix)
  , nsURI(proto.nsURI)
  , value(proto.value)
  {
  }

  XMLAttribute&
  XMLAttribute::operator=(const XMLAttribute& rhs)
  {
    if (&rhs == this)
      {
        return *this;
      }
    localname = rhs.localname;
    prefix = rhs.prefix;
    value = rhs.value;
    nsURI = rhs.nsURI;  // jhrg 3/16/11
    return *this;
  }

  void
  XMLAttribute::fromSAX2NamespaceAttributes(const xmlChar** chunkOfFivePointers)
  {
    const xmlChar* xmlLocalName = (*chunkOfFivePointers++);
    const xmlChar* xmlPrefix = (*chunkOfFivePointers++);
    const xmlChar* xmlURI = (*chunkOfFivePointers++);
    const xmlChar* xmlValueStart = (*chunkOfFivePointers++);
    // pointer to end of the value since not null terminated.
    const xmlChar* xmlValueEnd = (*chunkOfFivePointers++);

    // makeString calls map null into "".
    localname = XMLUtil::xmlCharToString(xmlLocalName);
    prefix = XMLUtil::xmlCharToString(xmlPrefix);
    nsURI = XMLUtil::xmlCharToString(xmlURI);
    value = XMLUtil::xmlCharToStringFromIterators(xmlValueStart, xmlValueEnd);
  }

  string
  XMLAttribute::getQName() const
  {
    return getQName(prefix, localname);
  }

  string
  XMLAttribute::getAsXMLString() const
  {
    return getQName() + "=\"" + value + "\"";
  }

  /*static */
  string
  XMLAttribute::getQName(const string& prefix, const string& localname)
  {
    if (prefix.empty())
      {
        return localname;
      }
    else
      {
        return prefix + ":" + localname;
      }
  }

  XMLAttributeMap::XMLAttributeMap()
  : _attributes()
  {
  }

  XMLAttributeMap::~XMLAttributeMap()
  {
  }

  XMLAttributeMap::const_iterator
  XMLAttributeMap::begin() const
  {
     return _attributes.begin();
  }

  XMLAttributeMap::const_iterator
  XMLAttributeMap::end() const
  {
    return _attributes.end();
  }

  bool
  XMLAttributeMap::empty() const
  {
    return _attributes.empty();
  }

  void
  XMLAttributeMap::clear()
  {
    // won't resize, we might be reusing it so no point.
    _attributes.clear();
  }

  void
  XMLAttributeMap::addAttribute(const XMLAttribute& attribute)
  {
    XMLAttributeMap::iterator foundIt = findByQName(attribute.getQName());
    // if in there, replace it.
    if (foundIt != _attributes.end())
      {
        // replace with a copy of new one
        (*foundIt) = XMLAttribute(attribute);
      }

    // otherwise push on a new one
    _attributes.push_back(attribute);
  }

  const string /*& returns a reference to a local temp object (the else clause). jhrg 4/16/14*/
  XMLAttributeMap::getValueForLocalNameOrDefault(const string& localname, const string& defVal/*=""*/) const
  {
    const XMLAttribute* pAttr = getAttributeByLocalName(localname);
    if (pAttr)
      {
        return pAttr->value;
      }
    else
      {
        // Reference to a local temporary object. jhrg 4/16/14
        return defVal;
      }
  }

  const XMLAttribute*
  XMLAttributeMap::getAttributeByLocalName(const string& localname) const
  {
    const XMLAttribute* pAtt = 0; // if not found
    for (XMLAttributeMap::const_iterator it=begin(); it != end(); ++it)
      {
        const XMLAttribute& rAttr = *it;
        if (rAttr.localname == localname)
          {
            pAtt = &rAttr;
            break;
          }
      }
    return pAtt;
  }

  const XMLAttribute*
  XMLAttributeMap::getAttributeByQName(const string& qname) const
  {
    const XMLAttribute* pAtt = 0; // if not found
      for (XMLAttributeMap::const_iterator it=begin(); it != end(); ++it)
        {
          const XMLAttribute& rAttr = *it;
          if (rAttr.getQName() == qname)
            {
              pAtt = &rAttr;
              break;
            }
        }
      return pAtt;
  }

  const XMLAttribute*
  XMLAttributeMap::getAttributeByQName(const string& prefix, const string& localname) const
  {
    return getAttributeByQName( XMLAttribute::getQName(prefix, localname) );
  }

  string
  XMLAttributeMap::getAllAttributesAsString() const
  {
    string result("");
    XMLAttributeMap::const_iterator it;
    for (it = begin(); it != end(); ++it)
      {
        const XMLAttribute& attr = *it;
        result += (attr.getQName() + "=\"" + attr.value + "\" ");
      }
    return result;
  }

  XMLAttributeMap::iterator
  XMLAttributeMap::findByQName(const string& qname)
  {
    XMLAttributeMap::iterator it;
    for (it = _attributes.begin();
         it != _attributes.end();
         ++it)
      {
        if (it->getQName() == qname)
          {
            break;
          }
      }
    return it;
  }


  XMLNamespace::XMLNamespace(const string& prefixArg/*=""*/, const string& uriArg/*=""*/)
  : prefix(prefixArg)
  , uri(uriArg)
  {
  }

  XMLNamespace::XMLNamespace(const XMLNamespace& proto)
  : prefix(proto.prefix)
  , uri(proto.uri)
  {
  }

  XMLNamespace&
  XMLNamespace::operator=(const XMLNamespace& rhs)
  {
    if (this == &rhs)
      {
        return *this;
      }

    prefix = rhs.prefix;
    uri = rhs.uri;
    return *this;
  }

  void
  XMLNamespace::fromSAX2Namespace(const xmlChar** pNamespace)
  {
    prefix = XMLUtil::xmlCharToString(*pNamespace);
    uri = XMLUtil::xmlCharToString(*(pNamespace+1));
  }

  string
  XMLNamespace::getAsAttributeString() const
  {
    string attr("xmlns");
    if (!prefix.empty())
      {
         attr += ( string(":") + prefix );
      }
    attr += string("=\"");
    attr += uri;
    attr += string("\"");
    return attr;
  }


  XMLNamespaceMap::XMLNamespaceMap()
  : _namespaces()
  {
  }

  XMLNamespaceMap::~XMLNamespaceMap()
  {
    _namespaces.clear();
  }

  XMLNamespaceMap::XMLNamespaceMap(const XMLNamespaceMap& proto)
  : _namespaces(proto._namespaces)
  {
  }

  XMLNamespaceMap&
  XMLNamespaceMap::operator=(const XMLNamespaceMap& rhs)
  {
    if (this == &rhs)
      {
        return *this;
      }
    _namespaces = rhs._namespaces;
    return *this;
  }

  void
  XMLNamespaceMap::fromSAX2Namespaces(const xmlChar** pNamespaces, int numNamespaces)
  {
    clear();
    for (int i=0; i<numNamespaces; ++i)
      {
        XMLNamespace ns;
        ns.fromSAX2Namespace(pNamespaces);
        pNamespaces += 2; // this array is stride 2
        addNamespace(ns);
      }
  }

  string
  XMLNamespaceMap::getAllNamespacesAsAttributeString() const
  {
    string allAttrs("");
    for (XMLNamespaceMap::const_iterator it = begin(); it != end(); ++it)
      {
        const XMLNamespace& ns = *it;
        allAttrs += string(" ") + ns.getAsAttributeString();
      }
    return allAttrs;
  }

  XMLNamespaceMap::const_iterator
  XMLNamespaceMap::begin() const
  {
    return _namespaces.begin();
  }

  XMLNamespaceMap::const_iterator
  XMLNamespaceMap::end() const
  {
    return _namespaces.end();
  }

  XMLNamespaceMap::const_iterator
  XMLNamespaceMap::find(const string& prefix) const
  {
    XMLNamespaceMap::const_iterator foundIt;
    for (foundIt = begin(); foundIt != end(); ++foundIt)
      {
        if (foundIt->prefix == prefix)
          {
            break;
          }
      }
    return foundIt;
  }

  bool
  XMLNamespaceMap::isInMap(const string& prefix) const
  {
    return ( find(prefix) != end() );
  }

  void
  XMLNamespaceMap::addNamespace(const XMLNamespace& ns)
  {
    XMLNamespaceMap::iterator foundIt = findNonConst(ns.prefix);
    if (foundIt == _namespaces.end()) // not found, push
      {
        _namespaces.push_back(ns);
      }
    else
      {
        // overwrite
        (*foundIt) = XMLNamespace(ns);
      }
  }

  void
  XMLNamespaceMap::clear()
  {
    _namespaces.clear();
  }

  bool
  XMLNamespaceMap::empty() const
  {
    return _namespaces.empty();
  }


  XMLNamespaceMap::iterator
  XMLNamespaceMap::findNonConst(const string& prefix)
  {
    XMLNamespaceMap::iterator foundIt;
    for (foundIt = _namespaces.begin(); foundIt != _namespaces.end(); ++foundIt)
      {
        if (foundIt->prefix == prefix)
          {
            break;
          }
      }
    return foundIt;
  }


  XMLNamespaceStack::XMLNamespaceStack()
  : _stack()
  {
  }

  XMLNamespaceStack::~XMLNamespaceStack()
  {
    _stack.clear();
    _stack.resize(0);
  }

  XMLNamespaceStack::XMLNamespaceStack(const XMLNamespaceStack& proto)
  : _stack(proto._stack)
  {
  }

  XMLNamespaceStack&
  XMLNamespaceStack::operator=(const XMLNamespaceStack& rhs)
  {
    if (this == &rhs)
      {
        return *this;
      }
    _stack = rhs._stack;
    return *this;
  }

  void
  XMLNamespaceStack::push(const XMLNamespaceMap& nsMap)
  {
    _stack.push_back(nsMap);
  }

  void
  XMLNamespaceStack::pop()
  {
    _stack.pop_back();
  }

  const XMLNamespaceMap&
  XMLNamespaceStack::top() const
  {
    return _stack.back();
  }

  bool
  XMLNamespaceStack::empty() const
  {
    return _stack.empty();
  }

  void
  XMLNamespaceStack::clear()
  {
    _stack.clear();
  }

  XMLNamespaceStack::const_iterator
  XMLNamespaceStack::begin() const
  {
    return _stack.rbegin();
  }

  XMLNamespaceStack::const_iterator
  XMLNamespaceStack::end() const
  {
    return _stack.rend();
  }

  void
  XMLNamespaceStack::getFlattenedNamespacesUsingLexicalScoping(XMLNamespaceMap& nsFlattened) const
  {
    // Scan the stack in top (lexically innermost) to bottom order, adding in
    // the namespaces we don't have a prefix for.
    for (XMLNamespaceStack::const_iterator it = begin(); it != end(); ++it)
      {
        addMissingNamespaces(nsFlattened, *it);
      }
  }

  /* static */
  void
  XMLNamespaceStack::addMissingNamespaces(XMLNamespaceMap& intoMap, const XMLNamespaceMap& fromMap)
  {
    for (XMLNamespaceMap::const_iterator it = fromMap.begin(); it != fromMap.end(); ++it)
      {
        const XMLNamespace& ns = *it;
        // If this namespace is not in the output map, add it
        if (intoMap.find(ns.prefix) == intoMap.end())
          {
            intoMap.addNamespace(ns);
          }
        // otherwise, it's been lexically shadowed, so ignore it.
      }
  }
}; // namespace ncml_module