writer.hpp

Go to the documentation of this file.

/*
 * This file is part of PLaSK (https://plask.app) by Photonics Group at TUL
 * Copyright (c) 2022 Lodz University of Technology
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 */
#ifndef PLASK__UTILS_XMLWRITER_H
#define PLASK__UTILS_XMLWRITER_H
 
#include <string>
#include <iostream>
#include <cstdio>
 
#include "exceptions.hpp"
#include "../format.hpp"
 
namespace plask {
 
struct PLASK_API XMLWriter {
 
    struct PLASK_API Output {
 
        virtual ~Output() {}
 
        virtual void write(const char* buffer, std::size_t n) = 0;
 
        template <int n>
        void puts(const char (&str)[n]) { write(str, n-1); }
 
        virtual void put(char c) { write(&c, 1); }
 
        void newline() { put('\n'); }
 
    };
 
    class PLASK_API Element {
 
        std::string name;
 
        XMLWriter* writer;
 
        Element* parent;
 
        bool attributesStillAlowed;
 
        bool hasChildren;
 
     public:
 
        Element(XMLWriter& writer, const std::string& name);
 
        Element(XMLWriter& writer, std::string&& name);
 
        Element(Element& parent, const std::string& name);
 
        Element(Element& parent, std::string&& name);
 
        Element(const Element&) = delete;
 
        Element& operator=(const Element&) = delete;
 
        Element(Element&& to_move);
 
        Element& operator=(Element&& to_move);
 
        ~Element();
 
        std::size_t getLevel() const;
 
        Element& attr(const std::string& attr_name, const std::string& attr_value);
 
        template <typename ValueT>
        Element& attr(const std::string& attr_name, const ValueT& attr_value) {
            return attr(attr_name, str(attr_value));
        }
 
        Element& writeText(const char* str);
 
        Element& writeText(const std::string& str) { return writeText(str.c_str()); }
 
        template <class T>
        Element& writeText(const T& value) {
            return writeText(str(value));
        }
 
        Element& writeCDATA(const std::string& str);
 
        void indent ();
 
        template <typename name_t>
        Element addElement(name_t&& name) { return Element(*this, std::forward<name_t>(name)); }
 
        template <typename name_t>
        Element addTag(name_t&& name) { return Element(*this, std::forward<name_t>(name)); }
 
        Element& end();
 
        bool canAppendAttributes() const { return this->attributesStillAlowed; }
 
        bool isCurrent() const { return writer->current == this; }
 
        bool isEnded() const { return writer != 0; }
 
        const std::string& getName() const { return name; }
 
        XMLWriter* getWriter() const { return writer; }
 
        Element* getParent() const { return parent; }
 
    private:
        void writeOpening();    
 
        void writeClosing();    
 
        bool disallowAttributes(); 
 
        void ensureIsCurrent(); 
    };
 
private:
 
    Output* out;
 
    void appendStr(const std::string& s) { out->write(s.data(), s.size()); }
 
    void appendStrQuoted(const char* s);
 
    void appendStrQuoted(const std::string& s) { appendStrQuoted(s.c_str()); }
 
    Element* current;
 
    std::size_t indentation;
 
public:
 
    XMLWriter(std::ostream& out, std::size_t indentation=2);
 
    XMLWriter(const std::string& file_name, std::size_t indentation=2);
 
    XMLWriter(std::FILE* cfile, std::size_t indentation=2);
 
    XMLWriter(Output* out, std::size_t indentation=2);
 
    ~XMLWriter() { delete out; assert(current == 0); }
 
    void writeHeader() {
        out->puts("<?xml version=\"1.0\" encoding=\"utf-8\"?>");
        out->newline();
    }
 
    template <typename name_t>
    Element addElement(name_t&& name) { return Element(*this, std::forward<name_t>(name)); }
 
    template <typename name_t>
    Element addTag(name_t&& name) { return Element(*this, std::forward<name_t>(name)); }
 
    template <typename text_t>
    void writeText(text_t&& text) {
        if (!current) throw XMLWriterException("no tag is open");
        current->writeText(std::forward<text_t>(text));
    }
 
    template <typename text_t>
    void writeCDATA(text_t&& cdata) {
        if (!current) throw XMLWriterException("no tag is open");
        current->writeCDATA(std::forward<text_t>(cdata));
    }
 
    void indent () {
        if (current) current->indent();
    }
 
    Element* getCurrent() {
        return current;
    }
 
};
 
typedef XMLWriter::Element XMLElement;
 
}   // namespace plask
 
#endif // PLASK__UTILS_XMLWRITER_H