Recent changes to patches

Minor default initialization to keep linting tools happy.

2021-05-10T18:24:22.640000Z

659a660,661

        , m_name_size(0)
        , m_value_size(0)
810a813
: m_prev_attribute(0), m_next_attribute(0)
903a907
, m_last_node(0)
904a909,911
, m_last_attribute(0)
, m_prev_sibling(0)
, m_next_sibling(0)

#5 Feature to strip XML namespaces from tags

2016-10-11T22:07:25.351000Z

What patch format is this? I can't manage to apply it!

Here is another go on the problem: https://github.com/dwd/rapidxml/blob/master/rapidxml.hpp

#6 GCC 4.7.2 compiler warnings

2015-08-12T16:29:53.984000Z

I ran into this as well, and found a similar fix here: http://stackoverflow.com/questions/14113923/rapidxml-print-header-has-undefined-methods

Additionally, there's still a warning because flags parameter is unused in print_attributes. This is easily fixed with something like this:
http://stackoverflow.com/questions/7090998/portable-unused-parameter-macro-used-on-function-signature-for-c-and-c

rapidxml_iterators.hpp improvements

2015-06-19T18:13:46.996000Z

Constructors take an optional "name", which lets you iterate through nodes/attributes of a given name only.
Ch defaults to char, just like the rest of the templates.
Fixed compile error on GCC due to superfluous use of typename.

wchar_t filename support

2014-02-28T19:30:44.023000Z

I wanted support for wchar_t for rapidxml::file filenames but the pre-existing patch didn't do it for me so I wrote another one. This "supports" other character types as well although it just strips all high bytes off of the characters.

It's "slower than necessary" for type char but we're erroring so that shouldn't be a problem.

    template <typename Fn>
    file(const Fn *filename)
    {
        using namespace std;

        // Open stream
        basic_ifstream<Ch> stream(filename, ios::binary);
        if (!stream.good())
        {
            // quick and dirty coersion from wchar_t if that's what Fn is.
            const Fn* fnend = filename;
            while (*fnend != 0)
                ++fnend;
            throw runtime_error(string("cannot open file ") + string(filename, fnend));
        }
        stream.unsetf(ios::skipws);

xml_node comparison

2013-10-07T12:40:04.159000Z

I use RapidXml to compare two XML documents, comparing the structure. I wrote a comparison function for xml_node:

namespace rapidxml {
template<typename Ch>
Bool operator==(const xml_node<Ch>& lhs, const xml_node<Ch>& rhs);

template<typename Ch>
Bool operator!=(const xml_node<Ch>& lhs, const xml_node<Ch>& rhs) {
  return !(lhs == rhs);
}

template<typename Ch>
Bool operator==(const xml_node<Ch>& lhs, const xml_node<Ch>& rhs) {
  // Check current nodes are the same
  if ((lhs.type() != rhs.type()) ||
      (0 != std::strncmp(lhs.name(), rhs.name(), lhs.name_size())) ||
      (0 != std::strncmp(lhs.value(), rhs.value(), lhs.value_size()))) {
    return false;
  }

  // Check the node attributes are the same
  const xml_attribute<Ch> * lattr = lhs.first_attribute();
  const xml_attribute<Ch> * rattr = rhs.first_attribute();
  while (lattr || rattr) {
    if (!lattr || !rattr) {
      return false;
    }
    if ((0 != std::strncmp(lattr->name(), rattr->name(), lattr->name_size())) ||
        (0 != std::strncmp(lattr->value(), rattr->value(), lattr->value_size()))) {
      return false;
    }
    lattr = lattr->next_attribute();
    rattr = rattr->next_attribute();
  }

  // Recurse into the children
  const xml_node<Ch> * lchild = lhs.first_node();
  const xml_node<Ch> * rchild = rhs.first_node();
  if (((lchild == NULL) && (rchild != NULL)) ||
      ((lchild != NULL) && (rchild == NULL))) {
    return false;
  } else if ((lchild == NULL) && (rchild == NULL)) {
    return true;
  } else {
    while (lchild) {
      if (*lchild != *rchild) {
        return false;
      }
      lchild = lchild->next_sibling();
      if (lchild == NULL) {
        break;
      }
      if (rchild->next_sibling(lchild->name())) {
        rchild = rchild->next_sibling(lchild->name());
      } else if (rchild->previous_sibling(lchild->name())) {
        rchild = rchild->previous_sibling(lchild->name());
      } else {
        return false;
      }
    }
  }

  return true;
}
}  // namespace rapidxml

It would be great if there was a rapidxml_comparison.hpp that provided the comparison functions. If this is something that the project would like to include I would happily improve this function with doxygen, etc.

GCC 4.7.2 compiler warnings

2012-11-13T08:05:30Z

Templates need to be pre-declared when building on the latest gcc.

Feature to strip XML namespaces from tags

2010-04-05T17:42:08Z

The attached file patches RapidXML v1.13 with a new optional parsing flag to strip namespaces from element and attribute tags.

To use the feature, pass the flag parse_strip_xml_namespaces when parsing an XML document, eg.

xml_document<> doc;

doc.parse<parse_strip_xml_namespaces>(my_xml_string);

This causes all XML namespaces to be stripped from the resulting DOM, eg. the following XML:

<?xml version="1.0" encoding="ISO-8859-1" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:ns1="http://www.example.org">
<xs:element name="example" type="xs:string"/>
<ns1:example ns1:attr="hello world"/>
</xs:schema>

Would have a stripped representation of:

(Note how the string of the type node in the second line still has the "xs:" prefix applied to it, as it was in actual node content and not part of a tag or attribute name.)

The cost of stripping XML namespaces is fairly small but non-negligible: an additional iteration over every element and attribute tag name, looking for the namespace symbol (a colon, or ":"), plus the increase in code size to do this. The code should be optimized away entirely by the compiler when not using the flag.

The flag is non-destructive; ie. it does not modify the original string, only the XML nodes that are generated from the string.

Short of actual XML namespace support, eliminating the namespaces entirely was the most convenient way I found to drill into XML that had non-trivial or unpredictable namespace usage. A more robust solution may be required (of course) if those namespaces are actually needed to provide context to conflicting tag names.

Text with only whitespace is skipped

2009-10-14T07:35:56Z

When RapidXml parses the following XML (parse flag is 0),
the text of data node is empty.

I tried to modify the code to preserve the whitespace
when parse_trim_whitespace is not set.

Rapid XML 1.12 doesn't handle zero-length strings correctly

2009-03-03T03:20:48Z

Rapid XML 1.12 interprets a zero, when specified as a string's length, as indicating that the string is a C-string & its length should be calculated appropriately.
This makes it difficult to add variable length data where it may have zero length, but isn't necessarily a C-string. This may have also introduced hidden bugs into users code. Zero is a valid length for data & should be interpreted literally.

The attached patch defines a new constant `auto_size` to use instead of `0` and modifies code appropriately. Note: The change was sufficient for my usage. It probably requires some further work to update every occurrence.