XMLOutputStream.hh

Go to the documentation of this file.

#ifndef XMLOUTPUTSTREAM_HH
#define XMLOUTPUTSTREAM_HH
 
#include "XMLEscape.hh"
#include "ranges.hh"
#include <algorithm>
#include <array>
#include <string>
#include <string_view>
#include <vector>
 
template<typename Operations>
class XMLOutputStream
{
public:
        XMLOutputStream(Operations& ops_)
                : ops(ops_) {}
 
        void begin(std::string_view tag);
        void attribute(std::string_view name, std::string_view value);
        void data(std::string_view value);
        void end(std::string_view tag);
 
private:
        void writeSpaces(unsigned n);
        void writeChar(char c);
        void writeString(std::string_view s);
        void writeEscapedString(std::string_view s);
 
private:
        Operations& ops;
        unsigned level = 0;
        enum State {
                INDENT, // the next (begin or end) tag needs to be indented
                CLOSE,  // the begin tag still needs to be closed
                DATA,   // we got data, but no end-tag yet
        };
        State state = INDENT;
#ifdef DEBUG
        std::vector<std::string> stack;
#endif
};
 
 
template<typename Writer>
void XMLOutputStream<Writer>::begin(std::string_view tag)
{
#ifdef DEBUG
        stack.emplace_back(tag);
#endif
        ops.check(state != DATA);
        if (state == CLOSE) {
                writeString(">\n");
        }
        writeSpaces(2 * level);
        writeChar('<');
        writeString(tag);
        ++level;
        state = CLOSE;
}
 
template<typename Writer>
void XMLOutputStream<Writer>::attribute(std::string_view name, std::string_view value)
{
        ops.check(level > 0);
        ops.check(state == CLOSE);
        writeChar(' ');
        writeString(name);
        writeString("=\"");
        writeEscapedString(value);
        writeChar('"');
}
 
template<typename Writer>
void XMLOutputStream<Writer>::data(std::string_view value)
{
        ops.check(level > 0);
        ops.check(state == CLOSE);
 
        if (value.empty()) return;
 
        writeChar('>');
        writeEscapedString(value);
        state = DATA;
}
 
template<typename Writer>
void XMLOutputStream<Writer>::end(std::string_view tag)
{
#ifdef DEBUG
        ops.check(stack.size() == level);
        ops.check(!stack.empty());
        ops.check(stack.back() == tag);
        stack.pop_back();
#endif
        ops.check(level > 0);
        --level;
        if (state == CLOSE) {
                writeString("/>\n");
        } else {
                if (state == INDENT) {
                        writeSpaces(2 * level);
                }
                writeString("</");
                writeString(tag);
                writeString(">\n");
        }
        state = INDENT;
}
 
template<typename Writer>
void XMLOutputStream<Writer>::writeSpaces(unsigned n)
{
        static constexpr std::array<char, 64> spaces = {
                ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
                ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
                ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
                ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
        };
        while (n) {
                auto t = std::min(64u, n);
                ops.write(subspan(spaces, 0, t));
                n -= t;
        }
}
 
template<typename Writer>
void XMLOutputStream<Writer>::writeChar(char c)
{
        ops.write1(c);
}
 
template<typename Writer>
void XMLOutputStream<Writer>::writeString(std::string_view s)
{
        ops.write(s);
}
 
template<typename Writer>
void XMLOutputStream<Writer>::writeEscapedString(std::string_view s)
{
        XMLEscape(s, [&](std::string_view chunk) { writeString(chunk); });
}
 
#endif