Showing preview only (374K chars total). Download the full file or copy to clipboard to get everything.
Repository: dwd/rapidxml
Branch: master
Commit: a304c197c706
Files: 27
Total size: 360.9 KB
Directory structure:
gitextract_2ljvjjz2/
├── .github/
│ └── workflows/
│ └── gtest.yml
├── .gitignore
├── README.md
├── conanfile.py
├── include/
│ ├── flxml/
│ │ ├── generator.h
│ │ ├── iterators.h
│ │ ├── predicates.h
│ │ ├── print.h
│ │ ├── tables.h
│ │ ├── utils.h
│ │ └── wrappers.h
│ ├── flxml.h
│ ├── rapidxml.hpp
│ └── rapidxml_print.hpp
├── license.txt
├── manual.html
└── test/
├── CMakeLists.txt
├── conanfile.py
├── sonar-project.properties
└── src/
├── iterators.cpp
├── low-level-parse.cpp
├── main.cc
├── manipulations.cpp
├── parse-simple.cpp
├── perf.cpp
├── round-trips.cpp
└── xpath.cpp
================================================
FILE CONTENTS
================================================
================================================
FILE: .github/workflows/gtest.yml
================================================
name: gtest
on:
- push
- pull_request
- release
jobs:
gtest:
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v4
with:
fetch-depth: 0
- name: Figure out version
id: tag
run: |
TAG=$(git describe --tags --abbrev=0)
COMMITS_SINCE_TAG=$(git rev-list ${TAG}..HEAD --count)
if [ "${COMMITS_SINCE_TAG}" -eq 0 ]; then
echo "VERSION=${TAG}" >> $GITHUB_ENV
else
echo "VERSION="$(git describe --tags --abbrev=8) >> $GITHUB_ENV
fi
- name: Cache Conan2 dependencies
uses: actions/cache@v3
with:
path: ~/.conan2
key: ${{ runner.os }}-conan2-${{ hashFiles('**/conanfile.py') }}
restore-keys: |
${{ runner.os }}-conan2-
- name: Set up Python 3.8 for gcovr
uses: actions/setup-python@v4
- name: SonarQube install
uses: SonarSource/sonarcloud-github-c-cpp@v3
- name: Install Conan
run: pip install conan
- name: Configure Conan Profile
run: |
conan profile detect -e
conan remote add conan-nexus https://nexus.cridland.io/repository/dwd-conan --force
conan remote login conan-nexus ci --password ${{ secrets.NEXUS_PASSWORD }}
- name: Conan Deps
run: conan install . --output-folder=gh-build -s build_type=Debug -s compiler.cppstd=gnu23 -b missing --version=${{ env.VERSION }}
- name: Create package
run: conan create . --version=${{ env.VERSION }}
- name: Conan deps for tests
run: cd test && conan install . --output-folder=. -s build_type=Debug -s compiler.cppstd=gnu23 -b missing --version=${{ env.VERSION }}
- name: CMake tests
run: cd test && cmake -B gh-build -DCMAKE_BUILD_TYPE=Debug
- name: Build Wrapper
run: cd test && build-wrapper-linux-x86-64 --out-dir sonar-out cmake --build gh-build
- name: Sonar Scanner
run: cd test && sonar-scanner --define sonar.cfamily.compile-commands=sonar-out/compile_commands.json
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
- name: Run Tests
run: cd test/gh-build && ./rapidxml-test
- name: Upload
run: conan upload -r conan-nexus --confirm 'flxml/*'
================================================
FILE: .gitignore
================================================
/cmake-build-debug/
/gtest-build/
================================================
FILE: README.md
================================================
# FLXML
## Or -- RapidXML, Dave's Version
Hey! This is a fork of RapidXML, an ancient C++ library for parsing XML quickly and flexibly. To distinguish, this version is called "FLXML", for "Fast/Light XML". Hey, it's a name.
There's a lot of forks of this around, and I (Dave Cridland) didn't write the vast majority of this library - instead, it was written by someone called Marcin Kalicinski, and his copyright is dated 2009.
## Version 2, Breaking Changes
This is version 2.x. You might not want this, since it introduces a number of breaking changes from rapidxml. The rapidxml-like library is available, with breaking changes, by including `rapidxml.hpp` as before, within the `rapidxml` namespace - however this is an alias to the `flxml` namespace defined in `flxml.h`.
It has breaking changes, the largest of which are:
* No more case insensitive option. Really, nobody should be using XML case insensitively anyway, but it was too difficult to keep around, sorry.
* Instead of passing around potentially unterminated character pointers with optional lengths, we now use std::basic_string_view
* There is no need for string termination, now, so the parse function never terminates, and that option has vanished.
* Return values that were previously bare pointers are now a safe wrapped pointer which ordinarily will check/throw for nullptr.
* append/prepend/insert_node now also have an append/prepend/insert_element shorthand, which will allow an XML namespace to be included if wanted.
* Parsing data can be done from a container as well as a NUL-terminated buffer. A NUL-terminated buffer remains slightly faster, and will be used if possible (for example, if you pass ina std::basic_string, it'll call c_str() on it and do that).
Not breaking, but kind of nice:
* The parse buffer is now treated as const, and will never be mutated. This incurs a slight performance penalty for handling long text values that have an encoded entity late in the string.
* The iterators library is now included by default, and updated to m_handle most idiomatic modern C++ operations.
Internal changes:
* There is no longer a internal::measure or internal::compare; these just use the std::char_traits<Ch> functions as used by the string_views.
* Reserialization (that is, using the rapidxml::print family on a tree that is mostly or entirely from parsing) is now much faster, and will optimize itself to use simple buffer copies where the data is unchanged from parsing.
* Alignment of the allocator uses C++11's alignof/std::align, and so should be more portable.
New features:
* Instead of the `doc->allocate_node` / `node->append_node` dance, you can now `node->append_element(name, value)`, where `name` can be either a `string` (or `string_view`, etc) or a tuple like {xmlns, local_name}, which will set an xmlns attribute if needed.
* There's a xpathish thing going on in `flxml/predicates.h`, which lets you search for (or iterate through) elements using a trivial subset of XPath.
* You can get access to containerish things in rapidxml_iterators by methods on nodes/documents, as `node.children()`, `node.attributes()` and a new `node.descendants()`.
### Fun
The rapidxml_iterators library is now included in `flxml.h`, and you can do amusing things like:
```c++
for (auto & child : node.children()) {
if (child.name() == "potato") scream_for(joy);
}
```
More in [test/iterators.cpp](./test/iterators.cpp)
Of course, in this case it might be simpler to:
```c++
auto xpath = flxml::xpath::parse("/potato");
for (auto & child : xp->all(node)) {
scream_for(joy);
}
```
More of that in [test/xpath.cpp](./test/xpath.cpp)
For those of us who lose track of the buffer sometimes, clone_node() now takes an optional second argument of "true" if you want to also clone the strings. Otherwise, nodes will use string_views which reference the original parsed buffer.
### Gotchas
The functions like find_node and name(...) that took a Ch * and optional length now take only a
std::basic_string_view<Ch>. Typical usage passed in 0, NULL, or nullptr for unwanted values; this will now segfault on C++20
and earlier - use C++23 ideally, but you can pass in {} instead. This should probably be a
std::optional<std::basic_string_view<Ch>> instead.
## Changes to the original
I needed a library for fast XMPP processing (reading, processing, and reserializing), and this mostly fit the bill. However, not entirely, so this version adds:
* XML Namespace support
* An additional parse mode flag for doing shallow parsing.
* An additional parse mode flag for extracting just one (child) element.
## Tests
The other thing this fork added was a file of simple tests, which I've recently rewritten into GoogleTest.
The original makes reference to an expansive test suite, but this was not included in the open source release. I'll expand these tests as and when I need to.
The tests use a driver which can optionally use Sentry for performance/error tracking; to enable, use the CMake option RAPIDXML_SENTRY, and clone the [sentry-native](https://github.com/getsentry/sentry-native) repository into the root, and when running `rapidxml-test`, set SENTRY_DSN in the environment.
The tests are in a different Conan package, to keep things light and simple.
## Pull Requests
Pull request are very welcome, but do ensure you're happy with the licensing first.
================================================
FILE: conanfile.py
================================================
from conan import ConanFile
from conan.tools.files import copy
class FLXML(ConanFile):
name = "flxml"
exports_sources = "include/*"
no_copy_source = True
def package(self):
copy(self, "include/*.hpp", self.source_folder, self.package_folder)
copy(self, "include/*.h", self.source_folder, self.package_folder)
def package_info(self):
self.cpp_info.includedirs = ['include']
self.cpp_info.libdirs = []
self.cpp_info.bindirs = []
================================================
FILE: include/flxml/generator.h
================================================
//
// Created by dave on 29/07/2024.
//
#ifndef RAPIDXML_RAPIDXML_GENERATOR_HPP
#define RAPIDXML_RAPIDXML_GENERATOR_HPP
#include <coroutine>
#include <iterator>
namespace flxml {
template<typename T>
class generator {
public:
using value_pointer = std::remove_reference<T>::type *;
struct handle_type;
struct promise_type {
value_pointer value;
std::suspend_always yield_value(T & v) {
value = &v;
return {};
}
std::suspend_never initial_suspend() {
return {};
}
std::suspend_always final_suspend() noexcept {
return {}; // Change this to std::suspend_always
}
void return_void() {}
void unhandled_exception() {
std::terminate();
}
generator get_return_object() {
return generator{handle_type{handle_type::from_promise(*this)}};
}
};
struct handle_type : std::coroutine_handle<promise_type> {
explicit handle_type(std::coroutine_handle<promise_type> && h) : std::coroutine_handle<promise_type>(std::move(h)) {}
T &operator*() {
return *(this->promise().value);
}
void operator++() {
this->resume();
}
bool operator!=(std::default_sentinel_t) const {
return !this->done();
}
};
explicit generator(handle_type h) : m_handle(h) {}
~generator() {
if (m_handle)
m_handle.destroy();
}
handle_type begin() {
return m_handle;
}
std::default_sentinel_t end() {
return std::default_sentinel;
}
private:
handle_type m_handle{};
};
}
#endif //RAPIDXML_RAPIDXML_GENERATOR_HPP
================================================
FILE: include/flxml/iterators.h
================================================
#ifndef RAPIDXML_ITERATORS_HPP_INCLUDED
#define RAPIDXML_ITERATORS_HPP_INCLUDED
// Copyright (C) 2006, 2009 Marcin Kalicinski
// Version 1.13
// Revision $DateTime: 2009/05/13 01:46:17 $
//! \file rapidxml_iterators.hpp This file contains rapidxml iterators
#include <flxml.h>
namespace flxml
{
//! Iterator of child nodes of xml_node
template<typename Ch>
class node_iterator
{
public:
using value_type = xml_node<Ch>;
using reference = xml_node<Ch> &;
using pointer = xml_node<Ch> *;
using iterator_category = std::bidirectional_iterator_tag;
using difference_type = long;
node_iterator()
: m_node()
{
}
explicit node_iterator(xml_node<Ch> const &node)
: m_node(node.first_node())
{
}
node_iterator(node_iterator && other) noexcept : m_node(other.m_node) {}
node_iterator(node_iterator const & other) : m_node(other.m_node) {}
reference operator *() const
{
return const_cast<reference>(*m_node);
}
pointer operator->() const
{
return const_cast<pointer>(m_node.get());
}
node_iterator& operator++()
{
m_node = m_node->next_sibling();
return *this;
}
node_iterator operator++(int)
{
node_iterator tmp = *this;
++(*this);
return tmp;
}
node_iterator& operator--()
{
m_node = m_node->previous_sibling();
return *this;
}
node_iterator operator--(int)
{
node_iterator tmp = *this;
--(*this);
return tmp;
}
bool operator == (const node_iterator<Ch>& rhs) const
{
return m_node == rhs.m_node;
}
bool operator != (const node_iterator<Ch>& rhs) const
{
return m_node != rhs.m_node;
}
node_iterator & operator = (node_iterator && other) noexcept {
m_node = other.m_node;
return *this;
}
node_iterator & operator = (node_iterator const & other) {
m_node = other.m_node;
return *this;
}
bool valid()
{
return m_node.has_value();
}
private:
optional_ptr<xml_node<Ch>> m_node;
};
//! Iterator of child nodes of xml_node
template<typename Ch=char>
class descendant_iterator
{
public:
using value_type = xml_node<Ch>;
using reference = xml_node<Ch> &;
using pointer = xml_node<Ch> *;
using iterator_category = std::bidirectional_iterator_tag;
using difference_type = long;
descendant_iterator()
: m_parent(), m_node()
{
}
explicit descendant_iterator(xml_node<Ch>::ptr node)
: m_parent(node), m_node(node->first_node())
{
}
descendant_iterator(descendant_iterator && other) noexcept : m_parent(other.m_parent), m_node(other.m_node) {}
descendant_iterator(descendant_iterator const & other) : m_parent(other.m_parent), m_node(other.m_node) {}
reference operator *() const
{
return const_cast<reference>(*m_node);
}
pointer operator->() const
{
return const_cast<pointer>(m_node.get());
}
descendant_iterator& operator++()
{
if (m_node->first_node()) {
m_node = m_node->first_node();
} else if (m_node->next_sibling()) {
m_node = m_node->next_sibling();
} else {
// Run out of children, so move upward until we can find a sibling.
while (true) {
m_node = m_node->parent();
if (m_node == m_parent) {
m_node = nullptr;
break;
}
if (m_node->next_sibling()) {
m_node = m_node->next_sibling();
break;
}
}
}
return *this;
}
descendant_iterator operator++(int)
{
node_iterator tmp = *this;
++(*this);
return tmp;
}
descendant_iterator& operator--()
{
if (!m_node->previous_sibling()) {
m_node = m_node->parent();
if (m_node == m_parent) {
m_node = nullptr;
}
} else {
m_node = m_node->previous_sibling();
while (m_node->last_node()) {
m_node = m_node->last_node();
}
}
return *this;
}
descendant_iterator operator--(int)
{
node_iterator tmp = *this;
--(*this);
return tmp;
}
bool operator == (const descendant_iterator<Ch>& rhs) const
{
return m_node == rhs.m_node;
}
bool operator != (const descendant_iterator<Ch>& rhs) const
{
return m_node != rhs.m_node;
}
descendant_iterator & operator = (descendant_iterator && other) noexcept {
m_parent = other.m_parent;
m_node = other.m_node;
return *this;
}
descendant_iterator & operator = (descendant_iterator const & other) {
m_parent = other.m_parent;
m_node = other.m_node;
return *this;
}
bool valid()
{
return m_node.has_value();
}
private:
optional_ptr<xml_node<Ch>> m_parent;
optional_ptr<xml_node<Ch>> m_node;
};
//! Iterator of child attributes of xml_node
template<class Ch>
class attribute_iterator
{
public:
using value_type = xml_attribute<Ch>;
using reference = xml_attribute<Ch> &;
using pointer = xml_attribute<Ch> *;
using iterator_category = std::bidirectional_iterator_tag;
using difference_type = long;
attribute_iterator()
: m_attribute()
{
}
explicit attribute_iterator(xml_node<Ch> const &node)
: m_attribute(node.first_attribute())
{
}
attribute_iterator(attribute_iterator && other) noexcept : m_attribute(other.m_attribute) {}
attribute_iterator(attribute_iterator const & other) : m_attribute(other.m_attribute) {}
reference operator *() const
{
return const_cast<reference>(*m_attribute);
}
pointer operator->() const
{
return const_cast<pointer>(m_attribute.get());
}
attribute_iterator& operator++()
{
m_attribute = m_attribute->next_attribute();
return *this;
}
attribute_iterator operator++(int)
{
attribute_iterator tmp = *this;
++*this;
return tmp;
}
attribute_iterator& operator--()
{
m_attribute = m_attribute->previous_attribute();
return *this;
}
attribute_iterator operator--(int)
{
attribute_iterator tmp = *this;
--*this;
return tmp;
}
bool operator ==(const attribute_iterator<Ch> &rhs) const
{
return m_attribute == rhs.m_attribute;
}
bool operator !=(const attribute_iterator<Ch> &rhs) const
{
return m_attribute != rhs.m_attribute;
}
attribute_iterator & operator = (attribute_iterator && other) noexcept {
m_attribute = other.m_attribute;
return *this;
}
attribute_iterator & operator = (attribute_iterator const & other) {
m_attribute = other.m_attribute;
return *this;
}
private:
optional_ptr<xml_attribute<Ch>> m_attribute;
};
//! Container adaptor for child nodes
template<typename Ch>
class children
{
xml_node<Ch> const & m_node;
public:
explicit children(xml_node<Ch> const & node) : m_node(node) {}
explicit children(optional_ptr<xml_node<Ch>> const ptr) : m_node(ptr.value()) {}
children(children && other) noexcept : m_node(other.m_node) {}
children(children const & other) : m_node(other.m_node) {}
using const_iterator = node_iterator<Ch>;
using iterator = node_iterator<Ch>;
iterator begin() {
return iterator(m_node);
}
iterator end() {
return {};
}
const_iterator begin() const {
return const_iterator(m_node);
}
const_iterator end() const {
return {};
}
};
//! Container adaptor for child nodes
template<typename Ch>
class descendants
{
xml_node<Ch> & m_node;
public:
explicit descendants(xml_node<Ch> & node) : m_node(node) {}
explicit descendants(optional_ptr<xml_node<Ch>> ptr) : m_node(ptr.value()) {}
descendants(descendants && other) noexcept : m_node(other.m_node) {}
descendants(descendants const & other) : m_node(other.m_node) {}
using const_iterator = descendant_iterator<Ch>;
using iterator = descendant_iterator<Ch>;
iterator begin() {
return iterator(&m_node);
}
iterator end() {
return {};
}
const_iterator begin() const {
return const_iterator(&m_node);
}
const_iterator end() const {
return {};
}
};
//! Container adaptor for attributes
template<typename Ch>
class attributes
{
xml_node<Ch> const & m_node;
public:
explicit attributes(xml_node<Ch> const & node) : m_node(node) {}
explicit attributes(optional_ptr<xml_node<Ch>> ptr) : m_node(ptr.value()) {}
using const_iterator = attribute_iterator<Ch>;
using iterator = attribute_iterator<Ch>;
iterator begin() {
return iterator{m_node};
}
iterator end() {
return {};
}
const_iterator begin() const {
return const_iterator{m_node};
}
const_iterator end() const {
return {};
}
};
}
template<typename Ch>
inline constexpr bool std::ranges::enable_borrowed_range<flxml::children<Ch>> = true;
template<typename Ch>
inline constexpr bool std::ranges::enable_borrowed_range<flxml::attributes<Ch>> = true;
#endif
================================================
FILE: include/flxml/predicates.h
================================================
//
// Created by dave on 29/07/2024.
//
#ifndef RAPIDXML_RAPIDXML_PREDICATES_HPP
#define RAPIDXML_RAPIDXML_PREDICATES_HPP
#include <string_view>
#include <list>
#include <flxml/generator.h>
#include <flxml.h>
namespace flxml {
template<typename Ch> class xpath;
namespace internal {
template<typename Ch>
class xpath_base;
template<typename Ch=char>
class name : public flxml::internal::xpath_base<Ch> {
private:
std::basic_string<Ch> m_name;
std::optional<std::basic_string<Ch>> m_xmlns;
public:
explicit name(std::basic_string_view<Ch> n)
: xpath_base<Ch>(), m_name(n) {}
explicit name(std::basic_string<Ch> const & xmlns, std::basic_string_view<Ch> n)
: xpath_base<Ch>(), m_name(n), m_xmlns(xmlns) {}
bool do_match(const xml_node<Ch> & t) override {
if (m_xmlns.has_value() && t.xmlns() != m_xmlns.value()) return false;
return (t.type() == node_type::node_element) && (t.name() == m_name || m_name == "*");
}
};
template<typename Ch=char>
class value : public flxml::internal::xpath_base<Ch> {
private:
std::basic_string<Ch> m_value;
public:
explicit value(std::basic_string_view<Ch> v)
: xpath_base<Ch>(), m_value(v) {}
bool do_match(const xml_node<Ch> & t) override {
return (t.type() == node_type::node_element) && (t.value() == m_value);
}
};
template<typename Ch=char>
class xmlns : public flxml::internal::xpath_base<Ch> {
private:
std::basic_string<Ch> m_xmlns;
public:
explicit xmlns(std::basic_string_view<Ch> v)
: xpath_base<Ch>(), m_xmlns(v) {}
bool do_match(const xml_node<Ch> & t) override {
return (t.type() == node_type::node_element) && (t.xmlns() == m_xmlns);
}
};
template<typename Ch=char>
class attr : public flxml::internal::xpath_base<Ch> {
private:
std::basic_string<Ch> m_name;
std::basic_string<Ch> m_value;
std::optional<std::basic_string<Ch>> m_xmlns;
public:
explicit attr(std::basic_string_view<Ch> n, std::basic_string_view<Ch> v)
: xpath_base<Ch>(), m_name(n), m_value(v) {}
explicit attr(std::basic_string<Ch> const & x, std::basic_string_view<Ch> n, std::basic_string_view<Ch> v)
: xpath_base<Ch>(), m_name(n), m_value(v), m_xmlns(x) {}
bool do_match(const xml_node<Ch> & t) override {
if (t.type() != node_type::node_element) return false;
for (auto const & attr : t.attributes()) {
if (m_xmlns.has_value()) {
if (m_name == "*" || attr.local_name() != m_name) continue;
if (attr.xmlns() != m_xmlns.value()) continue;
} else {
if (m_name == "*" || attr.name() != m_name) continue;
}
return attr.value() == m_value;
}
return false;
}
};
template<typename Ch=char>
class root : public flxml::internal::xpath_base<Ch> {
public:
root() = default;
generator<xml_node<Ch> &> do_gather(xml_node<Ch> & t) override {
for (auto & x : t.children()) {
co_yield x;
}
}
bool do_match(const xml_node<Ch> & t) override {
return t.type() == node_type::node_document || t.type() == node_type::node_element;
}
};
template<typename Ch=char>
class any : public flxml::internal::xpath_base<Ch> {
public:
any() = default;
generator<xml_node<Ch> &> do_gather(xml_node<Ch> & t) override {
co_yield t; // self
for (auto & x : t.descendants()) {
co_yield x;
}
}
bool do_match(const xml_node<Ch> & t) override {
return t.type() == node_type::node_document || t.type() == node_type::node_element;
}
};
template<typename Ch=char>
class xpath_base {
private:
std::list<std::unique_ptr<xpath<Ch>>> m_contexts;
public:
xpath_base() = default;
virtual ~xpath_base() = default;
virtual generator<xml_node<Ch> &> do_gather(xml_node<Ch> & t) {
co_yield t;
}
generator<xml_node<Ch> &> gather(xml_node<Ch> & t) {
for (auto & x : do_gather(t)) {
if (match(x)) co_yield x;
}
}
virtual bool do_match(const xml_node<Ch> & t) = 0;
bool match(xml_node<Ch> & t) {
if (!do_match(t)) {
return false;
}
for(auto & context : m_contexts) {
if (!context->first(t)) {
return false;
}
}
return true;
}
void context(std::unique_ptr<xpath<Ch>> && xp) {
m_contexts.emplace_back(std::move(xp));
}
auto & contexts() const {
return m_contexts;
}
};
std::map<std::string,std::string> xmlns_empty = {};
}
template<typename Ch=char>
class xpath : public internal::xpath_base<Ch> {
private:
std::vector<std::unique_ptr<internal::xpath_base<Ch>>> m_chain;
std::map<std::string,std::string> const & m_xmlns;
public:
bool do_match(const xml_node<Ch> & t) override {
return false;
}
auto const & chain() const {
return m_chain;
}
std::string const & prefix_lookup(std::basic_string_view<Ch> const & prefix) const {
std::basic_string<Ch> p{prefix};
auto it = m_xmlns.find(p);
if (it != m_xmlns.end()) {
return (*it).second;
}
throw std::runtime_error("XPath contains unknown prefix");
}
static void parse_predicate(std::basic_string_view<Ch> const &name, xpath<Ch> &xp, bool inner) {
using xml_doc = xml_document<Ch>;
if (name.starts_with('@')) {
std::basic_string<Ch> text = "<dummy ";
bool star = false;
if (name.starts_with("@*")) {
text += "star ";
text += name.substr(2);
star = true;
} else {
text += name.substr(1);
}
text += "/>";
xml_doc doc;
doc.template parse<parse_fastest>(text);
auto attr = doc.first_node()->first_attribute();
auto colon = attr->name().find(':');
if (colon != xml_attribute<Ch>::view_type::npos) {
auto const & uri = xp.prefix_lookup(attr->name().substr(0, colon));
xp.m_chain.push_back(std::make_unique<internal::attr<Ch>>(uri, attr->local_name(), attr->value()));
} else {
xp.m_chain.push_back(std::make_unique<internal::attr<Ch>>(star ? "*" : attr->name(), attr->value()));
}
} else if (name.starts_with("text()")) {
// text match
std::basic_string<Ch> text = "<dummy text";
text += name.substr(6);
text += "/>";
xml_doc doc;
doc.template parse<parse_fastest>(text);
auto attr = doc.first_node()->first_attribute();
xp.m_chain.push_back(std::make_unique<internal::value<Ch>>(attr->value()));
} else if (name.starts_with("namespace-uri()")) {
// text match
std::basic_string<Ch> text = "<dummy xmlns";
text += name.substr(6);
text += "/>";
xml_doc doc;
doc.template parse<parse_fastest>(text);
auto attr = doc.first_node()->first_attribute();
xp.m_chain.push_back(std::make_unique<internal::xmlns<Ch>>(attr->value()));
} else {
if (xp.m_chain.empty() && inner) {
xp.m_chain.push_back(std::make_unique<internal::root<Ch>>());
}
auto colon = name.find(':');
if (colon != std::basic_string_view<Ch>::npos) {
auto const & uri = xp.prefix_lookup(name.substr(0, colon));
xp.m_chain.push_back(std::make_unique<internal::name<Ch>>(uri, name.substr(colon + 1)));
} else {
xp.m_chain.push_back(std::make_unique<internal::name<Ch>>(name));
}
}
}
static bool parse_inner(std::map<std::string,std::string> & xmlns, std::basic_string_view<Ch> &view, xpath<Ch> &xp, bool first=false, bool inner=false) {
if (view.starts_with("//")) {
xp.m_chain.push_back(std::make_unique<internal::any<Ch>>());
view.remove_prefix(2);
} else if (view.starts_with('/')) {
xp.m_chain.push_back(std::make_unique<internal::root<Ch>>());
view.remove_prefix(1);
} else if (first && !inner) {
xp.m_chain.push_back(std::make_unique<internal::any<Ch>>());
}
for (typename std::basic_string_view<Ch>::size_type i = 0; i != view.size(); ++i) {
switch (view[i]) {
case '/':
case ']':
if (i == 0) throw std::runtime_error("Empty name?");
case '[':
if (i != 0) parse_predicate(view.substr(0, i), xp, inner);
}
switch (view[i]) {
case ']':
view.remove_prefix(i + 1);
if (!inner) throw std::runtime_error("Unexpected ] in input");
return true;
case '[':
view.remove_prefix(i + 1);
xp.m_chain[xp.m_chain.size() - 1]->context(parse_cont(xmlns, view));
return false;
case '/':
view.remove_prefix(i );
return false;
}
}
if (!view.empty()) {
parse_predicate(view, xp, inner);
view.remove_prefix(view.length());
}
return true;
}
static std::unique_ptr<xpath<Ch>> parse_cont(std::map<std::string,std::string> & xmlns, std::basic_string_view<Ch> &view) {
if (view.empty()) throw std::runtime_error("Context expression is empty");
auto xp = std::make_unique<xpath<Ch>>(xmlns);
if (!parse_inner(xmlns, view, *xp, true, true)) {
while (!view.empty()) {
if (parse_inner(xmlns, view, *xp, false, true)) break;
}
}
return xp;
}
static std::unique_ptr<xpath<Ch>> parse(std::map<std::string,std::string> & xmlns, std::basic_string_view<Ch> &view) {
if (view.empty()) throw std::runtime_error("XPath expression is empty");
auto xp = std::make_unique<xpath<Ch>>(xmlns);
if (!parse_inner(xmlns, view, *xp, true, false)) {
while (!view.empty()) {
if (parse_inner(xmlns, view, *xp, false, false)) break;
}
}
return xp;
}
static std::unique_ptr<xpath<Ch>> parse(std::map<std::string,std::string> & xmlns, std::basic_string_view<Ch> const &view) {
std::basic_string_view<Ch> sv(view);
return parse(xmlns, sv);
}
static std::unique_ptr<xpath<Ch>> parse(std::map<std::string,std::string> & xmlns, std::basic_string<Ch> const &view) {
std::basic_string_view<Ch> sv(view);
return parse(xmlns, sv);
}
static std::unique_ptr<xpath<Ch>> parse(std::map<std::string,std::string> & xmlns, const char * view) {
std::basic_string_view<Ch> sv(view);
return parse(xmlns, sv);
}
static std::unique_ptr<xpath<Ch>> parse(std::basic_string_view<Ch> &sv) {
return parse(internal::xmlns_empty, sv);
}
static std::unique_ptr<xpath<Ch>> parse(std::basic_string<Ch> const &view) {
std::basic_string_view<Ch> sv(view);
return parse(internal::xmlns_empty, sv);
}
static std::unique_ptr<xpath<Ch>> parse(std::basic_string_view<Ch> const &view) {
std::basic_string_view<Ch> sv(view);
return parse(internal::xmlns_empty, sv);
}
static std::unique_ptr<xpath<Ch>> parse(const char * view) {
std::basic_string_view<Ch> sv(view);
return parse(internal::xmlns_empty, sv);
}
explicit xpath(std::map<std::string,std::string> & xmlns) : m_xmlns(xmlns) {}
flxml::generator<xml_node<Ch> &> all(xml_node<Ch> & current, unsigned int depth = 0) {
if (depth >= m_chain.size()) throw std::logic_error("Depth exceeded");
auto & xp = m_chain[depth];
depth++;
for (auto & r : xp->gather(current)) {
if (depth >= m_chain.size()) {
co_yield r;
} else {
for (auto & t : all(r, depth)) {
co_yield t;
}
}
}
}
xml_node<Ch>::ptr first(xml_node<Ch> & current) {
for (auto &r: all(current)) {
return &r;
}
return {};
}
};
}
#endif //RAPIDXML_RAPIDXML_PREDICATES_HPP
================================================
FILE: include/flxml/print.h
================================================
#ifndef RAPIDXML_PRINT_HPP_INCLUDED
#define RAPIDXML_PRINT_HPP_INCLUDED
// Copyright (C) 2006, 2009 Marcin Kalicinski
// Version 1.13
// Revision $DateTime: 2009/05/13 01:46:17 $
//! \file rapidxml_print.hpp This file contains rapidxml printer implementation
#include <flxml.h>
// Only include streams if not disabled
#ifndef FLXML_NO_STREAMS
#include <ostream>
#include <iterator>
#endif
namespace flxml
{
///////////////////////////////////////////////////////////////////////
// Printing flags
const int print_no_indenting = 0x1; //!< Printer flag instructing the printer to suppress indenting of XML. See print() function.
///////////////////////////////////////////////////////////////////////
// Internal
//! \cond internal
namespace internal
{
///////////////////////////////////////////////////////////////////////////
// Internal character operations
// Copy characters from given range to given output iterator
template<class OutIt, class Ch>
inline OutIt copy_chars(const Ch *begin, const Ch *end, OutIt out)
{
while (begin != end)
*out++ = *begin++;
return out;
}
template<class OutIt, class Ch>
inline OutIt copy_chars(std::basic_string_view<Ch> const & sv, OutIt out) {
return copy_chars(sv.data(), sv.data() + sv.size(), out);
}
// Copy characters from given range to given output iterator and expand
// characters into references (< > ' " &)
template<class OutIt, class Ch>
inline OutIt copy_and_expand_chars(const Ch *begin, const Ch *end, Ch noexpand, OutIt out)
{
while (begin != end)
{
if (*begin == noexpand)
{
*out++ = *begin; // No expansion, copy character
}
else
{
switch (*begin)
{
case Ch('<'):
*out++ = Ch('&'); *out++ = Ch('l'); *out++ = Ch('t'); *out++ = Ch(';');
break;
case Ch('>'):
*out++ = Ch('&'); *out++ = Ch('g'); *out++ = Ch('t'); *out++ = Ch(';');
break;
case Ch('\''):
*out++ = Ch('&'); *out++ = Ch('a'); *out++ = Ch('p'); *out++ = Ch('o'); *out++ = Ch('s'); *out++ = Ch(';');
break;
case Ch('"'):
*out++ = Ch('&'); *out++ = Ch('q'); *out++ = Ch('u'); *out++ = Ch('o'); *out++ = Ch('t'); *out++ = Ch(';');
break;
case Ch('&'):
*out++ = Ch('&'); *out++ = Ch('a'); *out++ = Ch('m'); *out++ = Ch('p'); *out++ = Ch(';');
break;
default:
*out++ = *begin; // No expansion, copy character
}
}
++begin; // Step to next character
}
return out;
}
template<class OutIt, class Ch>
inline OutIt copy_and_expand_chars(std::basic_string_view<Ch> const & sv, Ch noexpand, OutIt out) {
return copy_and_expand_chars(sv.data(), sv.data() + sv.size(), noexpand, out);
}
// Fill given output iterator with repetitions of the same character
template<class OutIt, class Ch>
inline OutIt fill_chars(OutIt out, int n, Ch ch)
{
for (int i = 0; i < n; ++i)
*out++ = ch;
return out;
}
// Find character
template<class Ch, Ch ch>
inline bool find_char(const Ch *begin, const Ch *end)
{
while (begin != end)
if (*begin++ == ch)
return true;
return false;
}
///////////////////////////////////////////////////////////////////////////
// Internal printing operations
// Print node
template<class OutIt, class Ch>
inline OutIt print_node(OutIt out, const optional_ptr<xml_node<Ch>> node, int flags, int indent);
// Print children of the node
template<class OutIt, class Ch>
inline OutIt print_children(OutIt out, const optional_ptr<xml_node<Ch>> node, int flags, int indent)
{
for (auto child = node->first_node(); child; child = child->next_sibling())
out = print_node(out, child, flags, indent);
return out;
}
// Print attributes of the node
template<class OutIt, class Ch>
inline OutIt print_attributes(OutIt out, const optional_ptr<xml_node<Ch>> node, int)
{
for (auto attribute = node->first_attribute(); attribute; attribute = attribute->next_attribute())
{
if (!(attribute->name().empty()) || attribute->value_raw().empty())
{
// Print attribute name
*out = Ch(' '), ++out;
out = copy_chars(attribute->name(), out);
*out = Ch('='), ++out;
if (attribute->quote() && !attribute->value_decoded()) {
// Shortcut here; just dump out the raw value.
*out++ = attribute->quote();
out = copy_chars(attribute->value_raw(), out);
**out++ = attribute->quote();
} else {
// Print attribute value using appropriate quote type
if (attribute->value().find('"') != std::basic_string_view<Ch>::npos) {
*out = Ch('\''), ++out;
out = copy_and_expand_chars(attribute->value(), Ch('"'), out);
*out = Ch('\''), ++out;
} else {
*out = Ch('"'), ++out;
out = copy_and_expand_chars(attribute->value(), Ch('\''), out);
*out = Ch('"'), ++out;
}
}
}
}
return out;
}
// Print data node
template<class OutIt, class Ch>
inline OutIt print_data_node(OutIt out, const optional_ptr<xml_node<Ch>> node, int flags, int indent)
{
assert(node->type() == node_type::node_data);
if (!(flags & print_no_indenting))
out = fill_chars(out, indent, Ch('\t'));
if (!node->value_decoded()) {
out = copy_chars(node->value_raw(), out);
} else {
out = copy_and_expand_chars(node->value(), Ch(0), out);
}
return out;
}
// Print data node
template<class OutIt, class Ch>
inline OutIt print_cdata_node(OutIt out, const optional_ptr<xml_node<Ch>> node, int flags, int indent)
{
assert(node->type() == node_type::node_cdata);
if (!(flags & print_no_indenting))
out = fill_chars(out, indent, Ch('\t'));
*out = Ch('<'); ++out;
*out = Ch('!'); ++out;
*out = Ch('['); ++out;
*out = Ch('C'); ++out;
*out = Ch('D'); ++out;
*out = Ch('A'); ++out;
*out = Ch('T'); ++out;
*out = Ch('A'); ++out;
*out = Ch('['); ++out;
out = copy_chars(node->value(), out);
*out = Ch(']'); ++out;
*out = Ch(']'); ++out;
*out = Ch('>'); ++out;
return out;
}
// Print element node
template<class OutIt, class Ch>
inline OutIt print_element_node(OutIt out, const optional_ptr<xml_node<Ch>> node, int flags, int indent)
{
assert(node->type() == node_type::node_element);
// Print element name and attributes, if any
if (!(flags & print_no_indenting))
out = fill_chars(out, indent, Ch('\t'));
*out = Ch('<'), ++out;
if (!node->prefix().empty()) {
out = copy_chars(node->prefix(), out);
*out = Ch(':'); ++out;
}
out = copy_chars(node->name(), out);
out = print_attributes(out, node, flags);
// If node is childless
if (node->value().empty() && !node->first_node())
{
// Print childless node tag ending
*out = Ch('/'), ++out;
*out = Ch('>'), ++out;
}
else
{
// Print normal node tag ending
*out = Ch('>'), ++out;
// If the node is clean, just output the contents and move on.
// Can only do this if we're not indenting, otherwise pretty-print won't work.
if (node->clean() && (flags & print_no_indenting)) {
out = copy_chars(node->contents(), out);
} else {
// Test if node contains a single data node only (and no other nodes)
auto child = node->first_node();
if (!child) {
// If node has no children, only print its value without indenting
if (!node->value_decoded()) {
out = copy_chars(node->value_raw(), out);
} else {
out = copy_and_expand_chars(node->value(), Ch(0), out);
}
} else if (!child->next_sibling() && child->type() == node_type::node_data) {
// If node has a sole data child, only print its value without indenting
if (!child->value_decoded()) {
out = copy_chars(child->value_raw(), out);
} else {
out = copy_and_expand_chars(child->value(), Ch(0), out);
}
} else {
// Print all children with full indenting
if (!(flags & print_no_indenting))
*out = Ch('\n'), ++out;
out = print_children(out, node, flags, indent + 1);
if (!(flags & print_no_indenting))
out = fill_chars(out, indent, Ch('\t'));
}
}
// Print node end
*out = Ch('<'), ++out;
*out = Ch('/'), ++out;
if (!node->prefix().empty()) {
out = copy_chars(node->prefix(), out);
*out = Ch(':'); ++out;
}
out = copy_chars(node->name(), out);
*out = Ch('>'), ++out;
}
return out;
}
// Print declaration node
template<class OutIt, class Ch>
inline OutIt print_declaration_node(OutIt out, const optional_ptr<xml_node<Ch>> node, int flags, int indent)
{
// Print declaration start
if (!(flags & print_no_indenting))
out = fill_chars(out, indent, Ch('\t'));
*out = Ch('<'), ++out;
*out = Ch('?'), ++out;
*out = Ch('x'), ++out;
*out = Ch('m'), ++out;
*out = Ch('l'), ++out;
// Print attributes
out = print_attributes(out, node, flags);
// Print declaration end
*out = Ch('?'), ++out;
*out = Ch('>'), ++out;
return out;
}
// Print comment node
template<class OutIt, class Ch>
inline OutIt print_comment_node(OutIt out, const optional_ptr<xml_node<Ch>> node, int flags, int indent)
{
assert(node->type() == node_type::node_comment);
if (!(flags & print_no_indenting))
out = fill_chars(out, indent, Ch('\t'));
*out = Ch('<'), ++out;
*out = Ch('!'), ++out;
*out = Ch('-'), ++out;
*out = Ch('-'), ++out;
out = copy_chars(node->value(), out);
*out = Ch('-'), ++out;
*out = Ch('-'), ++out;
*out = Ch('>'), ++out;
return out;
}
// Print doctype node
template<class OutIt, class Ch>
inline OutIt print_doctype_node(OutIt out, const optional_ptr<xml_node<Ch>> node, int flags, int indent)
{
assert(node->type() == node_type::node_doctype);
if (!(flags & print_no_indenting))
out = fill_chars(out, indent, Ch('\t'));
*out = Ch('<'), ++out;
*out = Ch('!'), ++out;
*out = Ch('D'), ++out;
*out = Ch('O'), ++out;
*out = Ch('C'), ++out;
*out = Ch('T'), ++out;
*out = Ch('Y'), ++out;
*out = Ch('P'), ++out;
*out = Ch('E'), ++out;
*out = Ch(' '), ++out;
out = copy_chars(node->value(), out);
*out = Ch('>'), ++out;
return out;
}
// Print pi node
template<class OutIt, class Ch>
inline OutIt print_pi_node(OutIt out, const optional_ptr<xml_node<Ch>> node, int flags, int indent)
{
assert(node->type() == node_type::node_pi);
if (!(flags & print_no_indenting))
out = fill_chars(out, indent, Ch('\t'));
*out = Ch('<'), ++out;
*out = Ch('?'), ++out;
out = copy_chars(node->name(), out);
*out = Ch(' '), ++out;
out = copy_chars(node->value(), out);
*out = Ch('?'), ++out;
*out = Ch('>'), ++out;
return out;
}
// Print literal node
template<class OutIt, class Ch>
inline OutIt print_literal_node(OutIt out, const optional_ptr<xml_node<Ch>> node, int flags, int indent)
{
assert(node->type() == node_type::node_literal);
if (!(flags & print_no_indenting))
out = fill_chars(out, indent, Ch('\t'));
out = copy_chars(node->value(), out);
return out;
}
// Print node
// Print node
template<class OutIt, class Ch>
inline OutIt print_node(OutIt out, const optional_ptr<xml_node<Ch>> node, int flags, int indent)
{
// Print proper node type
switch (node->type())
{
// Document
case node_document:
out = print_children(out, node, flags, indent);
break;
// Element
case node_element:
out = print_element_node(out, node, flags, indent);
break;
// Data
case node_data:
out = print_data_node(out, node, flags, indent);
break;
// CDATA
case node_cdata:
out = print_cdata_node(out, node, flags, indent);
break;
// Declaration
case node_declaration:
out = print_declaration_node(out, node, flags, indent);
break;
// Comment
case node_comment:
out = print_comment_node(out, node, flags, indent);
break;
// Doctype
case node_doctype:
out = print_doctype_node(out, node, flags, indent);
break;
// Pi
case node_pi:
out = print_pi_node(out, node, flags, indent);
break;
case node_literal:
out = print_literal_node(out, node, flags, indent);
break;
// Unknown
default:
assert(0);
break;
}
// If indenting not disabled, add line break after node
if (!(flags & print_no_indenting))
*out = Ch('\n'), ++out;
// Return modified iterator
return out;
}
}
//! \endcond
///////////////////////////////////////////////////////////////////////////
// Printing
//! Prints XML to given output iterator.
//! \param out Output iterator to print to.
//! \param node Node to be printed. Pass xml_document to print entire document.
//! \param flags Flags controlling how XML is printed.
//! \return Output iterator pointing to position immediately after last character of printed text.
template<class OutIt, class Ch>
inline OutIt print(OutIt out, const xml_node<Ch> &node, int flags = 0)
{
flxml::optional_ptr ptr(const_cast<xml_node<Ch> *>(&node));
return internal::print_node(out, ptr, flags, 0);
}
#ifndef RAPIDXML_NO_STREAMS
//! Prints XML to given output stream.
//! \param out Output stream to print to.
//! \param node Node to be printed. Pass xml_document to print entire document.
//! \param flags Flags controlling how XML is printed.
//! \return Output stream.
template<class Ch>
inline std::basic_ostream<Ch> &print(std::basic_ostream<Ch> &out, const xml_node<Ch> &node, int flags = 0)
{
print(std::ostream_iterator<Ch>(out), node, flags);
return out;
}
//! Prints formatted XML to given output stream. Uses default printing flags. Use print() function to customize printing process.
//! \param out Output stream to print to.
//! \param node Node to be printed.
//! \return Output stream.
template<class Ch>
inline std::basic_ostream<Ch> &operator <<(std::basic_ostream<Ch> &out, const xml_node<Ch> &node)
{
return print(out, node);
}
#endif
}
#endif
================================================
FILE: include/flxml/tables.h
================================================
//
// Created by dwd on 9/7/24.
//
#ifndef RAPIDXML_RAPIDXML_TABLES_HPP
#define RAPIDXML_RAPIDXML_TABLES_HPP
#include <vector>
#include <array>
///////////////////////////////////////////////////////////////////////
// Internals
//! \cond internal
namespace flxml::internal {
// Struct that contains lookup tables for the parser
struct lookup_tables {
// Whitespace (space \n \r \t)
static inline const std::vector<bool> lookup_whitespace =
{
// 0 1 2 3 4 5 6 7 8 9 A B C D E F
false, false, false, false, false, false, false, false, false, true , true , false, false, true , false, false, // 0
false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, // 1
true , false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, // 2
false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, // 3
false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, // 4
false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, // 5
false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, // 6
false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, // 7
false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, // 8
false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, // 9
false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, // A
false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, // B
false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, // C
false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, // D
false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, // E
false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false // F
};
// Element name (anything but space \n \r \t / > ? \0 and :)
static inline const std::vector<bool> lookup_element_name =
{
// 0 1 2 3 4 5 6 7 8 9 A B C D E F
false, true , true , true , true , true , true , true , true , false, false, true , true , false, true , true , // 0
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 1
false, true , true , true , true , true , true , true , true , true , true , true , true , true , true , false, // 2
true , true , true , true , true , true , true , true , true , true , false, true , true , true , false, false, // 3
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 4
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 5
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 6
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 7
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 8
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 9
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // A
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // B
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // C
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // D
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // E
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , 1 // F
};
// Node name (anything but space \n \r \t / > ? \0)
static inline const std::vector<bool> lookup_node_name =
{
// 0 1 2 3 4 5 6 7 8 9 A B C D E F
false, true , true , true , true , true , true , true , true , false, false, true , true , false, true , true , // 0
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 1
false, true , true , true , true , true , true , true , true , true , true , true , true , true , true , false, // 2
true , true , true , true , true , true , true , true , true , true , true , true , true , true , false, false, // 3
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 4
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 5
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 6
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 7
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 8
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 9
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // A
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // B
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // C
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // D
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // E
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , 1 // F
};
// Text (i.e. PCDATA) (anything but < \0)
static inline const std::vector<bool> lookup_text =
{
// 0 1 2 3 4 5 6 7 8 9 A B C D E F
false, true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 0
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 1
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 2
true , true , true , true , true , true , true , true , true , true , true , true , false, true , true , true , // 3
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 4
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 5
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 6
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 7
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 8
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 9
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // A
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // B
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // C
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // D
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // E
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , 1 // F
};
// Text (i.e. PCDATA) that does not require processing when ws normalization is disabled
// (anything but < \0 &)
static inline const std::vector<bool> lookup_text_pure_no_ws =
{
// 0 1 2 3 4 5 6 7 8 9 A B C D E F
false, true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 0
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 1
true , true , true , true , true , true , false, true , true , true , true , true , true , true , true , true , // 2
true , true , true , true , true , true , true , true , true , true , true , true , false, true , true , true , // 3
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 4
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 5
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 6
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 7
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 8
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 9
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // A
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // B
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // C
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // D
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // E
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , 1 // F
};
// Text (i.e. PCDATA) that does not require processing when ws normalizationis is enabled
// (anything but < \0 & space \n \r \t)
static inline const std::vector<bool> lookup_text_pure_with_ws =
{
// 0 1 2 3 4 5 6 7 8 9 A B C D E F
false, true , true , true , true , true , true , true , true , false, false, true , true , false, true , true , // 0
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 1
false, true , true , true , true , true , false, true , true , true , true , true , true , true , true , true , // 2
true , true , true , true , true , true , true , true , true , true , true , true , false, true , true , true , // 3
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 4
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 5
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 6
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 7
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 8
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 9
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // A
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // B
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // C
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // D
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // E
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , 1 // F
};
// Attribute name (anything but space \n \r \t / < > = ? ! \0)
static inline const std::vector<bool> lookup_attribute_name =
{
// 0 1 2 3 4 5 6 7 8 9 A B C D E F
false, true , true , true , true , true , true , true , true , false, false, true , true , false, true , true , // 0
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 1
false, false, true , true , true , true , true , true , true , true , true , true , true , true , true , false, // 2
true , true , true , true , true , true , true , true , true , true , true , true , false, false, false, false, // 3
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 4
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 5
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 6
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 7
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 8
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 9
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // A
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // B
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // C
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // D
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // E
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , 1 // F
};
// Attribute data with single quote (anything but ' \0)
static inline const std::vector<bool> lookup_attribute_data_1 =
{
// 0 1 2 3 4 5 6 7 8 9 A B C D E F
false, true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 0
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 1
true , true , true , true , true , true , true , false, true , true , true , true , true , true , true , true , // 2
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 3
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 4
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 5
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 6
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 7
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 8
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 9
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // A
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // B
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // C
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // D
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // E
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , 1 // F
};
// Attribute data with single quote that does not require processing (anything but ' \0 &)
static inline const std::vector<bool> lookup_attribute_data_1_pure =
{
// 0 1 2 3 4 5 6 7 8 9 A B C D E F
false, true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 0
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 1
true , true , true , true , true , true , false, false, true , true , true , true , true , true , true , true , // 2
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 3
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 4
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 5
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 6
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 7
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 8
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 9
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // A
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // B
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // C
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // D
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // E
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , 1 // F
};
// Attribute data with double quote (anything but " \0)
static inline const std::vector<bool> lookup_attribute_data_2 =
{
// 0 1 2 3 4 5 6 7 8 9 A B C D E F
false, true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 0
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 1
true , true , false, true , true , true , true , true , true , true , true , true , true , true , true , true , // 2
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 3
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 4
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 5
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 6
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 7
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 8
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 9
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // A
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // B
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // C
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // D
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // E
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , 1 // F
};
// Attribute data with double quote that does not require processing (anything but " \0 &)
static inline const std::vector<bool> lookup_attribute_data_2_pure =
{
// 0 1 2 3 4 5 6 7 8 9 A B C D E F
false, true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 0
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 1
true , true , false, true , true , true , false, true , true , true , true , true , true , true , true , true , // 2
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 3
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 4
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 5
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 6
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 7
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 8
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // 9
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // A
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // B
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // C
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // D
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , // E
true , true , true , true , true , true , true , true , true , true , true , true , true , true , true , true // F
};
// Digits (dec and hex, 255 denotes end of numeric character reference)
static inline const std::array<unsigned char, 256> lookup_digits =
{
// 0 1 2 3 4 5 6 7 8 9 A B C D E F
255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // 0
255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // 1
255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // 2
0, 1, 2, 3, 4, 5, 6, 7, 8, 9,255,255,255,255,255,255, // 3
255, 10, 11, 12, 13, 14, 15,255,255,255,255,255,255,255,255,255, // 4
255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // 5
255, 10, 11, 12, 13, 14, 15,255,255,255,255,255,255,255,255,255, // 6
255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // 7
255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // 8
255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // 9
255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // A
255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // B
255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // C
255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // D
255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // E
255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255 // F
};
};
}
//! \endcond
#endif //RAPIDXML_RAPIDXML_TABLES_HPP
================================================
FILE: include/flxml/utils.h
================================================
#ifndef RAPIDXML_UTILS_HPP_INCLUDED
#define RAPIDXML_UTILS_HPP_INCLUDED
// Copyright (C) 2006, 2009 Marcin Kalicinski
// Version 1.13
// Revision $DateTime: 2009/05/13 01:46:17 $
//! \file rapidxml_utils.hpp This file contains high-level rapidxml utilities that can be useful
//! in certain simple scenarios. They should probably not be used if maximizing performance is the main objective.
#include <flxml.h>
#include <vector>
#include <string>
#include <fstream>
#include <stdexcept>
namespace flxml
{
//! Represents data loaded from a file
template<class Ch = char>
class file
{
public:
//! Loads file into the memory. Data will be automatically destroyed by the destructor.
//! \param filename Filename to load.
file(const char *filename)
{
using namespace std;
// Open stream
basic_ifstream<Ch> stream(filename, ios::binary);
if (!stream)
throw runtime_error(string("cannot open file ") + filename);
stream.unsetf(ios::skipws);
// Determine stream size
stream.seekg(0, ios::end);
size_t size = stream.tellg();
stream.seekg(0);
// Load data and add terminating 0
m_data.resize(size + 1);
stream.read(&m_data.front(), static_cast<streamsize>(size));
m_data[size] = 0;
}
//! Loads file into the memory. Data will be automatically destroyed by the destructor
//! \param stream Stream to load from
file(std::basic_istream<Ch> &stream)
{
using namespace std;
// Load data and add terminating 0
stream.unsetf(ios::skipws);
m_data.assign(istreambuf_iterator<Ch>(stream), istreambuf_iterator<Ch>());
if (stream.fail() || stream.bad())
throw runtime_error("error reading stream");
m_data.push_back(0);
}
//! Gets file data.
//! \return Pointer to data of file.
Ch *data()
{
return &m_data.front();
}
//! Gets file data.
//! \return Pointer to data of file.
const Ch *data() const
{
return &m_data.front();
}
//! Gets file data size.
//! \return Size of file data, in characters.
std::size_t size() const
{
return m_data.size();
}
private:
std::vector<Ch> m_data; // File data
};
//! Counts children of node. Time complexity is O(n).
//! \return Number of children of node
template<class Ch>
inline std::size_t count_children(xml_node<Ch> *node)
{
xml_node<Ch> *child = node->first_node();
std::size_t count = 0;
while (child)
{
++count;
child = child->next_sibling();
}
return count;
}
//! Counts attributes of node. Time complexity is O(n).
//! \return Number of attributes of node
template<class Ch>
inline std::size_t count_attributes(xml_node<Ch> *node)
{
xml_attribute<Ch> *attr = node->first_attribute();
std::size_t count = 0;
while (attr)
{
++count;
attr = attr->next_attribute();
}
return count;
}
}
#endif
================================================
FILE: include/flxml/wrappers.h
================================================
//
// Created by dave on 10/07/2024.
//
#ifndef RAPIDXML_RAPIDXML_WRAPPERS_HPP
#define RAPIDXML_RAPIDXML_WRAPPERS_HPP
#include <type_traits>
#include <numeric>
#include <stdexcept>
namespace flxml {
// Most of rapidxml was written to use a NUL-terminated Ch * for parsing.
// This utility struct wraps a buffer to provide something that
// looks mostly like a pointer, deferencing to NUL when it hits the end.
// It's also a forward_iterator, so it'll work with the rage type constructors for string{_view} etc.
template<typename T>
struct buffer_ptr {
// Iterator magic typedefs
using iterator_category = std::contiguous_iterator_tag;
using difference_type = T::difference_type;
using value_type = T::value_type;
using pointer = T::const_pointer;
using reference = T::const_reference;
using real_it = T::const_iterator;
real_it it;
real_it end_it;
static constexpr value_type end_char = value_type(0);
explicit buffer_ptr(T const & buf) : it(buf.cbegin()), end_it(buf.cend()) {}
buffer_ptr(buffer_ptr const & other) : it(other.it), end_it(other.end_it) {}
buffer_ptr() = default;
buffer_ptr & operator = (buffer_ptr const & other) {
it = other.it;
return *this;
}
reference validated_it(typename T::const_iterator const &it) const {
if (it == end_it) return end_char;
return *it;
}
reference operator[](int i) const {
real_it it2 = it + i;
if (it2 >= end_it) return end_char;
return *it2;
}
pointer operator -> () const {
if (it >= end_it) return &end_char;
return &*it;
}
auto operator <=> (buffer_ptr other) const {
return it <=> other.it;
}
auto operator < (buffer_ptr other) const {
return it < other.it;
}
auto operator > (buffer_ptr other) const {
return it > other.it;
}
auto operator >= (buffer_ptr other) const {
return it >= other.it;
}
auto operator <= (buffer_ptr other) const {
return it <= other.it;
}
buffer_ptr & operator ++() {
++it;
return *this;
}
buffer_ptr operator ++(int) {
auto old = *this;
++it;
return old;
}
buffer_ptr & operator --() {
--it;
return *this;
}
buffer_ptr operator --(int) {
auto old = *this;
--it;
return old;
}
reference operator *() const {
return validated_it(it);
}
bool operator == (buffer_ptr const & other) const {
return it == other.it;
}
auto operator + (difference_type n) const {
buffer_ptr other(*this);
other.it += n;
return other;
}
buffer_ptr & operator += (difference_type i) {
it += i;
return *this;
}
auto operator - (difference_type n) const {
buffer_ptr other(*this);
other.it -= n;
return other;
}
buffer_ptr & operator -= (difference_type i) {
it -= i;
return *this;
}
difference_type operator - (buffer_ptr const & other) const {
return it - other.it;
}
pointer ptr() {
return &*it;
}
};
template<typename T>
static auto operator + (int n, buffer_ptr<T> it) {
it.it += n;
return it;
}
class no_such_node : std::runtime_error {
public:
no_such_node() : std::runtime_error("No such node") {}
};
template<typename T>
class optional_ptr {
T * m_ptr;
void assert_value() const {
if (m_ptr == nullptr) {
throw no_such_node();
}
}
public:
optional_ptr(std::nullptr_t) : m_ptr(nullptr) {}
optional_ptr() : m_ptr(nullptr) {}
optional_ptr(T * ptr) : m_ptr(ptr) {}
bool has_value() const {
return m_ptr != nullptr;
}
T & value() {
assert_value();
return *m_ptr;
}
T * get() {
assert_value();
return m_ptr;
}
T * operator -> () {
return get();
}
T & operator * () {
return value();
}
T * ptr_unsafe() {
return m_ptr;
}
T const & value() const {
assert_value();
return *m_ptr;
}
T const * get() const {
assert_value();
return m_ptr;
}
T const * operator -> () const {
return get();
}
T const & operator * () const {
return value();
}
T const * ptr_unsafe() const {
return m_ptr;
}
bool operator ! () const {
return m_ptr == nullptr;
}
operator bool() const {
return m_ptr != nullptr;
}
bool operator == (T * t) const {
return m_ptr == t;
}
bool operator == (optional_ptr const & t) const {
return m_ptr == t.m_ptr;
}
};
}
#endif //RAPIDXML_RAPIDXML_WRAPPERS_HPP
================================================
FILE: include/flxml.h
================================================
#ifndef RAPIDXML_HPP_INCLUDED
#define RAPIDXML_HPP_INCLUDED
// Copyright (C) 2006, 2009 Marcin Kalicinski
// Version 1.13
// Revision $DateTime: 2009/05/13 01:46:17 $
//! \file rapidxml.hpp This file contains rapidxml parser and DOM implementation
#include <flxml/wrappers.h>
#include <flxml/tables.h>
#include <cstdint> // For std::size_t
#include <cassert> // For assert
#include <new> // For placement new
#include <string>
#include <span>
#include <optional>
#include <memory>
#include <stdexcept> // For std::runtime_error
// On MSVC, disable "conditional expression is constant" warning (level 4).
// This warning is almost impossible to avoid with certain types of templated code
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4127) // Conditional expression is constant
#endif
///////////////////////////////////////////////////////////////////////////
// RAPIDXML_PARSE_ERROR
#if defined(FLXML_NO_EXCEPTIONS)
#define FLXML_PARSE_ERROR(what, where) { parse_error_handler(what, where); assert(0); }
#define FLML_EOF_ERROR(what, where) { parse_error_handler(what, where); assert(0); }
namespace flxml
{
//! When exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS,
//! this function is called to notify user about the error.
//! It must be defined by the user.
//! <br><br>
//! This function cannot return. If it does, the results are undefined.
//! <br><br>
//! A very simple definition might look like that:
//! <pre>
//! void %rapidxml::%parse_error_handler(const char *what, void *where)
//! {
//! std::cout << "Parse error: " << what << "\n";
//! std::abort();
//! }
//! </pre>
//! \param what Human readable description of the error.
//! \param where Pointer to character data where error was detected.
void parse_error_handler(const char *what, void *where);
}
#else
#define FLXML_PARSE_ERROR(what, where) {if (*where == Ch(0)) throw eof_error(what, nullptr); else throw parse_error(what, nullptr);} (void)0
#define FLXML_EOF_ERROR(what, where) throw eof_error(what, nullptr)
namespace flxml
{
//! Parse error exception.
//! This exception is thrown by the parser when an error occurs.
//! Use what() function to get human-readable error message.
//! Use where() function to get a pointer to position within source text where error was detected.
//! <br><br>
//! If throwing exceptions by the parser is undesirable,
//! it can be disabled by defining RAPIDXML_NO_EXCEPTIONS macro before rapidxml.hpp is included.
//! This will cause the parser to call rapidxml::parse_error_handler() function instead of throwing an exception.
//! This function must be defined by the user.
//! <br><br>
//! This class derives from <code>std::exception</code> class.
class parse_error: public std::runtime_error
{
public:
//! Constructs parse error
parse_error(const char *what, void *where)
: std::runtime_error(what)
, m_where(where)
{
}
//! Gets pointer to character data where error happened.
//! Ch should be the same as char type of xml_document that produced the error.
//! \return Pointer to location within the parsed string where error occured.
template<class Ch>
Ch *where() const
{
return reinterpret_cast<Ch *>(m_where);
}
private:
void *m_where;
};
class eof_error : public parse_error {
public:
using parse_error::parse_error;
};
class validation_error : public std::runtime_error
{
public:
using std::runtime_error::runtime_error;
};
class xmlns_unbound : public validation_error {
public:
using validation_error::validation_error;
};
class duplicate_attribute : public validation_error {
public:
using validation_error::validation_error;
};
class attr_xmlns_unbound : public xmlns_unbound {
public:
using xmlns_unbound::xmlns_unbound;
};
class element_xmlns_unbound : public xmlns_unbound {
public:
using xmlns_unbound::xmlns_unbound;
};
}
#endif
///////////////////////////////////////////////////////////////////////////
// Pool sizes
#ifndef FLXML_STATIC_POOL_SIZE
// Size of static memory block of memory_pool.
// Define RAPIDXML_STATIC_POOL_SIZE before including rapidxml.hpp if you want to override the default value.
// No dynamic memory allocations are performed by memory_pool until static memory is exhausted.
#define FLXML_STATIC_POOL_SIZE (64 * 1024)
#endif
#ifndef FLXML_DYNAMIC_POOL_SIZE
// Size of dynamic memory block of memory_pool.
// Define RAPIDXML_DYNAMIC_POOL_SIZE before including rapidxml.hpp if you want to override the default value.
// After the static block is exhausted, dynamic blocks with approximately this size are allocated by memory_pool.
#define FLXML_DYNAMIC_POOL_SIZE (64 * 1024)
#endif
namespace flxml
{
// Forward declarations
template<typename Ch> class xml_node;
template<typename Ch> class xml_attribute;
template<typename Ch> class xml_document;
template<typename Ch> class children;
template<typename Ch> class descendants;
template<typename Ch> class attributes;
//! Enumeration listing all node types produced by the parser.
//! Use xml_node::type() function to query node type.
enum class node_type
{
node_document, //!< A document node. Name and value are empty.
node_element, //!< An element node. Name contains element name. Value contains text of first data node.
node_data, //!< A data node. Name is empty. Value contains data text.
node_cdata, //!< A CDATA node. Name is empty. Value contains data text.
node_comment, //!< A comment node. Name is empty. Value contains comment text.
node_declaration, //!< A declaration node. Name and value are empty. Declaration parameters (version, encoding and standalone) are in node attributes.
node_doctype, //!< A DOCTYPE node. Name is empty. Value contains DOCTYPE text.
node_pi, //!< A PI node. Name contains target. Value contains instructions.
node_literal //!< Value is unencoded text (used for inserting pre-rendered XML).
};
using enum node_type; // Import this into the rapidxml namespace as before.
///////////////////////////////////////////////////////////////////////
// Parsing flags
//! Parse flag instructing the parser to not create data nodes.
//! Text of first data node will still be placed in value of parent element, unless rapidxml::parse_no_element_values flag is also specified.
//! Can be combined with other flags by use of | operator.
//! <br><br>
//! See xml_document::parse() function.
const int parse_no_data_nodes = 0x1;
//! Parse flag instructing the parser to not use text of first data node as a value of parent element.
//! Can be combined with other flags by use of | operator.
//! Note that child data nodes of element node take precendence over its value when printing.
//! That is, if element has one or more child data nodes <em>and</em> a value, the value will be ignored.
//! Use rapidxml::parse_no_data_nodes flag to prevent creation of data nodes if you want to manipulate data using values of elements.
//! <br><br>
//! See xml_document::parse() function.
const int parse_no_element_values = 0x2;
//! Parse flag instructing the parser to not translate entities in the source text.
//! By default entities are translated, modifying source text.
//! Can be combined with other flags by use of | operator.
//! <br><br>
//! See xml_document::parse() function.
const int parse_no_entity_translation = 0x8;
//! Parse flag instructing the parser to disable UTF-8 handling and assume plain 8 bit characters.
//! By default, UTF-8 handling is enabled.
//! Can be combined with other flags by use of | operator.
//! <br><br>
//! See xml_document::parse() function.
const int parse_no_utf8 = 0x10;
//! Parse flag instructing the parser to create XML declaration node.
//! By default, declaration node is not created.
//! Can be combined with other flags by use of | operator.
//! <br><br>
//! See xml_document::parse() function.
const int parse_declaration_node = 0x20;
//! Parse flag instructing the parser to create comments nodes.
//! By default, comment nodes are not created.
//! Can be combined with other flags by use of | operator.
//! <br><br>
//! See xml_document::parse() function.
const int parse_comment_nodes = 0x40;
//! Parse flag instructing the parser to create DOCTYPE node.
//! By default, doctype node is not created.
//! Although W3C specification allows at most one DOCTYPE node, RapidXml will silently accept documents with more than one.
//! Can be combined with other flags by use of | operator.
//! <br><br>
//! See xml_document::parse() function.
const int parse_doctype_node = 0x80;
//! Parse flag instructing the parser to create PI nodes.
//! By default, PI nodes are not created.
//! Can be combined with other flags by use of | operator.
//! <br><br>
//! See xml_document::parse() function.
const int parse_pi_nodes = 0x100;
//! Parse flag instructing the parser to validate closing tag names.
//! If not set, name inside closing tag is irrelevant to the parser.
//! By default, closing tags are not validated.
//! Can be combined with other flags by use of | operator.
//! <br><br>
//! See xml_document::parse() function.
const int parse_validate_closing_tags = 0x200;
//! Parse flag instructing the parser to trim all leading and trailing whitespace of data nodes.
//! By default, whitespace is not trimmed.
//! This flag does not cause the parser to modify source text.
//! Can be combined with other flags by use of | operator.
//! <br><br>
//! See xml_document::parse() function.
const int parse_trim_whitespace = 0x400;
//! Parse flag instructing the parser to condense all whitespace runs of data nodes to a single space character.
//! Trimming of leading and trailing whitespace of data is controlled by rapidxml::parse_trim_whitespace flag.
//! By default, whitespace is not normalized.
//! If this flag is specified, source text will be modified.
//! Can be combined with other flags by use of | operator.
//! <br><br>
//! See xml_document::parse() function.
const int parse_normalize_whitespace = 0x800;
//! Parse flag to say "Parse only the initial element opening."
//! Useful for XMLstreams used in XMPP.
const int parse_open_only = 0x1000;
//! Parse flag to say "Toss the children of the top node and parse off
//! one element.
//! Useful for parsing off XMPP top-level elements.
const int parse_parse_one = 0x2000;
//! Parse flag to say "Validate XML namespaces fully."
//! This will generate additional errors, including unbound prefixes
//! and duplicate attributes (with different prefices)
const int parse_validate_xmlns = 0x4000;
// Compound flags
//! Parse flags which represent default behaviour of the parser.
//! This is always equal to 0, so that all other flags can be simply ored together.
//! Normally there is no need to inconveniently disable flags by anding with their negated (~) values.
//! This also means that meaning of each flag is a <i>negation</i> of the default setting.
//! For example, if flag name is rapidxml::parse_no_utf8, it means that utf-8 is <i>enabled</i> by default,
//! and using the flag will disable it.
//! <br><br>
//! See xml_document::parse() function.
[[maybe_unused]] const int parse_default = 0;
//! A combination of parse flags resulting in fastest possible parsing, without sacrificing important data.
//! <br><br>
//! See xml_document::parse() function.
const int parse_fastest = parse_no_data_nodes;
//! A combination of parse flags resulting in largest amount of data being extracted.
//! This usually results in slowest parsing.
//! <br><br>
//! See xml_document::parse() function.
const int parse_full = parse_declaration_node | parse_comment_nodes | parse_doctype_node | parse_pi_nodes | parse_validate_closing_tags | parse_validate_xmlns;
///////////////////////////////////////////////////////////////////////
// Memory pool
//! This class is used by the parser to create new nodes and attributes, without overheads of dynamic memory allocation.
//! In most cases, you will not need to use this class directly.
//! However, if you need to create nodes manually or modify names/values of nodes,
//! you are encouraged to use memory_pool of relevant xml_document to allocate the memory.
//! Not only is this faster than allocating them by using <code>new</code> operator,
//! but also their lifetime will be tied to the lifetime of document,
//! possibly simplyfing memory management.
//! <br><br>
//! Call allocate_node() or allocate_attribute() functions to obtain new nodes or attributes from the pool.
//! You can also call allocate_string() function to allocate strings.
//! Such strings can then be used as names or values of nodes without worrying about their lifetime.
//! Note that there is no <code>free()</code> function -- all allocations are freed at once when clear() function is called,
//! or when the pool is destroyed.
//! <br><br>
//! It is also possible to create a standalone memory_pool, and use it
//! to allocate nodes, whose lifetime will not be tied to any document.
//! <br><br>
//! Pool maintains <code>RAPIDXML_STATIC_POOL_SIZE</code> bytes of statically allocated memory.
//! Until static memory is exhausted, no dynamic memory allocations are done.
//! When static memory is exhausted, pool allocates additional blocks of memory of size <code>RAPIDXML_DYNAMIC_POOL_SIZE</code> each,
//! by using global <code>new[]</code> and <code>delete[]</code> operators.
//! This behaviour can be changed by setting custom allocation routines.
//! Use set_allocator() function to set them.
//! <br><br>
//! Allocations for nodes, attributes and strings are aligned at <code>RAPIDXML_ALIGNMENT</code> bytes.
//! This value defaults to the size of pointer on target architecture.
//! <br><br>
//! To obtain absolutely top performance from the parser,
//! it is important that all nodes are allocated from a single, contiguous block of memory.
//! Otherwise, cache misses when jumping between two (or more) disjoint blocks of memory can slow down parsing quite considerably.
//! If required, you can tweak <code>RAPIDXML_STATIC_POOL_SIZE</code>, <code>RAPIDXML_DYNAMIC_POOL_SIZE</code> and <code>RAPIDXML_ALIGNMENT</code>
//! to obtain best wasted memory to performance compromise.
//! To do it, define their values before rapidxml.hpp file is included.
//! \param Ch Character type of created nodes.
template<typename Ch = char>
class memory_pool
{
public:
//! \cond internal
using alloc_func = void * (*)(std::size_t); // Type of user-defined function used to allocate memory
using free_func = void (*)(void *); // Type of user-defined function used to free memory
//! \endcond
//! Constructs empty pool with default allocator functions.
memory_pool() {
init();
}
memory_pool(memory_pool const &) = delete;
memory_pool(memory_pool &&) = delete;
//! Destroys pool and frees all the memory.
//! This causes memory occupied by nodes allocated by the pool to be freed.
//! Nodes allocated from the pool are no longer valid.
~memory_pool()
{
clear();
}
using view_type = std::basic_string_view<Ch>;
//! Allocates a new node from the pool, and optionally assigns name and value to it.
//! If the allocation request cannot be accomodated, this function will throw <code>std::bad_alloc</code>.
//! If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function
//! will call rapidxml::parse_error_handler() function.
//! \param type Type of node to create.
//! \param name Name to assign to the node, or 0 to assign no name.
//! \param value Value to assign to the node, or 0 to assign no value.
//! \param name_size Size of name to assign, or 0 to automatically calculate size from name string.
//! \param value_size Size of value to assign, or 0 to automatically calculate size from value string.
//! \return Pointer to allocated node. This pointer will never be NULL.
template<typename... Args>
xml_node<Ch> * allocate_node_low(Args... args) {
void *memory = allocate_aligned<xml_node<Ch>>();
auto *node = new(memory) xml_node<Ch>(args...);
return node;
}
xml_node<Ch> * allocate_node(node_type type, view_type const & name, view_type const & value) {
auto * node = this->allocate_node_low(type, name);
node->value(value);
return node;
}
xml_node<Ch> * allocate_node(node_type type, view_type const & name) {
return this->allocate_node_low(type, name);
}
xml_node<Ch> * allocate_node(node_type type) {
return this->allocate_node_low(type);
}
//! Allocates a new attribute from the pool, and optionally assigns name and value to it.
//! If the allocation request cannot be accomodated, this function will throw <code>std::bad_alloc</code>.
//! If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function
//! will call rapidxml::parse_error_handler() function.
//! \param name Name to assign to the attribute, or 0 to assign no name.
//! \param value Value to assign to the attribute, or 0 to assign no value.
//! \param name_size Size of name to assign, or 0 to automatically calculate size from name string.
//! \param value_size Size of value to assign, or 0 to automatically calculate size from value string.
//! \return Pointer to allocated attribute. This pointer will never be NULL.
template<typename... Args>
xml_attribute<Ch> *allocate_attribute_low(Args... args) {
void *memory = allocate_aligned<xml_attribute<Ch>>();
auto *attribute = new(memory) xml_attribute<Ch>(args...);
return attribute;
}
xml_attribute<Ch> * allocate_attribute(view_type const & name, view_type const & value) {
auto * attr = this->allocate_attribute_low(name);
attr->value(value);
return attr;
}
xml_attribute<Ch> * allocate_attribute(view_type const & name) {
return this->allocate_attribute_low(name);
}
xml_attribute<Ch> * allocate_attribute() {
return this->allocate_attribute_low();
}
//! Allocates a char array of given size from the pool, and optionally copies a given string to it.
//! If the allocation request cannot be accomodated, this function will throw <code>std::bad_alloc</code>.
//! If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function
//! will call rapidxml::parse_error_handler() function.
//! \param source String to initialize the allocated memory with, or 0 to not initialize it.
//! \param size Number of characters to allocate, or zero to calculate it automatically from source string length; if size is 0, source string must be specified and null terminated.
//! \return Pointer to allocated char array. This pointer will never be NULL.
template<typename Sch>
std::span<Ch> allocate_span(std::basic_string_view<Sch> const & source)
{
if (source.size() == 0) return {}; // No need to allocate.
Ch *result = allocate_aligned<Ch>(source.size());
for (std::size_t i = 0; i < source.size(); ++i)
result[i] = source[i];
return {result, source.size()};
}
template<typename Sch>
view_type allocate_string(std::basic_string_view<Sch> const & source) {
auto span = allocate_span(source);
return {span.data(), span.size()};
}
template<typename Sch>
view_type allocate_string(std::basic_string<Sch> const & source) {
return allocate_string(std::basic_string_view{source.data(), source.size()});
}
template<typename Sch>
view_type allocate_string(const Sch * source) {
return allocate_string(std::basic_string_view<Sch>(source));
}
view_type const & nullstr()
{
return m_nullstr;
}
view_type const & xmlns_xml()
{
if (m_xmlns_xml.empty())
m_xmlns_xml = allocate_string("http://www.w3.org/XML/1998/namespace");
return m_xmlns_xml;
}
view_type const & xmlns_xmlns()
{
if (m_xmlns_xmlns.empty())
m_xmlns_xmlns = allocate_string("http://www.w3.org/2000/xmlns/");
return m_xmlns_xmlns;
}
//! Clones an xml_node and its hierarchy of child nodes and attributes.
//! Nodes and attributes are allocated from this memory pool.
//! Names and values are not cloned, they are shared between the clone and the source.
//! Result node can be optionally specified as a second parameter,
//! in which case its contents will be replaced with cloned source node.
//! This is useful when you want to clone entire document.
//! \param source Node to clone.
//! \param result Node to put results in, or 0 to automatically allocate result node
//! \return Pointer to cloned node. This pointer will never be NULL.
optional_ptr<xml_node<Ch>> clone_node(const optional_ptr<xml_node<Ch>> source, bool strings=false)
{
// Prepare result node
auto result = allocate_node(source->type());
auto s = [this, strings](view_type const & sv) { return strings ? this->allocate_string(sv) : sv; };
// Clone name and value
result->name(s(source->name()));
result->value(s(source->value()));
result->prefix(s(source->prefix()));
// Clone child nodes and attributes
for (auto child = source->first_node(); child; child = child->next_sibling())
result->append_node(clone_node(child, strings));
for (auto attr = source->first_attribute(); attr; attr = attr->next_attribute())
result->append_attribute(allocate_attribute(s(attr->name()), s(attr->value())));
return result;
}
//! Clears the pool.
//! This causes memory occupied by nodes allocated by the pool to be freed.
//! Any nodes or strings allocated from the pool will no longer be valid.
void clear()
{
while (m_begin != m_static_memory.data())
{
std::size_t s = sizeof(header) * 2;
void * h = m_begin;
std::align(alignof(header), sizeof(header), h, s);
void *previous_begin = reinterpret_cast<header *>(h)->previous_begin;
if (m_free_func)
m_free_func(m_begin);
else
delete[] reinterpret_cast<char *>(m_begin);
m_begin = previous_begin;
}
init();
}
//! Sets or resets the user-defined memory allocation functions for the pool.
//! This can only be called when no memory is allocated from the pool yet, otherwise results are undefined.
//! Allocation function must not return invalid pointer on failure. It should either throw,
//! stop the program, or use <code>longjmp()</code> function to pass control to other place of program.
//! If it returns invalid pointer, results are undefined.
//! <br><br>
//! User defined allocation functions must have the following forms:
//! <br><code>
//! <br>void *allocate(std::size_t size);
//! <br>void free(void *pointer);
//! </code><br>
//! \param af Allocation function, or 0 to restore default function
//! \param ff Free function, or 0 to restore default function
[[maybe_unused]] void set_allocator(alloc_func af, free_func ff)
{
assert(m_begin == m_static_memory.data() && m_ptr == m_begin); // Verify that no memory is allocated yet
m_alloc_func = af;
m_free_func = ff;
}
private:
struct header
{
void *previous_begin;
};
void init()
{
m_begin = m_static_memory.data();
m_ptr = m_begin;
m_space = m_static_memory.size();
}
void *allocate_raw(std::size_t size)
{
// Allocate
void *memory;
if (m_alloc_func) // Allocate memory using either user-specified allocation function or global operator new[]
{
memory = m_alloc_func(size);
assert(memory); // Allocator is not allowed to return 0, on failure it must either throw, stop the program or use longjmp
}
else
{
memory = new char[size];
#ifdef FLXML_NO_EXCEPTIONS
if (!memory) // If exceptions are disabled, verify memory allocation, because new will not be able to throw bad_alloc
FLXML_PARSE_ERROR("out of memory", 0);
#endif
}
return memory;
}
template<typename T>
T *allocate_aligned(std::size_t n = 1)
{
auto size = n * sizeof(T);
// Calculate aligned pointer
if (!std::align(alignof(T), sizeof(T) * n, m_ptr, m_space)) {
// If not enough memory left in current pool, allocate a new pool
// Calculate required pool size (may be bigger than RAPIDXML_DYNAMIC_POOL_SIZE)
std::size_t pool_size = FLXML_DYNAMIC_POOL_SIZE;
if (pool_size < size)
pool_size = size;
// Allocate
std::size_t alloc_size = sizeof(header) + (2 * alignof(header) - 2) + pool_size; // 2 alignments required in worst case: one for header, one for actual allocation
void *raw_memory = allocate_raw(alloc_size);
// Setup new pool in allocated memory
void *new_header = raw_memory;
std::align(alignof(header), sizeof(header), new_header, alloc_size);
auto * h = reinterpret_cast<header *>(new_header);
h->previous_begin = m_begin;
m_begin = raw_memory;
m_ptr = (h + 1);
m_space = alloc_size - sizeof(header);
// Calculate aligned pointer again using new pool
return allocate_aligned<T>(n);
}
auto * result = reinterpret_cast<T *>(m_ptr);
m_ptr = (result + n);
m_space -= size;
auto blank = reinterpret_cast<char *>(result);
auto end = blank + size;
while (blank != end) *blank++ = 'X';
return result;
}
void *m_begin = nullptr; // Start of raw memory making up current pool
void *m_ptr = nullptr; // First free byte in current pool
std::size_t m_space = FLXML_STATIC_POOL_SIZE; // Available space remaining
std::array<char, FLXML_STATIC_POOL_SIZE> m_static_memory = {}; // Static raw memory
alloc_func m_alloc_func = nullptr; // Allocator function, or 0 if default is to be used
free_func m_free_func = nullptr; // Free function, or 0 if default is to be used
view_type m_nullstr;
view_type m_xmlns_xml;
view_type m_xmlns_xmlns;
};
///////////////////////////////////////////////////////////////////////////
// XML base
//! Base class for xml_node and xml_attribute implementing common functions:
//! name(), name_size(), value(), value_size() and parent().
//! \param Ch Character type to use
template<typename Ch = char>
class xml_base
{
public:
using view_type = std::basic_string_view<Ch>;
///////////////////////////////////////////////////////////////////////////
// Construction & destruction
// Construct a base with empty name, value and parent
xml_base() = default;
explicit xml_base(view_type const & name) : m_name(name) {}
xml_base(view_type const & name, view_type const & value) : m_name(name), m_value(value) {}
///////////////////////////////////////////////////////////////////////////
// Node data access
//! Gets name of the node.
//! Interpretation of name depends on type of node.
//! Note that name will not be zero-terminated if rapidxml::parse_no_string_terminators option was selected during parse.
//! <br><br>
//! Use name_size() function to determine length of the name.
//! \return Name of node, or empty string if node has no name.
view_type const & name() const
{
return m_name;
}
//! Gets value of node.
//! Interpretation of value depends on type of node.
//! Note that value will not be zero-terminated if rapidxml::parse_no_string_terminators option was selected during parse.
//! <br><br>
//! Use value_size() function to determine length of the value.
//! \return Value of node, or empty string if node has no value.
view_type const & value_raw() const
{
return m_value;
}
///////////////////////////////////////////////////////////////////////////
// Node modification
//! Sets name of node to a non zero-terminated string.
//! See \ref ownership_of_strings.
//! <br><br>
//! Note that node does not own its name or value, it only stores a pointer to it.
//! It will not delete or otherwise free the pointer on destruction.
//! It is reponsibility of the user to properly manage lifetime of the string.
//! The easiest way to achieve it is to use memory_pool of the document to allocate the string -
//! on destruction of the document the string will be automatically freed.
//! <br><br>
//! Size of name must be specified separately, because name does not have to be zero terminated.
//! Use name(const Ch *) function to have the length automatically calculated (string must be zero terminated).
//! \param name Name of node to set. Does not have to be zero terminated.
//! \param size Size of name, in characters. This does not include zero terminator, if one is present.
void name(view_type const & name) {
m_name = name;
}
//! Sets value of node to a non zero-terminated string.
//! See \ref ownership_of_strings.
//! <br><br>
//! Note that node does not own its name or value, it only stores a pointer to it.
//! It will not delete or otherwise free the pointer on destruction.
//! It is reponsibility of the user to properly manage lifetime of the string.
//! The easiest way to achieve it is to use memory_pool of the document to allocate the string -
//! on destruction of the document the string will be automatically freed.
//! <br><br>
//! Size of value must be specified separately, because it does not have to be zero terminated.
//! Use value(const Ch *) function to have the length automatically calculated (string must be zero terminated).
//! <br><br>
//! If an element has a child node of type node_data, it will take precedence over element value when printing.
//! If you want to manipulate data of elements using values, use parser flag rapidxml::parse_no_data_nodes to prevent creation of data nodes by the parser.
//! \param value value of node to set. Does not have to be zero terminated.
//! \param size Size of value, in characters. This does not include zero terminator, if one is present.
void value_raw(view_type const & value)
{
m_value = value;
}
///////////////////////////////////////////////////////////////////////////
// Related nodes access
//! Gets node parent.
//! \return Pointer to parent node, or 0 if there is no parent.
optional_ptr<xml_node<Ch>> parent() const
{
return m_parent;
}
protected:
view_type m_name; // Name of node, or 0 if no name
view_type m_value; // Value of node, or 0 if no value
xml_node<Ch> *m_parent = nullptr; // Pointer to parent node, or 0 if none
};
//! Class representing attribute node of XML document.
//! Each attribute has name and value strings, which are available through name() and value() functions (inherited from xml_base).
//! Note that after parse, both name and value of attribute will point to interior of source text used for parsing.
//! Thus, this text must persist in memory for the lifetime of attribute.
//! \param Ch Character type to use.
template<typename Ch = char>
class xml_attribute: public xml_base<Ch>
{
friend class xml_node<Ch>;
public:
using view_type = std::basic_string_view<Ch>;
using ptr = optional_ptr<xml_attribute<Ch>>;
///////////////////////////////////////////////////////////////////////////
// Construction & destruction
//! Constructs an empty attribute with the specified type.
//! Consider using memory_pool of appropriate xml_document if allocating attributes manually.
xml_attribute() = default;
xml_attribute(view_type const & name) : xml_base<Ch>(name) {}
xml_attribute(view_type const & name, view_type const & value) : xml_base<Ch>(name, value) {}
void quote(Ch q) {
m_quote = q;
}
Ch quote() const {
return m_quote;
}
view_type const & value() const {
if (m_value.has_value()) return m_value.value();
m_value = document()->decode_attr_value(this);
return m_value.value();
}
void value(view_type const & v) {
m_value = v;
this->value_raw("");
if (this->m_parent) this->m_parent->dirty_parent();
}
// Return true if the value has been decoded.
bool value_decoded() const {
// Either we don't have a decoded value, or we do but it's identical.
return !m_value.has_value() || m_value.value().data() != this->value_raw().data();
}
///////////////////////////////////////////////////////////////////////////
// Related nodes access
//! Gets document of which attribute is a child.
//! \return Pointer to document that contains this attribute, or 0 if there is no parent document.
optional_ptr<xml_document<Ch>> document() const {
if (auto node = this->parent()) {
return node->document();
} else {
return nullptr;
}
}
view_type const & xmlns() const {
if (m_xmlns.has_value()) return m_xmlns.value();
auto const & name = this->name();
auto colon = name.find(':');
if (colon != view_type::npos) {
auto element = this->parent();
if (element) m_xmlns = element->xmlns_lookup(name.substr(0, colon), true);
} else {
m_xmlns = document()->nullstr();
}
return m_xmlns.value();
}
//! Gets previous attribute, optionally matching attribute name.
//! \param name Name of attribute to find, or 0 to return previous attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
//! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
//! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
//! \return Pointer to found attribute, or 0 if not found.
optional_ptr<xml_attribute<Ch>> previous_attribute(view_type const & name = {}) const
{
if (name)
{
for (xml_attribute<Ch> *attribute = m_prev_attribute; attribute; attribute = attribute->m_prev_attribute)
if (name == attribute->name())
return attribute;
return 0;
}
else
return this->m_parent ? m_prev_attribute : 0;
}
//! Gets next attribute, optionally matching attribute name.
//! \param name Name of attribute to find, or 0 to return next attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
//! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
//! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
//! \return Pointer to found attribute, or 0 if not found.
optional_ptr<xml_attribute<Ch>> next_attribute(view_type const & name = {}) const
{
if (!name.empty())
{
for (xml_attribute<Ch> *attribute = m_next_attribute; attribute; attribute = attribute->m_next_attribute)
if (attribute->name() == name)
return attribute;
return nullptr;
}
else
return this->m_parent ? m_next_attribute : nullptr;
}
view_type const & local_name() const
{
if (!m_local_name.empty()) return m_local_name;
auto colon = this->name().find(':');
if (colon == view_type::npos) {
m_local_name = this->name();
} else {
m_local_name = this->name().substr(colon + 1);
}
return m_local_name;
}
private:
xml_attribute<Ch> *m_prev_attribute = nullptr; // Pointer to previous sibling of attribute, or 0 if none; only valid if parent is non-zero
xml_attribute<Ch> *m_next_attribute = nullptr; // Pointer to next sibling of attribute, or 0 if none; only valid if parent is non-zero
Ch m_quote = 0; // When parsing, this should be set to the containing quote for the value.
mutable std::optional<view_type> m_xmlns;
mutable std::optional<view_type> m_value; // This is the decoded, not raw, value.
mutable view_type m_local_name; // ATTN: points inside m_name.
};
///////////////////////////////////////////////////////////////////////////
// XML node
//! Class representing a node of XML document.
//! Each node may have associated name and value strings, which are available through name() and value() functions.
//! Interpretation of name and value depends on type of the node.
//! Type of node can be determined by using type() function.
//! <br><br>
//! Note that after parse, both name and value of node, if any, will point interior of source text used for parsing.
//! Thus, this text must persist in the memory for the lifetime of node.
//! \param Ch Character type to use.
template<typename Ch = char>
class xml_node: public xml_base<Ch>
{
public:
using view_type = std::basic_string_view<Ch>;
using ptr = optional_ptr<xml_node<Ch>>;
///////////////////////////////////////////////////////////////////////////
// Construction & destruction
//! Constructs an empty node with the specified type.
//! Consider using memory_pool of appropriate document to allocate nodes manually.
//! \param type Type of node to construct.
explicit xml_node(node_type type)
: m_type(type)
{
}
xml_node(node_type type, view_type const & name) : xml_base<Ch>(name), m_type(type) {}
xml_node(node_type type, view_type const & name, view_type const & value) : xml_base<Ch>(name, value), m_type(type) {}
///////////////////////////////////////////////////////////////////////////
// Node data access
view_type const & value() const {
if (m_value.has_value()) return m_value.value();
if (m_type == node_element || m_type == node_data) {
m_value = document()->decode_data_value(this);
} else {
m_value = this->value_raw();
}
return m_value.value();
}
void dirty() {
m_clean = false;
dirty_parent();
}
void dirty_parent() {
if (this->m_parent) this->m_parent->dirty();
}
bool clean() const {
return m_clean;
}
void value(view_type const & v) {
if (this->m_type == node_element) {
// Set the first data node to the value, if one exists.
for (auto node = m_first_node; node; node = node->m_next_sibling) {
if (node->type() == node_data) {
node->value(v);
break;
}
}
}
m_value = v;
this->value_raw("");
dirty();
}
bool value_decoded() const {
return !m_value.has_value() || m_value.value().data() != this->value_raw().data();
}
//! Gets type of node.
//! \return Type of node.
node_type type() const {
return m_type;
}
void prefix(view_type const & prefix) {
m_prefix = prefix;
dirty_parent();
}
view_type const & prefix() const {
return m_prefix;
}
void contents(view_type const & contents) {
m_contents = contents;
// Reset to clean here.
m_clean = true;
}
view_type const & contents() const
{
return m_contents;
}
view_type const & xmlns() const {
if (m_xmlns.has_value()) return m_xmlns.value();
m_xmlns = xmlns_lookup(m_prefix, false);
return m_xmlns.value();
}
view_type const & xmlns_lookup(view_type const & prefix, bool attribute) const
{
std::basic_string<Ch> attrname{"xmlns"};
if (!prefix.empty()) {
// Check if the prefix begins "xml".
if (prefix.size() >= 3 && prefix.starts_with("xml")) {
if (prefix.size() == 3) {
return this->document()->xmlns_xml();
} else if (prefix.size() == 5
&& prefix[3] == Ch('n')
&& prefix[4] == Ch('s')) {
return this->document()->xmlns_xmlns();
}
}
attrname += ':';
attrname += prefix;
}
for (const xml_node<Ch> * node = this;
node;
node = node->m_parent) {
auto attr = node->first_attribute(attrname);
if (attr) {
return attr->value();
}
}
if (!prefix.empty()) {
if (attribute) {
throw attr_xmlns_unbound(attrname.c_str());
} else {
throw element_xmlns_unbound(attrname.c_str());
}
}
return document()->nullstr();
}
///////////////////////////////////////////////////////////////////////////
// Related nodes access
//! Gets document of which node is a child.
//! \return Pointer to document that contains this node, or 0 if there is no parent document.
optional_ptr<xml_document<Ch>> document() const
{
auto *node = this;
while (node) {
if (node->type() == node_document) {
return static_cast<xml_document<Ch> *>(const_cast<xml_node<Ch> *>(node));
}
node = node->parent().ptr_unsafe();
}
return nullptr;
}
flxml::children<Ch> children() const {
return flxml::children<Ch>{*this};
}
flxml::descendants<Ch> descendants() const {
return flxml::descendants<Ch>{optional_ptr<xml_node<Ch>>{const_cast<xml_node<Ch> *>(this)}};
}
flxml::attributes<Ch> attributes() const {
return flxml::attributes<Ch>{*this};
}
//! Gets first child node, optionally matching node name.
//! \param name Name of child to find, or 0 to return first child regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
//! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
//! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
//! \return Pointer to found child, or 0 if not found.
optional_ptr<xml_node<Ch>> first_node(view_type const & name = {}, view_type const & asked_xmlns = {}) const
{
view_type xmlns = asked_xmlns;
if (asked_xmlns.empty() && !name.empty()) {
// No XMLNS asked for, but a name is present.
// Assume "same XMLNS".
xmlns = this->xmlns();
}
for (xml_node<Ch> *child = m_first_node; child; child = child->m_next_sibling) {
if ((name.empty() || child->name() == name)
&& (xmlns.empty() || child->xmlns() == xmlns)) {
return child;
}
}
return nullptr;
}
//! Gets last child node, optionally matching node name.
//! Behaviour is undefined if node has no children.
//! Use first_node() to test if node has children.
//! \param name Name of child to find, or 0 to return last child regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
//! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
//! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
//! \return Pointer to found child, or 0 if not found.
optional_ptr<xml_node<Ch>> last_node(view_type const & name = {}, view_type const & asked_xmlns = {}) const
{
view_type xmlns = asked_xmlns;
if (asked_xmlns.empty() && !name.empty()) {
// No XMLNS asked for, but a name is present.
// Assume "same XMLNS".
xmlns = this->xmlns();
}
for (xml_node<Ch> *child = m_last_node; child; child = child->m_prev_sibling) {
if ((name.empty() || child->name() == name)
&& (xmlns.empty() || child->xmlns() == xmlns)) {
return child;
}
}
return nullptr;
}
//! Gets previous sibling node, optionally matching node name.
//! Behaviour is undefined if node has no parent.
//! Use parent() to test if node has a parent.
//! \param name Name of sibling to find, or 0 to return previous sibling regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
//! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
//! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
//! \return Pointer to found sibling, or 0 if not found.
optional_ptr<xml_node<Ch>> previous_sibling(view_type const & name = {}, view_type const & asked_xmlns = {}) const
{
assert(this->m_parent); // Cannot query for siblings if node has no parent
if (!name.empty())
{
view_type xmlns = asked_xmlns;
if (xmlns.empty() && !name.empty()) {
// No XMLNS asked for, but a name is present.
// Assume "same XMLNS".
xmlns = this->xmlns();
}
for (xml_node<Ch> *sibling = m_prev_sibling; sibling; sibling = sibling->m_prev_sibling)
if ((name.empty() || sibling->name() == name)
&& (xmlns.empty() || sibling->xmlns() == xmlns))
return sibling;
return nullptr;
}
else
return m_prev_sibling;
}
//! Gets next sibling node, optionally matching node name.
//! Behaviour is undefined if node has no parent.
//! Use parent() to test if node has a parent.
//! \param name Name of sibling to find, or 0 to return next sibling regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
//! \param xmlns Namespace of sibling to find, or 0 to return next sibling regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
//! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
//! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
//! \return Pointer to found sibling, or 0 if not found.
optional_ptr<xml_node<Ch>> next_sibling(view_type const & name = {}, view_type const & asked_xmlns = {}) const
{
assert(this->m_parent); // Cannot query for siblings if node has no parent
view_type xmlns = asked_xmlns;
if (xmlns.empty() && !name.empty()) {
// No XMLNS asked for, but a name is present.
// Assume "same XMLNS".
xmlns = this->xmlns();
}
for (xml_node<Ch> *sibling = m_next_sibling; sibling; sibling = sibling->m_next_sibling)
if ((name.empty() || sibling->name() == name)
&& (xmlns.empty() || sibling->xmlns() == xmlns))
return sibling;
return nullptr;
}
//! Gets first attribute of node, optionally matching attribute name.
//! \param name Name of attribute to find, or 0 to return first attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
//! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
//! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
//! \return Pointer to found attribute, or 0 if not found.
optional_ptr<xml_attribute<Ch>> first_attribute(view_type const & name = {}, view_type const & xmlns = {}) const
{
for (xml_attribute<Ch> *attribute = m_first_attribute; attribute; attribute = attribute->m_next_attribute)
if ((name.empty() || attribute->name() == name) && (xmlns.empty() || attribute->xmlns() == xmlns))
return attribute;
return nullptr;
}
//! Gets last attribute of node, optionally matching attribute name.
//! \param name Name of attribute to find, or 0 to return last attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
//! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
//! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
//! \return Pointer to found attribute, or 0 if not found.
optional_ptr<xml_attribute<Ch>> last_attribute(view_type const & name = {}, view_type const & xmlns = {}) const
{
for (xml_attribute<Ch> *attribute = m_last_attribute; attribute; attribute = attribute->m_prev_attribute)
if ((name.empty() || attribute->name() == name) && (xmlns.empty() || attribute->xmlns() == xmlns))
return attribute;
return nullptr;
}
///////////////////////////////////////////////////////////////////////////
// Node modification
//! Sets type of node.
//! \param type Type of node to set.
void type(node_type type) {
m_type = type;
dirty();
}
///////////////////////////////////////////////////////////////////////////
// Node manipulation
//! Allocate a new element to be added as a child at this node.
//! If an XMLNS is specified via the clarke notation syntax, then the prefix will match the parent element (if any),
//! and any needed xmlns attributes will be added for you.
//! Strings are assumed to remain in scope - you should document()->allocate_string() any that might not.
//! \param name Name of the element, either string view, string, or clarke notation
protected: // These are too easy to accidentally forget to append, prepend, or insert.
optional_ptr<xml_node<Ch>> allocate_element(view_type const & name) {
return document()->allocate_node(node_element, name);
}
optional_ptr<xml_node<Ch>> allocate_element(std::tuple<view_type,view_type> const & clark_name) {
auto [xmlns, name] = clark_name;
xml_node<Ch> * child;
if (xmlns != this->xmlns()) {
child = document()->allocate_node(node_element, name);
child->append_attribute(document()->allocate_attribute("xmlns", xmlns));
} else if (!this->prefix().empty()) {
std::basic_string<Ch> pname = std::string(this->prefix()) + ':';
pname += name;
child = document()->allocate_node(node_element, document()->allocate_string(pname));
} else {
child = document()->allocate_node(node_element, name);
}
return child;
}
optional_ptr<xml_node<Ch>> allocate_element(view_type const & name, view_type const & value) {
auto child = allocate_element(name);
child->value(value);
return child;
}
optional_ptr<xml_node<Ch>> allocate_element(std::tuple<view_type,view_type> const & clark_name, view_type const & value) {
auto child = allocate_element(clark_name);
child->value(value);
return child;
}
optional_ptr<xml_node<Ch>> allocate_element(std::initializer_list<const Ch *> const & clark_name) {
auto it = clark_name.begin();
auto a = *it;
auto b = *++it;
return allocate_element({view_type(a), view_type(b)});
}
optional_ptr<xml_node<Ch>> allocate_element(std::initializer_list<const Ch *> const & clark_name, view_type const & value) {
auto child = allocate_element(clark_name);
if (!value.empty()) child->value(value);
return child;
}
public:
//! Prepends a new child node.
//! The prepended child becomes the first child, and all existing children are moved one position back.
//! \param child Node to prepend.
optional_ptr<xml_node<Ch>> prepend_node(xml_node<Ch> *child)
{
assert(child && !child->parent() && child->type() != node_document);
dirty();
if (first_node())
{
child->m_next_sibling = m_first_node;
m_first_node->m_prev_sibling = child;
}
else
{
child->m_next_sibling = 0;
m_last_node = child;
}
m_first_node = child;
child->m_parent = this;
child->m_prev_sibling = 0;
return child;
}
auto prepend_node(optional_ptr<xml_node<Ch>> ptr) {
return prepend_node(ptr.get());
}
auto prepend_element(view_type const & v, view_type const & value = {}) {
auto child = allocate_element(v, value);
return prepend_node(child);
}
auto prepend_element(std::tuple<view_type, view_type> const & il, view_type const & value = {}) {
auto child = allocate_element(il, value);
return prepend_node(child);
}
auto prepend_element(std::initializer_list<const Ch *> const & il, view_type const & value = {}) {
auto child = allocate_element(il, value);
return prepend_node(child);
}
//! Appends a new child node.
//! The appended child becomes the last child.
//! \param child Node to append.
optional_ptr<xml_node<Ch>> append_node(xml_node<Ch> *child)
{
assert(child && !child->parent() && child->type() != node_document);
dirty();
if (first_node())
{
child->m_prev_sibling = m_last_node;
m_last_node->m_next_sibling = child;
}
else
{
child->m_prev_sibling = nullptr;
m_first_node = child;
}
m_last_node = child;
child->m_parent = this;
child->m_next_sibling = nullptr;
return child;
}
optional_ptr<xml_node<Ch>> append_node(optional_ptr<xml_node<Ch>> ptr) {
return append_node(ptr.get());
}
auto append_element(view_type const & v, view_type const & value = {}) {
auto child = allocate_element(v, value);
return append_node(child);
}
auto append_element(std::tuple<view_type, view_type> const & il, view_type const & value = {}) {
auto child = allocate_element(il, value);
return append_node(child);
}
auto append_element(std::initializer_list<const Ch *> const & il, view_type const & value = {}) {
auto child = allocate_element(il, value);
return append_node(child);
}
//! Inserts a new child node at specified place inside the node.
//! All children after and including the specified node are moved one position back.
//! \param where Place where to insert the child, or 0 to insert at the back.
//! \param child Node to insert.
optional_ptr<xml_node<Ch>> insert_node(xml_node<Ch> *where, xml_node<Ch> *child)
{
assert(!where || where->parent() == this);
assert(child && !child->parent() && child->type() != node_document);
dirty();
if (where == m_first_node)
prepend_node(child);
else if (!where)
append_node(child);
else
{
child->m_prev_sibling = where->m_prev_sibling;
child->m_next_sibling = where;
where->m_prev_sibling->m_next_sibling = child;
where->m_prev_sibling = child;
child->m_parent = this;
}
return child;
}
auto insert_node(optional_ptr<xml_node<Ch>> where, optional_ptr<xml_node<Ch>> ptr) {
return insert_node(where.ptr(), ptr.ptr());
}
auto insert_element(optional_ptr<xml_node<Ch>> where, view_type const & v, view_type const & value = {}) {
auto child = allocate_element(v, value);
return insert_node(where, child);
}
auto insert_element(optional_ptr<xml_node<Ch>> where, std::tuple<view_type, view_type> const & il, view_type const & value = {}) {
auto child = allocate_element(il, value);
return insert_node(where, child);
}
auto insert_element(optional_ptr<xml_node<Ch>> where, std::initializer_list<const Ch *> const & il, view_type const & value = {}) {
auto child = allocate_element(il, value);
return insert_node(where, child);
}
//! Removes first child node.
//! If node has no children, behaviour is undefined.
//! Use first_node() to test if node has children.
void remove_first_node()
{
assert(first_node());
dirty();
xml_node<Ch> *child = m_first_node;
m_first_node = child->m_next_sibling;
if (child->m_next_sibling)
child->m_next_sibling->m_prev_sibling = nullptr;
else
m_last_node = nullptr;
child->m_parent = nullptr;
}
//! Removes last child of the node.
//! If node has no children, behaviour is undefined.
//! Use first_node() to test if node has children.
void remove_last_node()
{
assert(first_node());
dirty();
xml_node<Ch> *child = m_last_node;
if (child->m_prev_sibling)
{
m_last_node = child->m_prev_sibling;
child->m_prev_sibling->m_next_sibling = nullptr;
}
else
m_first_node = nullptr;
child->m_parent = nullptr;
}
//! Removes specified child from the node
// \param where Pointer to child to be removed.
void remove_node(optional_ptr<xml_node<Ch>> where)
{
assert(where->parent() == this);
assert(first_node());
dirty();
if (where == m_first_node)
remove_first_node();
else if (where == m_last_node)
remove_last_node();
else
{
where->m_prev_sibling->m_next_sibling = where->m_next_sibling;
where->m_next_sibling->m_prev_sibling = where->m_prev_sibling;
where->m_parent = nullptr;
}
}
//! Removes all child nodes (but not attributes).
void remove_all_nodes()
{
if (!m_first_node) return;
dirty();
for (xml_node<Ch> *node = m_first_node; node; node = node->m_next_sibling) {
node->m_parent = nullptr;
}
m_first_node = nullptr;
m_last_node = nullptr;
}
//! Prepends a new attribute to the node.
//! \param attribute Attribute to prepend.
void prepend_attribute(xml_attribute<Ch> *attribute)
{
assert(attribute && !attribute->parent());
dirty_parent();
if (first_attribute())
{
attribute->m_next_attribute = m_first_attribute;
m_first_attribute->m_prev_attribute = attribute;
}
else
{
attribute->m_next_attribute = nullptr;
m_last_attribute = attribute;
}
m_first_attribute = attribute;
attribute->m_parent = this;
attribute->m_prev_attribute = nullptr;
}
//! Appends a new attribute to the node.
//! \param attribute Attribute to append.
void append_attribute(xml_attribute<Ch> *attribute)
{
assert(attribute && !attribute->parent());
dirty_parent();
if (first_attribute())
{
attribute->m_prev_attribute = m_last_attribute;
m_last_attribute->m_next_attribute = attribute;
}
else
{
attribute->m_prev_attribute = nullptr;
m_first_attribute = attribute;
}
m_last_attribute = attribute;
attribute->m_parent = this;
attribute->m_next_attribute = nullptr;
}
//! Inserts a new attribute at specified place inside the node.
//! All attributes after and including the specified attribute are moved one position back.
//! \param where Place where to insert the attribute, or 0 to insert at the back.
//! \param attribute Attribute to insert.
void insert_attribute(xml_attribute<Ch> *where, xml_attribute<Ch> *attribute)
{
assert(!where || where->parent() == this);
assert(attribute && !attribute->parent());
dirty_parent();
if (where == m_first_attribute)
prepend_attribute(attribute);
else if (!where)
append_attribute(attribute);
else
{
attribute->m_prev_attribute = where->m_prev_attribute;
attribute->m_next_attribute = where;
where->m_prev_attribute->m_next_attribute = attribute;
where->m_prev_attribute = attribute;
attribute->m_parent = this;
}
}
//! Removes first attribute of the node.
//! If node has no attributes, behaviour is undefined.
//! Use first_attribute() to test if node has attributes.
void remove_first_attribute()
{
assert(first_attribute());
dirty_parent();
xml_attribute<Ch> *attribute = m_first_attribute;
if (attribute->m_next_attribute)
{
attribute->m_next_attribute->m_prev_attribute = 0;
}
else
m_last_attribute = nullptr;
attribute->m_parent = nullptr;
m_first_attribute = attribute->m_next_attribute;
}
//! Removes last attribute of the node.
//! If node has no attributes, behaviour is undefined.
//! Use first_attribute() to test if node has attributes.
void remove_last_attribute()
{
assert(first_attribute());
dirty_parent();
xml_attribute<Ch> *attribute = m_last_attribute;
if (attribute->m_prev_attribute)
{
attribute->m_prev_attribute->m_next_attribute = 0;
m_last_attribute = attribute->m_prev_attribute;
}
else
m_first_attribute = nullptr;
attribute->m_parent = nullptr;
}
//! Removes specified attribute from node.
//! \param where Pointer to attribute to be removed.
void remove_attribute(optional_ptr<xml_attribute<Ch>> where)
{
assert(first_attribute() && where->parent() == this);
dirty_parent();
if (where == m_first_attribute)
remove_first_attribute();
else if (where == m_last_attribute)
remove_last_attribute();
else
{
where->m_prev_attribute->m_next_attribute = where->m_next_attribute;
where->m_next_attribute->m_prev_attribute = where->m_prev_attribute;
where->m_parent = nullptr;
}
}
//! Removes all attributes of node.
void remove_all_attributes()
{
if (!m_first_attribute) return;
dirty_parent();
for (xml_attribute<Ch> *attribute = m_first_attribute; attribute; attribute = attribute->m_next_attribute) {
attribute->m_parent = nullptr;
}
m_first_attribute = nullptr;
}
void validate() const
{
this->xmlns();
for (auto child = this->first_node();
child;
child = child->next_sibling()) {
child->validate();
}
for (auto attribute = first_attribute();
attribute;
attribute = attribute->m_next_attribute) {
attribute->xmlns();
for (auto otherattr = first_attribute();
otherattr != attribute;
otherattr = otherattr->m_next_attribute) {
if (attribute->name() == otherattr->name()) {
throw duplicate_attribute("Attribute doubled");
}
if ((attribute->local_name() == otherattr->local_name())
&& (attribute->xmlns() == otherattr->xmlns()))
throw duplicate_attribute("Attribute XMLNS doubled");
}
}
}
private:
///////////////////////////////////////////////////////////////////////////
// Restrictions
// No copying
xml_node(const xml_node &) = delete;
void operator =(const xml_node &) = delete;
///////////////////////////////////////////////////////////////////////////
// Data members
// Note that some of the pointers below have UNDEFINED values if certain other pointers are 0.
// This is required for maximum performance, as it allows the parser to omit initialization of
// unneded/redundant values.
//
// The rules are as follows:
// 1. first_node and first_attribute contain valid pointers, or 0 if node has no children/attributes respectively
// 2. last_node and last_attribute are valid only if node has at least one child/attribute respectively, otherwise they contain garbage
// 3. prev_sibling and next_sibling are valid only if node has a parent, otherwise they contain garbage
view_type m_prefix;
mutable std::optional<view_type> m_xmlns; // Cache
node_type m_type; // Type of node; always valid
xml_node<Ch> *m_first_node = nullptr; // Pointer to first child node, or 0 if none; always valid
xml_node<Ch> *m_last_node = nullptr; // Pointer to last child node, or 0 if none; this value is only valid if m_first_node is non-zero
xml_attribute<Ch> *m_first_attribute = nullptr; // Pointer to first attribute of node, or 0 if none; always valid
xml_attribute<Ch> *m_last_attribute = nullptr; // Pointer to last attribute of node, or 0 if none; this value is only valid if m_first_attribute is non-zero
xml_node<Ch> *m_prev_sibling = nullptr; // Pointer to previous sibling of node, or 0 if none; this value is only valid if m_parent is non-zero
xml_node<Ch> *m_next_sibling = nullptr; // Pointer to next sibling of node, or 0 if none; this value is only valid if m_parent is non-zero
view_type m_contents; // Pointer to original contents in buffer.
bool m_clean = false; // Unchanged since parsing (ie, contents are good).
mutable std::optional<view_type> m_value;
};
///////////////////////////////////////////////////////////////////////////
// XML document
//! This class represents root of the DOM hierarchy.
//! It is also an xml_node and a memory_pool through public inheritance.
//! Use parse() function to build a DOM tree from a zero-terminated XML text string.
//! parse() function allocates memory for nodes and attributes by using functions of xml_document,
//! which are inherited from memory_pool.
//! To access root node of the document, use the document itself, as if it was an xml_node.
//! \param Ch Character type to use.
template<class Ch = char>
class xml_document: public xml_node<Ch>, public memory_pool<Ch>
{
public:
using view_type = std::basic_string_view<Ch>;
using ptr = optional_ptr<xml_document<Ch>>;
//! Constructs empty XML document
xml_document()
: xml_node<Ch>(node_document)
{
}
//! Parses zero-terminated XML string according to given flags.
//! Passed string will be modified by the parser, unless rapidxml::parse_non_destructive flag is used.
//! The string must persist for the lifetime of the document.
//! In case of error, rapidxml::parse_error exception will be thrown.
//! <br><br>
//! If you want to parse contents of a file, you must first load the file into the memory, and pass pointer to its beginning.
//! Make sure that data is zero-terminated.
//! <br><br>
//! Document can be parsed into multiple times.
//! Each new call to parse removes previous nodes and attributes (if any), but does not clear memory pool.
//! \param text XML data to parse; pointer is non-const to denote fact that this data may be modified by the parser.
template<int Flags>
auto parse(const Ch * text, xml_document<Ch> * parent = nullptr) {
return this->parse_low<Flags>(text, parent);
}
template<int Flags>
auto parse(std::basic_string<Ch> const & str, xml_document<Ch> * parent = nullptr) {
return this->parse_low<Flags>(str.c_str(), parent);
}
template<int Flags, typename C>
requires std::is_same_v<Ch, typename C::value_type>
auto parse(C const & container, xml_document<Ch> * parent = nullptr) {
return this->parse_low<Flags>(buffer_ptr<C>(container), parent);
}
template<int Flags, typename T>
T parse_low(T text, xml_document<Ch> * parent) {
this->m_parse_flags = Flags;
// Remove current contents
this->remove_all_nodes();
this->remove_all_attributes();
this->m_parent = parent ? parent->first_node().get() : nullptr;
// Parse BOM, if any
parse_bom<Flags>(text);
// Parse children
while (true)
{
// Skip whitespace before node
skip<whitespace_pred, Flags>(text);
if (*text == 0)
break;
// Parse and append new child
if (*text == Ch('<'))
{
++text; // Skip '<'
if (xml_node<Ch> *node = parse_node<Flags>(text)) {
this->append_node(node);
if (Flags & (parse_open_only|parse_parse_one) && node->type() == node_element) {
break;
}
}
}
else
FLXML_PARSE_ERROR("expected <", text);
}
if (!this->first_node()) FLXML_PARSE_ERROR("no root element", text);
return text;
}
//! Clears the document by deleting all nodes and clearing the memory pool.
//! All nodes owned by document pool are destroyed.
void clear()
{
this->remove_all_nodes();
this->remove_all_attributes();
memory_pool<Ch>::clear();
}
template<int Flags>
view_type decode_data_value_low(view_type const & v) {
buffer_ptr first{v};
if (Flags & parse_normalize_whitespace) {
skip<text_pure_with_ws_pred,0>(first);
} else {
skip<text_pure_no_ws_pred,0>(first);
}
if (!*first) return v;
auto buf = this->allocate_string(v);
auto * start = buf.data();
buffer_ptr tmp{buf};
auto end = (Flags & parse_normalize_whitespace) ?
skip_and_expand_character_refs<text_pred,text_pure_with_ws_pred,Flags>(tmp) :
skip_and_expand_character_refs<text_pred,text_pure_no_ws_pred,Flags>(tmp);
// Trim trailing whitespace if flag is set; leading was already trimmed by whitespace skip after >
if (Flags & parse_trim_whitespace)
{
if (Flags & parse_normalize_whitespace)
{
// Whitespace is already condensed to single space characters by skipping function, so just trim 1 char off the end
if (*(end - 1) == Ch(' '))
--end;
}
else
{
// Backup until non-whitespace character is found
while (whitespace_pred::test(*(end - 1)))
--end;
}
}
return {start, end};
}
template<Ch Q>
view_type decode_attr_value_low(view_type const & v) {
buffer_ptr first{v};
skip<attribute_value_pure_pred<Q>,0>(first);
if (!*first || *first == Q) return v;
auto buf = this->allocate_string(v);
const Ch * start = buf.data();
buffer_ptr tmp{buf};
const Ch * end = skip_and_expand_character_refs<attribute_value_pred<Q>,attribute_value_pure_pred<Q>,0>(tmp);
return {start, end};
}
view_type decode_attr_value(const xml_attribute<Ch> * attr) {
if (attr->quote() == Ch('"')) {
return decode_attr_value_low<'"'>(attr->value_raw());
} else if (attr->quote() == Ch('\'')){
return decode_attr_value_low<'\''>(attr->value_raw());
} else {
return attr->value_raw();
}
}
view_type decode_data_value(const xml_node<Ch> * node) {
if (node->value_raw().empty()) return node->value_raw();
if (m_parse_flags & parse_normalize_whitespace) {
if (m_parse_flags & parse_trim_whitespace) {
const int Flags = parse_normalize_whitespace | parse_trim_whitespace;
return decode_data_value_low<Flags>(node->value_raw());
} else {
const int Flags = parse_normalize_whitespace;
return decode_data_value_low<Flags>(node->value_raw());
}
} else {
if (m_parse_flags & parse_trim_whitespace) {
const int Flags = parse_trim_whitespace;
return decode_data_value_low<Flags>(node->value_raw());
} else {
const int Flags = 0;
return decode_data_value_low<Flags>(node->value_raw());
}
}
}
void validate() const
{
for (auto child = this->first_node();
child;
child = child->next_sibling()) {
child->validate();
}
}
#ifndef RAPIDXML_TESTING
private:
#endif
///////////////////////////////////////////////////////////////////////
// Internal character utility functions
// Detect whitespace character
struct whitespace_pred
{
static unsigned char test(Ch ch)
{
return internal::lookup_tables::lookup_whitespace[static_cast<unsigned char>(ch)];
}
};
// Detect node name character
struct node_name_pred
{
static unsigned char test(Ch ch)
{
return internal::lookup_tables::lookup_node_name[static_cast<unsigned char>(ch)];
}
};
// Detect element name character
struct element_name_pred
{
static unsigned char test(Ch ch)
{
return internal::lookup_tables::lookup_element_name[static_cast<unsigned char>(ch)];
}
};
// Detect attribute name character
struct attribute_name_pred
{
static unsigned char test(Ch ch)
{
return internal::lookup_tables::lookup_attribute_name[static_cast<unsigned char>(ch)];
}
};
// Detect text character (PCDATA)
struct text_pred
{
static unsigned char test(Ch ch)
{
return internal::lookup_tables::lookup_text[static_cast<unsigned char>(ch)];
}
};
// Detect text character (PCDATA) that does not require processing
struct text_pure_no_ws_pred
{
static unsigned char test(Ch ch)
{
return internal::lookup_tables::lookup_text_pure_no_ws[static_cast<unsigned char>(ch)];
}
};
// Detect text character (PCDATA) that does not require processing
struct text_pure_with_ws_pred
{
static unsigned char test(Ch ch)
{
return internal::lookup_tables::lookup_text_pure_with_ws[static_cast<unsigned char>(ch)];
}
};
// Detect attribute value character
template<Ch Quote>
struct attribute_value_pred
{
static unsigned char test(Ch ch)
{
if (Quote == Ch('\''))
return internal::lookup_tables::lookup_attribute_data_1[static_cast<unsigned char>(ch)];
if (Quote == Ch('\"'))
return internal::lookup_tables::lookup_attribute_data_2[static_cast<unsigned char>(ch)];
return 0; // Should never be executed, to avoid warnings on Comeau
}
};
// Detect attribute value character
template<Ch Quote>
struct attribute_value_pure_pred
{
static unsigned char test(Ch ch)
{
if (Quote == Ch('\''))
return internal::lookup_tables::lookup_attribute_data_1_pure[static_cast<unsigned char>(ch)];
if (Quote == Ch('\"'))
return internal::lookup_tables::lookup_attribute_data_2_pure[static_cast<unsigned char>(ch)];
return 0; // Should never be executed, to avoid warnings on Comeau
}
};
// Insert coded character, using UTF8 or 8-bit ASCII
template<int Flags>
static void insert_coded_character(Ch *&text, unsigned long code)
{
if (Flags & parse_no_utf8)
{
// Insert 8-bit ASCII character
// Todo: possibly verify that code is less than 256 and use replacement char otherwise?
text[0] = static_cast<unsigned char>(code);
text += 1;
}
else
{
// Insert UTF8 sequence
if (code < 0x80) // 1 byte sequence
{
text[0] = static_cast<unsigned char>(code);
text += 1;
}
else if (code < 0x800) // 2 byte sequence
{
text[1] = static_cast<unsigned char>((code | 0x80) & 0xBF); code >>= 6;
text[0] = static_cast<unsigned char>(code | 0xC0);
text += 2;
}
else if (code < 0x10000) // 3 byte sequence
{
text[2] = static_cast<unsigned char>((code | 0x80) & 0xBF); code >>= 6;
text[1] = static_cast<unsigned char>((code | 0x80) & 0xBF); code >>= 6;
text[0] = static_cast<unsigned char>(code | 0xE0);
text += 3;
}
else if (code < 0x110000) // 4 byte sequence
{
text[3] = static_cast<unsigned char>((code | 0x80) & 0xBF); code >>= 6;
text[2] = static_cast<unsigned char>((code | 0x80) & 0xBF); code >>= 6;
text[1] = static_cast<unsigned char>((code | 0x80) & 0xBF); code >>= 6;
text[0] = static_cast<unsigned char>(code | 0xF0);
text += 4;
}
else // Invalid, only codes up to 0x10FFFF are allowed in Unicode
{
FLXML_PARSE_ERROR("invalid numeric character entity", text);
}
}
}
// Skip characters until predicate evaluates to true
template<class StopPred, int Flags, typename Chp>
static void skip(Chp & b)
{
while (StopPred::test(*b))
++b;
}
// Skip characters until predicate evaluates to true while doing the following:
// - replacing XML character entity references with proper characters (' & " < > &#...;)
// - condensing whitespace sequences to single space character
template<class StopPred, class StopPredPure, int Flags, typename Chp>
static const Ch *skip_and_expand_character_refs(Chp text)
{
// If entity translation, whitespace condense and whitespace trimming is disabled, use plain skip
if (Flags & parse_no_entity_translation &&
!(Flags & parse_normalize_whitespace) &&
!(Flags & parse_trim_whitespace))
{
skip<StopPred, Flags>(text);
return &*text;
}
// Use simple skip until first modification is detected
skip<StopPredPure, Flags>(text);
// Use translation skip
Chp src = text;
Ch * dest = const_cast<Ch *>(&*src);
while (StopPred::test(*src))
{
// If entity translation is enabled
if (!(Flags & parse_no_entity_translation))
{
// Test if replacement is needed
if (src[0] == Ch('&'))
{
switch (src[1])
{
// & '
case Ch('a'):
if (src[2] == Ch('m') && src[3] == Ch('p') && src[4] == Ch(';'))
{
*dest = Ch('&');
++dest;
src += 5;
continue;
}
if (src[2] == Ch('p') && src[3] == Ch('o') && src[4] == Ch('s') && src[5] == Ch(';'))
{
*dest = Ch('\'');
++dest;
src += 6;
continue;
}
break;
// "
case Ch('q'):
if (src[2] == Ch('u') && src[3] == Ch('o') && src[4] == Ch('t') && src[5] == Ch(';'))
{
*dest = Ch('"');
++dest;
src += 6;
continue;
}
break;
// >
case Ch('g'):
if (src[2] == Ch('t') && src[3] == Ch(';'))
{
*dest = Ch('>');
++dest;
src += 4;
continue;
}
break;
// <
case Ch('l'):
if (src[2] == Ch('t') && src[3] == Ch(';'))
{
*dest = Ch('<');
++dest;
src += 4;
continue;
}
break;
// &#...; - assumes ASCII
case Ch('#'):
if (src[2] == Ch('x'))
{
unsigned long code = 0;
src += 3; // Skip &#x
while (true)
{
unsigned char digit = internal::lookup_tables::lookup_digits[static_cast<unsigned char>(*src)];
if (digit == 0xFF)
break;
code = code * 16 + digit;
++src;
}
insert_coded_character<Flags>(dest, code); // Put character in output
}
else
{
unsigned long code = 0;
src += 2; // Skip &#
while (true)
{
unsigned char digit = internal::lookup_tables::lookup_digits[static_cast<unsigned char>(*src)];
if (digit == 0xFF)
break;
code = code * 10 + digit;
++src;
}
insert_coded_character<Flags>(dest, code); // Put character in output
}
if (*src == Ch(';'))
++src;
else
FLXML_PARSE_ERROR("expected ;", src);
continue;
// Something else
default:
// Ignore, just copy '&' verbatim
break;
}
}
}
// If whitespace condensing is enabled
if (Flags & parse_normalize_whitespace && whitespace_pred::test(*src)) {
*dest = Ch(' '); ++dest; // Put single space in dest
++src; // Skip first whitespace char
// Skip remaining whitespace chars
while (whitespace_pred::test(*src))
++src;
continue;
}
// No replacement, only copy character
*dest++ = *src++;
}
// Return new end
return dest;
}
///////////////////////////////////////////////////////////////////////
// Internal parsing functions
// Parse BOM, if any
template<int Flags, typename Chp>
void parse_bom(Chp &texta)
{
Chp text = texta;
// UTF-8?
if (static_cast<unsigned char>(*text++) == 0xEF &&
static_cast<unsigned char>(*text++) == 0xBB &&
static_cast<unsigned char>(*text++) == 0xBF)
{
texta = text; // Skup utf-8 bom
}
}
// Parse XML declaration (<?xml...)
template<int Flags, typename Chp>
xml_node<Ch> *parse_xml_declaration(Chp &text)
{
// If parsing of declaration is disabled
if (!(Flags & parse_declaration_node))
{
// Skip until end of declaration
while (text[0] != Ch('?') || text[1] != Ch('>'))
{
if (!text[0]) FLXML_PARSE_ERROR("unexpected end of data", text);
++text;
}
text += 2; // Skip '?>'
return 0;
}
// Create declaration
xml_node<Ch> *declaration = this->allocate_node(node_declaration);
// Skip whitespace before attributes or ?>
skip<whitespace_pred, Flags>(text);
// Parse declaration attributes
parse_node_attributes<Flags>(text, declaration);
// Skip ?>
if (text[0] != Ch('?') || text[1] != Ch('>')) FLXML_PARSE_ERROR("expected ?>", text);
text += 2;
return declaration;
}
// Parse XML comment (<!--...)
template<int Flags, typename Chp>
xml_node<Ch> *parse_comment(Chp &text)
{
// If parsing of comments is disabled
if (!(Flags & parse_comment_nodes))
{
// Skip until end of comment
while (text[0] != Ch('-') || text[1] != Ch('-') || text[2] != Ch('>'))
{
if (!text[0]) FLXML_PARSE_ERROR("unexpected end of data", text);
++text;
}
text += 3; // Skip '-->'
return 0; // Do not produce comment node
}
// Remember value start
Chp value = text;
// Skip until end of comment
while (text[0] != Ch('-') || text[1] != Ch('-') || text[2] != Ch('>'))
{
if (!text[0]) FLXML_PARSE_ERROR("unexpected end of data", text);
++text;
}
// Create comment node
xml_node<Ch> *comment = this->allocate_node(node_comment);
comment->value({value, text});
text += 3; // Skip '-->'
return comment;
}
// Parse DOCTYPE
template<int Flags, typename Chp>
xml_node<Ch> *parse_doctype(Chp &text)
{
// Remember value start
Chp value = text;
// Skip to >
while (*text != Ch('>'))
{
// Determine character type
switch (*text)
{
// If '[' encountered, scan for matching ending ']' using naive algorithm with depth
// This works for all W3C test files except for 2 most wicked
case Ch('['):
{
++text; // Skip '['
int depth = 1;
while (depth > 0)
{
switch (*text)
{
case Ch('['): ++depth; break;
case Ch(']'): --depth; break;
case 0: FLXML_PARSE_ERROR("unexpected end of data", text);
default: break;
}
++text;
}
break;
}
// Error on end of text
case Ch('\0'):
FLXML_PARSE_ERROR("unexpected end of data", text);
// Other character, skip it
default:
++text;
}
}
// If DOCTYPE nodes enabled
if (Flags & parse_doctype_node)
{
// Create a new doctype node
xml_node<Ch> *doctype = this->allocate_node(node_doctype);
doctype->value({value, text});
text += 1; // skip '>'
return doctype;
}
else
{
text += 1; // skip '>'
return 0;
}
}
// Parse PI
template<int Flags, typename Chp>
xml_node<Ch> *parse_pi(Chp &text)
{
// If creation of PI nodes is enabled
if (Flags & parse_pi_nodes)
{
// Create pi node
xml_node<Ch> *pi = this->allocate_node(node_pi);
// Extract PI target name
Chp name = text;
skip<node_name_pred, Flags>(text);
if (text == name) FLXML_PARSE_ERROR("expected PI target", text);
pi->name({name, text});
// Skip whitespace between pi target and pi
skip<whitespace_pred, Flags>(text);
// Remember start of pi
Chp value = text;
// Skip to '?>'
while (text[0] != Ch('?') || text[1] != Ch('>'))
{
if (*text == Ch('\0'))
FLXML_PARSE_ERROR("unexpected end of data", text);
++text;
}
// Set pi value (verbatim, no entity expansion or whitespace normalization)
pi->value({value, text});
text += 2; // Skip '?>'
return pi;
}
else
{
// Skip to '?>'
while (text[0] != Ch('?') || text[1] != Ch('>'))
{
if (*text == Ch('\0'))
FLXML_PARSE_ERROR("unexpected end of data", text);
++text;
}
text += 2; // Skip '?>'
return 0;
}
}
// Parse and append data
// Return character that ends data.
// This is necessary because this character might have been overwritten by a terminating 0
template<int Flags, typename Chp>
Ch parse_and_append_data(xml_node<Ch> *node, Chp &text, Chp contents_start)
{
// Backup to contents start if whitespace trimming is disabled
if (!(Flags & parse_trim_whitespace))
text = contents_start;
// Skip until end of data. We should check if the contents will need decoding.
Chp value = text;
bool encoded = false;
skip<text_pure_no_ws_pred,0>(text);
if (text_pred::test(*text)) {
encoded = true;
skip<text_pred,0>(text);
}
// If characters are still left between end and value (this test is only necessary if normalization is enabled)
// Create new data node
if (!(Flags & parse_no_data_nodes))
{
xml_node<Ch> *data = this->allocate_node(node_data);
data->value_raw({value, text});
if (!encoded) data->value(data->value_raw());
node->append_node(data);
}
// Add data to parent node if no data exists yet
if (!(Flags & parse_no_element_values)) {
if (node->value_raw().empty()) {
node->value_raw({value, text});
if (!encoded) node->value(node->value_raw());
}
}
// Return character that ends data
return *text;
}
// Parse CDATA
template<int Flags, typename Chp>
xml_node<Ch> *parse_cdata(Chp &text)
{
// If CDATA is disabled
if (Flags & parse_no_data_nodes)
{
// Skip until end of cdata
while (text[0] != Ch(']') || text[1] != Ch(']') || text[2] != Ch('>'))
{
if (!text[0])
FLXML_PARSE_ERROR("unexpected end of data", text);
++text;
}
text += 3; // Skip ]]>
return 0; // Do not produce CDATA node
}
// Skip until end of cdata
Chp value = text;
while (text[0] != Ch(']') || text[1] != Ch(']') || text[2] != Ch('>'))
{
if (!text[0])
FLXML_PARSE_ERROR("unexpected end of data", text);
++text;
}
// Create new cdata node
xml_node<Ch> *cdata = this->allocate_node(node_cdata);
cdata->value({value, text});
text += 3; // Skip ]]>
return cdata;
}
// Parse element node
template<int Flags, typename Chp>
xml_node<Ch> *parse_element(Chp &text)
{
// Create element node
xml_node<Ch> *element = this->allocate_node(node_element);
// Extract element name
Chp prefix = text;
view_type qname;
skip<element_name_pred, Flags>(text);
if (text == prefix)
FLXML_PARSE_ERROR("expected element name or prefix", text);
if (*text == Ch(':')) {
element->prefix({prefix, text});
++text;
Chp name = text;
skip<node_name_pred, Flags>(text);
if (text == name)
FLXML_PARSE_ERROR("expected element local name", text);
element->name({name, text});
} else {
element->name({prefix, text});
}
qname = {prefix, text};
// Skip whitespace between element name and attributes or >
skip<whitespace_pred, Flags>(text);
// Parse attributes, if any
parse_node_attributes<Flags>(text, element);
// Once we have all the attributes, we should be able to fully validate:
if (Flags & parse_validate_xmlns) this->validate();
// Determine ending type
if (*text == Ch('>'))
{
Chp contents = ++text;
Chp contents_end = contents;
if (!(Flags & parse_open_only))
contents_end = parse_node_contents<Flags>(text, element, qname);
if (contents != contents_end) element->contents({contents, contents_end});
}
else if (*text == Ch('/'))
{
++text;
if (*text != Ch('>'))
FLXML_PARSE_ERROR("expected >", text);
++text;
if (Flags & parse_open_only)
FLXM
gitextract_2ljvjjz2/
├── .github/
│ └── workflows/
│ └── gtest.yml
├── .gitignore
├── README.md
├── conanfile.py
├── include/
│ ├── flxml/
│ │ ├── generator.h
│ │ ├── iterators.h
│ │ ├── predicates.h
│ │ ├── print.h
│ │ ├── tables.h
│ │ ├── utils.h
│ │ └── wrappers.h
│ ├── flxml.h
│ ├── rapidxml.hpp
│ └── rapidxml_print.hpp
├── license.txt
├── manual.html
└── test/
├── CMakeLists.txt
├── conanfile.py
├── sonar-project.properties
└── src/
├── iterators.cpp
├── low-level-parse.cpp
├── main.cc
├── manipulations.cpp
├── parse-simple.cpp
├── perf.cpp
├── round-trips.cpp
└── xpath.cpp
SYMBOL INDEX (190 symbols across 18 files)
FILE: conanfile.py
class FLXML (line 4) | class FLXML(ConanFile):
method package (line 9) | def package(self):
method package_info (line 13) | def package_info(self):
FILE: include/flxml.h
function namespace (line 36) | namespace flxml
function namespace (line 62) | namespace flxml
function class (line 101) | class eof_error : public parse_error {
function class (line 106) | class validation_error : public std::runtime_error
function class (line 112) | class xmlns_unbound : public validation_error {
function class (line 117) | class duplicate_attribute : public validation_error {
function class (line 122) | class attr_xmlns_unbound : public xmlns_unbound {
function class (line 127) | class element_xmlns_unbound : public xmlns_unbound {
function namespace (line 152) | namespace flxml
function value (line 764) | void value(view_type const & v) {
function dirty (line 901) | void dirty() {
function dirty_parent (line 905) | void dirty_parent() {
function value (line 912) | void value(view_type const & v) {
function prefix (line 937) | void prefix(view_type const & prefix) {
function contents (line 946) | void contents(view_type const & contents) {
function view_type (line 962) | view_type const & xmlns_lookup(view_type const & prefix, bool attribute)...
function remove_first_node (line 1328) | void remove_first_node()
function remove_last_node (line 1344) | void remove_last_node()
function remove_node (line 1361) | void remove_node(optional_ptr<xml_node<Ch>> where)
function remove_all_nodes (line 1379) | void remove_all_nodes()
function prepend_attribute (line 1392) | void prepend_attribute(xml_attribute<Ch> *attribute)
function append_attribute (line 1413) | void append_attribute(xml_attribute<Ch> *attribute)
function insert_attribute (line 1436) | void insert_attribute(xml_attribute<Ch> *where, xml_attribute<Ch> *attri...
function remove_first_attribute (line 1458) | void remove_first_attribute()
function remove_last_attribute (line 1476) | void remove_last_attribute()
function remove_attribute (line 1493) | void remove_attribute(optional_ptr<xml_attribute<Ch>> where)
function remove_all_attributes (line 1510) | void remove_all_attributes()
function clear (line 1670) | void clear()
function buffer_ptr (line 1679) | buffer_ptr first{v}
function buffer_ptr (line 1688) | buffer_ptr tmp{buf};
function buffer_ptr (line 1714) | buffer_ptr first{v}
function buffer_ptr (line 1719) | buffer_ptr tmp{buf};
function view_type (line 1724) | view_type decode_attr_value(const xml_attribute<Ch> * attr) {
function view_type (line 1734) | view_type decode_data_value(const xml_node<Ch> * node) {
type whitespace_pred (line 1772) | struct whitespace_pred
type node_name_pred (line 1781) | struct node_name_pred
type element_name_pred (line 1790) | struct element_name_pred
type attribute_name_pred (line 1799) | struct attribute_name_pred
type text_pred (line 1808) | struct text_pred
type text_pure_no_ws_pred (line 1817) | struct text_pure_no_ws_pred
type text_pure_with_ws_pred (line 1826) | struct text_pure_with_ws_pred
function test (line 1838) | static unsigned char test(Ch ch)
function test (line 1852) | static unsigned char test(Ch ch)
function Ch (line 1921) | const Ch *skip_and_expand_character_refs(Chp text)
FILE: include/flxml/generator.h
function namespace (line 11) | namespace flxml {
function promise_type (line 44) | struct handle_type : std::coroutine_handle<promise_type> {
FILE: include/flxml/iterators.h
function namespace (line 11) | namespace flxml
function operator (line 73) | bool operator == (const node_iterator<Ch>& rhs) const
function operator (line 78) | bool operator != (const node_iterator<Ch>& rhs) const
function valid (line 93) | bool valid()
function explicit (line 120) | explicit descendant_iterator(xml_node<Ch>::ptr node)
function reference (line 128) | reference operator *() const
function pointer (line 133) | pointer operator->() const
function operator (line 196) | bool operator != (const descendant_iterator<Ch>& rhs) const
function valid (line 213) | bool valid()
function explicit (line 242) | explicit attribute_iterator(xml_node<Ch> const &node)
function m_attribute (line 248) | attribute_iterator(attribute_iterator const & other) : m_attribute(other...
function reference (line 250) | reference operator *() const
function pointer (line 255) | pointer operator->() const
function m_node (line 318) | m_node(node) {}
function explicit (line 319) | explicit children(optional_ptr<xml_node<Ch>> const ptr) : m_node(ptr.val...
function m_node (line 321) | children(children const & other) : m_node(other.m_node) {}
function iterator (line 326) | iterator begin() {
function iterator (line 329) | iterator end() {
function m_node (line 346) | m_node(node) {}
function explicit (line 347) | explicit descendants(optional_ptr<xml_node<Ch>> ptr) : m_node(ptr.value(...
function m_node (line 349) | descendants(descendants const & other) : m_node(other.m_node) {}
function iterator (line 354) | iterator begin() {
function iterator (line 357) | iterator end() {
function m_node (line 374) | m_node(node) {}
function explicit (line 375) | explicit attributes(optional_ptr<xml_node<Ch>> ptr) : m_node(ptr.value()...
function iterator (line 380) | iterator begin() {
FILE: include/flxml/predicates.h
function namespace (line 13) | namespace flxml {
function do_match (line 58) | bool do_match(const xml_node<Ch> & t) override {
function do_match (line 102) | bool do_match(const xml_node<Ch> & t) override {
function context (line 158) | void context(std::unique_ptr<xpath<Ch>> && xp) {
function parse_predicate (line 193) | static void parse_predicate(std::basic_string_view<Ch> const &name, xpat...
function std (line 287) | static std::unique_ptr<xpath<Ch>> parse_cont(std::map<std::string,std::s...
function std (line 298) | static std::unique_ptr<xpath<Ch>> parse(std::map<std::string,std::string...
function std (line 308) | static std::unique_ptr<xpath<Ch>> parse(std::map<std::string,std::string...
function std (line 312) | static std::unique_ptr<xpath<Ch>> parse(std::map<std::string,std::string...
function std (line 316) | static std::unique_ptr<xpath<Ch>> parse(std::map<std::string,std::string...
function std (line 320) | static std::unique_ptr<xpath<Ch>> parse(std::basic_string_view<Ch> &sv) {
function std (line 323) | static std::unique_ptr<xpath<Ch>> parse(std::basic_string<Ch> const &vie...
function std (line 327) | static std::unique_ptr<xpath<Ch>> parse(std::basic_string_view<Ch> const...
function std (line 331) | static std::unique_ptr<xpath<Ch>> parse(const char * view) {
function explicit (line 336) | explicit xpath(std::map<std::string,std::string> & xmlns) : m_xmlns(xmln...
FILE: include/flxml/print.h
function namespace (line 17) | namespace flxml
FILE: include/flxml/tables.h
function namespace (line 15) | namespace flxml::internal {
FILE: include/flxml/utils.h
function namespace (line 16) | namespace flxml
FILE: include/flxml/wrappers.h
function namespace (line 12) | namespace flxml {
function operator (line 92) | bool operator == (buffer_ptr const & other) const {
function difference_type (line 116) | difference_type operator - (buffer_ptr const & other) const {
function pointer (line 120) | pointer ptr() {
function class (line 131) | class no_such_node : std::runtime_error {
function T (line 158) | T * get() {
FILE: test/conanfile.py
class FLXML (line 4) | class FLXML(ConanFile):
method configure (line 9) | def configure(self):
method requirements (line 12) | def requirements(self):
method generate (line 17) | def generate(self):
method build (line 24) | def build(self):
method test (line 29) | def test(self):
FILE: test/src/iterators.cpp
function TEST (line 11) | TEST(Iterators, Nodes) {
function TEST (line 33) | TEST(Iterators, Attributes) {
function TEST (line 55) | TEST(Predicates, Nodes) {
function TEST (line 69) | TEST(Predicates, AllNodes) {
function TEST (line 89) | TEST(Predicates, AllNodesRev) {
function TEST (line 117) | TEST(Predicates, Attributes) {
FILE: test/src/low-level-parse.cpp
function TEST (line 8) | TEST(Constants, Empty) {
function TEST (line 15) | TEST(Predicates, Skip) {
function TEST (line 25) | TEST(PredicateBuffer, Skip) {
function TEST (line 35) | TEST(Predicates, SkipAndExpand) {
function TEST (line 45) | TEST(Predicates, SkipAndExpandShort) {
function TEST (line 55) | TEST(Predicates, SkipAndExpandShorter) {
function TEST (line 65) | TEST(ParseFns, ParseBom) {
function TEST (line 73) | TEST(ParseFns, ParseBomShort) {
function TEST (line 81) | TEST(ParseFns, ParseBomShorter) {
FILE: test/src/main.cc
class EventListener (line 9) | class EventListener : public ::testing::TestEventListener {
method EventListener (line 17) | EventListener(std::string const & progname) : m_progname(progname) {}
method OnTestProgramStart (line 21) | void OnTestProgramStart(const ::testing::UnitTest & u) override {
method OnTestProgramEnd (line 26) | void OnTestProgramEnd(const ::testing::UnitTest &) override {
method OnTestStart (line 30) | void OnTestStart(::testing::TestInfo const & test_info) override {
method OnTestEnd (line 43) | void OnTestEnd(const ::testing::TestInfo & ti) override {
method OnTestIterationStart (line 50) | void OnTestIterationStart(const testing::UnitTest &unit_test, int iter...
method OnEnvironmentsSetUpStart (line 63) | void OnEnvironmentsSetUpStart(const testing::UnitTest &unit_test) over...
method OnEnvironmentsSetUpEnd (line 67) | void OnEnvironmentsSetUpEnd(const testing::UnitTest &unit_test) overri...
method OnTestSuiteStart (line 71) | void OnTestSuiteStart(const testing::TestSuite &suite) override {
method OnTestCaseStart (line 80) | void OnTestCaseStart(const testing::TestCase &aCase) override {
method OnTestDisabled (line 84) | void OnTestDisabled(const testing::TestInfo &info) override {
method OnTestPartResult (line 88) | void OnTestPartResult(const testing::TestPartResult &test_part_result)...
method OnTestSuiteEnd (line 101) | void OnTestSuiteEnd(const testing::TestSuite &suite) override {
method OnTestCaseEnd (line 109) | void OnTestCaseEnd(const testing::TestCase &aCase) override {
method OnEnvironmentsTearDownStart (line 113) | void OnEnvironmentsTearDownStart(const testing::UnitTest &unit_test) o...
method OnEnvironmentsTearDownEnd (line 117) | void OnEnvironmentsTearDownEnd(const testing::UnitTest &unit_test) ove...
method OnTestIterationEnd (line 121) | void OnTestIterationEnd(const testing::UnitTest &unit_test, int iterat...
function main (line 132) | int main(int argc, char ** argv) {
FILE: test/src/manipulations.cpp
function print (line 11) | auto print(flxml::xml_document<> & doc) {
function TEST (line 18) | TEST(Create, Node) {
function TEST (line 29) | TEST(Create, NodeEmpty) {
function TEST (line 40) | TEST(Create, Node2) {
function TEST (line 57) | TEST(Create, NodeAttr) {
FILE: test/src/parse-simple.cpp
function TEST (line 8) | TEST(Parser, SingleElement) {
function TEST (line 20) | TEST(Parser, DefaultElementNS) {
function TEST (line 38) | TEST(Parser, UnboundPrefix) {
function TEST (line 51) | TEST(Parser, DuplicateAttribute) {
function TEST (line 64) | TEST(Parser, UnboundAttrPrefix) {
function TEST (line 83) | TEST(Parser, DuplicateAttrPrefix) {
function TEST (line 97) | TEST(Parser, Xmlns) {
function TEST (line 109) | TEST(Parser, ChildXmlns) {
function TEST (line 152) | TEST(Parser, HandleEOF){
function TEST (line 161) | TEST(ParseOptions, Fastest) {
function TEST (line 182) | TEST(ParseOptions, OpenOnly) {
function TEST (line 194) | TEST(ParseOptions, ParseOne) {
function TEST (line 231) | TEST(ParseOptions, OpenOnlyFastest) {
function TEST (line 268) | TEST(Parser_Emoji, Single) {
function TEST (line 275) | TEST(Parser_Emoji, SingleUni) {
function TEST (line 282) | TEST(Parser_Emoji, SingleEmoji) {
function TEST (line 290) | TEST(Parser_Emoji, SingleEmojiReuse) {
FILE: test/src/perf.cpp
function TEST (line 21) | TEST(Perf, Parse) {
function TEST (line 45) | TEST(Perf, Parse2) {
function TEST (line 70) | TEST(Perf, PrintClean) {
function TEST (line 96) | TEST(Perf, PrintDirty) {
FILE: test/src/round-trips.cpp
function print (line 10) | auto print(flxml::xml_document<> & doc) {
function TEST (line 17) | TEST(RoundTrip, Simple) {
function TEST (line 29) | TEST(RoundTrip, SimpleMod) {
function TEST (line 71) | TEST(RoundTrip, SimpleApos) {
function TEST (line 88) | TEST(RoundTrip, SimpleApos2) {
function TEST (line 107) | TEST(RoundTrip, SimpleLtBody) {
function TEST (line 127) | TEST(RoundTrip, MutateBody) {
function TEST (line 144) | TEST(RoundTrip, Everything) {
function TEST (line 162) | TEST(RoundTrip, EverythingStream) {
FILE: test/src/xpath.cpp
function TEST (line 8) | TEST(XPath, parse) {
function TEST (line 17) | TEST(XPath, parse2) {
function TEST (line 26) | TEST(XPath, parse1) {
function TEST (line 35) | TEST(XPath, parse3) {
function TEST (line 46) | TEST(XPath, parse4) {
function TEST (line 56) | TEST(XPath, parse_attr) {
function TEST (line 67) | TEST(XPath, parse_text) {
function TEST (line 78) | TEST(XPathFirst, simple_all) {
function TEST (line 89) | TEST(XPathFirst, simple_any) {
function TEST (line 100) | TEST(XPathFirst, simple_sub) {
function TEST (line 111) | TEST(XPathFirst, simple_attr) {
function TEST (line 123) | TEST(XPathFirst, simple_text) {
function TEST (line 133) | TEST(XPathNS, simple_text) {
function TEST (line 143) | TEST(XPathNS, xmlns_text) {
function TEST (line 157) | TEST(XPathNS, xmlns_both) {
function TEST (line 171) | TEST(XPathNS, xmlns_text_miss) {
Condensed preview — 27 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (383K chars).
[
{
"path": ".github/workflows/gtest.yml",
"chars": 2378,
"preview": "name: gtest\n\non:\n - push\n - pull_request\n - release\n\njobs:\n gtest:\n runs-on: ubuntu-latest\n steps:\n - nam"
},
{
"path": ".gitignore",
"chars": 34,
"preview": "/cmake-build-debug/\n/gtest-build/\n"
},
{
"path": "README.md",
"chars": 5371,
"preview": "# FLXML\n## Or -- RapidXML, Dave's Version\n\nHey! This is a fork of RapidXML, an ancient C++ library for parsing XML quick"
},
{
"path": "conanfile.py",
"chars": 490,
"preview": "from conan import ConanFile\nfrom conan.tools.files import copy\n\nclass FLXML(ConanFile):\n name = \"flxml\"\n exports_s"
},
{
"path": "include/flxml/generator.h",
"chars": 1938,
"preview": "//\n// Created by dave on 29/07/2024.\n//\n\n#ifndef RAPIDXML_RAPIDXML_GENERATOR_HPP\n#define RAPIDXML_RAPIDXML_GENERATOR_HPP"
},
{
"path": "include/flxml/iterators.h",
"chars": 10765,
"preview": "#ifndef RAPIDXML_ITERATORS_HPP_INCLUDED\n#define RAPIDXML_ITERATORS_HPP_INCLUDED\n\n// Copyright (C) 2006, 2009 Marcin Kali"
},
{
"path": "include/flxml/predicates.h",
"chars": 14258,
"preview": "//\n// Created by dave on 29/07/2024.\n//\n\n#ifndef RAPIDXML_RAPIDXML_PREDICATES_HPP\n#define RAPIDXML_RAPIDXML_PREDICATES_H"
},
{
"path": "include/flxml/print.h",
"chars": 18129,
"preview": "#ifndef RAPIDXML_PRINT_HPP_INCLUDED\n#define RAPIDXML_PRINT_HPP_INCLUDED\n\n// Copyright (C) 2006, 2009 Marcin Kalicinski\n/"
},
{
"path": "include/flxml/tables.h",
"chars": 32879,
"preview": "//\n// Created by dwd on 9/7/24.\n//\n\n#ifndef RAPIDXML_RAPIDXML_TABLES_HPP\n#define RAPIDXML_RAPIDXML_TABLES_HPP\n\n#include "
},
{
"path": "include/flxml/utils.h",
"chars": 3409,
"preview": "#ifndef RAPIDXML_UTILS_HPP_INCLUDED\n#define RAPIDXML_UTILS_HPP_INCLUDED\n\n// Copyright (C) 2006, 2009 Marcin Kalicinski\n/"
},
{
"path": "include/flxml/wrappers.h",
"chars": 5483,
"preview": "//\n// Created by dave on 10/07/2024.\n//\n\n#ifndef RAPIDXML_RAPIDXML_WRAPPERS_HPP\n#define RAPIDXML_RAPIDXML_WRAPPERS_HPP\n\n"
},
{
"path": "include/flxml.h",
"chars": 112617,
"preview": "#ifndef RAPIDXML_HPP_INCLUDED\n#define RAPIDXML_HPP_INCLUDED\n\n// Copyright (C) 2006, 2009 Marcin Kalicinski\n// Version 1."
},
{
"path": "include/rapidxml.hpp",
"chars": 151,
"preview": "//\n// Created by dwd on 4/19/25.\n//\n\n#ifndef RAPIDXML_HPP\n#define RAPIDXML_HPP\n\n#include <flxml.h>\n\nnamespace rapidxml ="
},
{
"path": "include/rapidxml_print.hpp",
"chars": 175,
"preview": "//\n// Created by dwd on 4/19/25.\n//\n\n#ifndef RAPIDXML_PRINT_HPP\n#define RAPIDXML_PRINT_HPP\n\n#include <flxml/print.h>\n\nna"
},
{
"path": "license.txt",
"chars": 2804,
"preview": "Use of this software is granted under one of the following two licenses,\r\nto be chosen freely by the user.\r\n\r\n1. Boost S"
},
{
"path": "manual.html",
"chars": 113504,
"preview": "<html><head><style type=\"text/css\">\r\n\r\n body\r\n {\r\n font-family: sans-serif;\r\n font-s"
},
{
"path": "test/CMakeLists.txt",
"chars": 1614,
"preview": "cmake_minimum_required(VERSION 3.24)\nproject(rapidxml)\n\n# Include the Conan toolchain\ninclude(${CMAKE_CURRENT_SOURCE_DIR"
},
{
"path": "test/conanfile.py",
"chars": 867,
"preview": "from conan import ConanFile\nfrom conan.tools.cmake import CMakeToolchain, CMake, CMakeDeps\n\nclass FLXML(ConanFile):\n "
},
{
"path": "test/sonar-project.properties",
"chars": 602,
"preview": "sonar.projectKey=dwd-github_rapidxml\nsonar.organization=dwd-github\n\n# This is the name and version displayed in the Sona"
},
{
"path": "test/src/iterators.cpp",
"chars": 4011,
"preview": "//\n// Created by dave on 10/07/2024.\n//\n\n#include <gtest/gtest.h>\n#include <list>\n#include <algorithm>\n#include <ranges>"
},
{
"path": "test/src/low-level-parse.cpp",
"chars": 2716,
"preview": "//\n// Created by dave on 05/07/2024.\n//\n\n#include <gtest/gtest.h>\n#include <flxml.h>\n\nTEST(Constants, Empty) {\n flxml"
},
{
"path": "test/src/main.cc",
"chars": 4978,
"preview": "//\n// Created by dave on 30/07/2024.\n//\n\n#include \"gtest/gtest.h\"\n#ifdef DWD_GTEST_SENTRY\n#include <sentry.h>\n\nclass Eve"
},
{
"path": "test/src/manipulations.cpp",
"chars": 3036,
"preview": "//\n// Created by dwd on 01/07/24.\n//\n\n#include <gtest/gtest.h>\n\n#include <flxml.h>\n#include <flxml/print.h>\n\nnamespace {"
},
{
"path": "test/src/parse-simple.cpp",
"chars": 10577,
"preview": "//\n// Created by dwd on 1/13/24.\n//\n\n#include <gtest/gtest.h>\n#include <flxml.h>\n\nTEST(Parser, SingleElement) {\n char"
},
{
"path": "test/src/perf.cpp",
"chars": 3640,
"preview": "//\n// Created by dave on 07/07/2024.\n//\n\n#include <flxml.h>\n#include <flxml/utils.h>\n\n#include <gtest/gtest.h>\n#include "
},
{
"path": "test/src/round-trips.cpp",
"chars": 7240,
"preview": "//\n// Created by dave on 04/07/2024.\n//\n\n#include <gtest/gtest.h>\n#include <flxml.h>\n#include <flxml/print.h>\n\nnamespace"
},
{
"path": "test/src/xpath.cpp",
"chars": 5900,
"preview": "//\n// Created by dave on 29/07/2024.\n//\n\n#include <gtest/gtest.h>\n#include <flxml/predicates.h>\n\nTEST(XPath, parse) {\n "
}
]
About this extraction
This page contains the full source code of the dwd/rapidxml GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 27 files (360.9 KB), approximately 97.6k tokens, and a symbol index with 190 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.