reader.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_XML_READER_H
#define PLASK__UTILS_XML_READER_H
 
#include <string>
#include <limits>
#include <boost/lexical_cast.hpp>
#include "../../optional.hpp"
#include <boost/algorithm/string.hpp>
#include <vector>
#include <set>
#include <map>
 
#include <typeinfo>
#include <typeindex>
#include <functional>
#include <type_traits>
#include <boost/any.hpp>
 
#include "exceptions.hpp"
 
//this is copy paste from expat.h, this allows to not include expat.h in header
extern "C" {
    struct XML_ParserStruct;
    typedef struct XML_ParserStruct *XML_Parser;
}
 
namespace plask {
 
class PLASK_API StringInterpreter {
 
    typedef std::function<boost::any(const std::string&)> type_parser;
 
    std::map<std::type_index, type_parser> parsers;
 
    void set() {}   //do nothing, defined for stop of set recursion and default constructor
 
public:
 
    template <typename... Functors>
    StringInterpreter(Functors... parsers) { set(parsers...); }
 
    StringInterpreter(StringInterpreter&&) = default;
    StringInterpreter(const StringInterpreter&) = default;
    StringInterpreter& operator=(StringInterpreter&&) = default;
    StringInterpreter& operator=(const StringInterpreter&) = default;
 
    template <typename RequiredType>
    RequiredType get(const std::string& str) const {
        auto i = parsers.find(std::type_index(typeid((RequiredType*)0)));
        if (i != parsers.end())
            return boost::any_cast<RequiredType>(i->second(str));
        return boost::lexical_cast<RequiredType>(boost::trim_copy(str));
    }
 
    template <typename Functor1, typename... Functors>
    void set(Functor1 parser1, Functors... rest_parsers) {
        parsers[std::type_index(typeid((typename std::result_of<Functor1(std::string)>::type*)0))] = parser1;
        set(rest_parsers...);
    }
 
    template <typename type>
    void unset() {
        parsers.erase(std::type_index(typeid((type*)0)));
    }
 
};
 
class PLASK_API XMLReader {
  public:
 
    enum NodeType {
    //        NODE_NONE = irr::io::EXN_NONE,                  //< No xml node. This is usually the node if you did not read anything yet.
            NODE_ELEMENT = 1 ,             
            NODE_ELEMENT_END = 2,          
            NODE_TEXT = 4                  
    //        NODE_COMMENT =  irr::io::EXN_COMMENT,           //< An xml comment like &lt;!-- I am a comment --&gt; or a DTD definition.
    //        NODE_CDATA =  irr::io::EXN_CDATA,               //< An xml cdata section like &lt;![CDATA[ this is some CDATA ]]&gt;
    //        NODE_UNKNOWN = irr::io::EXN_UNKNOWN             //< Unknown element
    };
 
    struct PLASK_API DataSource {
 
        virtual std::size_t read(char* buff, std::size_t buf_size) = 0;
 
        virtual ~DataSource() {}
    };
 
    struct PLASK_API StreamDataSource: public DataSource {
 
        std::unique_ptr<std::istream> input;
 
        template <typename... Args>
        StreamDataSource(Args&&... params): input(std::forward<Args>(params)...) {}
 
        std::size_t read(char* buff, std::size_t buf_size) override;
 
    };
 
    struct PLASK_API CFileDataSource: public DataSource {
 
        FILE* desc;
 
        CFileDataSource(FILE* desc): desc(desc) {}
 
        ~CFileDataSource() { fclose(desc); }
 
        std::size_t read(char* buff, std::size_t buf_size) override;
 
    };
 
 
    template <typename EnumT>
    struct EnumAttributeReader {
 
      protected:
 
        XMLReader& reader;
        const std::string attr_name;
        bool case_insensitive;
 
        std::map<std::string, EnumT> values;
        std::string help;
 
        EnumT parse(std::string value) {
            if (case_insensitive) boost::to_lower(value);
            auto found = values.find(value);
            if (found == values.end())
                throw XMLBadAttrException(reader, attr_name, value, "one of " + help);
            return found->second;
        }
 
      public:
 
        EnumAttributeReader(XMLReader& reader, const std::string& attr_name, bool case_sensitive=false):
            reader(reader), attr_name(attr_name), case_insensitive(!case_sensitive) {}
 
        EnumAttributeReader& value(std::string key, EnumT val, std::size_t min=std::numeric_limits<std::size_t>::max()) {
            if (case_insensitive) boost::to_lower(key);
#           ifndef NDEBUG
                if (values.find(key) != values.end()) throw XMLException(reader, "CODE ERROR: Attribute value \"" + key + "\" already defined.");
#           endif
            help += values.empty()? "\"" : ", \"";
            values[key] = val;
            if (min < key.length()) {
                std::string skey = key.substr(0, min);
#               ifndef NDEBUG
                    if (values.find(skey) != values.end()) throw  XMLException(reader, "CODE ERROR: Attribute value \"" + skey + "\" already defined.");
#               endif
                values[skey] = val;
                help += skey; help += "["; help += key.substr(min); help += "]";
            } else
                help += key;
            help += "\"";
            return *this;
        }
 
        EnumT require() {
            return parse(reader.requireAttribute(attr_name));
        }
 
        plask::optional<EnumT> get() {
            plask::optional<std::string> value = reader.getAttribute(attr_name);
            if (!value) return plask::optional<EnumT>();
            return parse(std::move(*value));
        }
 
        EnumT get(EnumT default_value) {
            plask::optional<std::string> value = reader.getAttribute(attr_name);
            if (!value) return default_value;
            return parse(std::move(*value));
        }
 
    };
 
    class PLASK_API CheckTagDuplication {
 
        std::set<std::string> namesAlreadySeen;
 
    public:
 
        void operator()(const std::string& scope, std::string name) {
            if (namesAlreadySeen.find(name) != namesAlreadySeen.end()) throw XMLDuplicatedElementException(scope, "tag <" + name + ">");
            namesAlreadySeen.insert(std::move(name));
        }
 
        void operator()(const XMLReader& scope, std::string name) {
            if (namesAlreadySeen.find(name) != namesAlreadySeen.end()) throw XMLDuplicatedElementException(scope, "tag <" + name + ">");
            namesAlreadySeen.insert(std::move(name));
        }
 
        void operator()(const XMLReader& reader) {
            this->operator ()(reader, reader.getNodeName());
        }
 
    };
 
    typedef std::function<std::string(const std::string&)> Filter;
 
  private:
 
    static void startTag(void *data, const char *element, const char **attribute);
    static void endTag(void *data, const char *element);
    static void characterData(void* data, const char *string, int string_len);
 
    std::unique_ptr<DataSource> source;
 
    template <typename RequiredType>
    RequiredType parse(const std::string& attr_str) const {
        return stringInterpreter.get<RequiredType>(attr_str);
    }
 
    template <typename RequiredType>
    RequiredType parse(const std::string& attr_str, const std::string& attr_name) const {
        try {
            return parse<RequiredType>(attr_str);
        } catch (...) {
            throw XMLBadAttrException(*this, attr_name, attr_str);
        }
    }
 
    struct State {
 
        unsigned lineNr;
 
        unsigned columnNr;
 
        std::string text;
 
        std::map<std::string, std::string> attributes;
 
        NodeType type;
 
        State(NodeType type, unsigned lineNr, unsigned columnNr, const std::string& text): lineNr(lineNr), columnNr(columnNr), text(text), type(type) {}
 
        bool hasWhiteText() {
            for (std::size_t i = 0; i < text.size(); ++i)
                if (!isspace(text[i])) return false;
            return true;
        }
    };
 
    State& appendState(NodeType type, const std::string& text);
 
    std::deque<State> states;
 
    XML_Parser parser;
 
    std::vector<std::string> path;
 
    mutable std::set<std::string> read_attributes;
 
public:
    StringInterpreter stringInterpreter;
 
    Filter attributeFilter;
 
    Filter contentFilter;
 
    void setFilters(Filter f) {
        attributeFilter = f;
        contentFilter = f;
    }
 
private:
 
    mutable bool check_if_all_attributes_were_read;
 
    bool hasCurrent() const {
        if (states.empty()) return false;
        return states.size() > 1 || states.front().type != NODE_TEXT;
    }
 
    void ensureHasCurrent() const {
        if (!hasCurrent()) throw XMLException("XML reader: no current node (missing first read() call?)");
    }
 
    const State& getCurrent() const {
        return states.front();
    }
 
    static bool strToBool(std::string str) {
        boost::algorithm::to_lower(str);
        if (str == "yes" || str == "true" || str == "1") return true;
        else if (str == "no" || str == "false" || str == "0") return false;
        else throw XMLException("\"" + str + "\" is not valid bool value.");
    }
 
    static unsigned strToUnsigned(std::string str) {
        int value = boost::lexical_cast<int>(boost::trim_copy(str));
        if (value < 0) throw XMLException("negative value given for unsigned");
        return unsigned(value);
    }
 
    bool readSome();
 
    void initParser();
 
  public:
 
    void throwException(const std::string& msg) const { throw XMLException(*this, msg); }
 
    void throwUnexpectedEndException() const { throw XMLUnexpectedEndException(*this); }
 
    template <typename... Args>
    void throwUnexpectedElementException(Args&&... args) const { throw XMLUnexpectedElementException(*this, std::forward<Args>(args)...); }
 
    NodeType ensureNodeTypeIs(int required_types, const char* new_tag_name = nullptr) const;
 
    XMLReader(std::unique_ptr<DataSource>&& source);
 
    XMLReader(std::unique_ptr<std::istream>&& istream);
 
    XMLReader(const char* file_name);
 
    XMLReader(FILE* file);
 
    /*
     * Construct XML reader to read XML from given @p input stream.
     * @param input input stream
     */
    //XMLReader(std::istream& input);
 
#if (__cplusplus >= 201103L) || defined(__GXX_EXPERIMENTAL_CXX0X__)
    XMLReader(XMLReader&& to_move);
 
    XMLReader& operator=(XMLReader&& to_move);
 
    XMLReader(const XMLReader& to_copy) = delete;
    XMLReader& operator=(const XMLReader& to_copy) = delete;
#else
  private:
    XMLReader(const XMLReader&) {}
    XMLReader& operator=(const XMLReader&) { return *this; }
  public:
#endif
 
    ~XMLReader();
 
    void swap(XMLReader& to_swap);
 
    NodeType getNodeType() const { ensureHasCurrent(); return getCurrent().type; }
 
    unsigned getLineNr() const { ensureHasCurrent(); return getCurrent().lineNr; }
 
    unsigned getColumnNr() const { ensureHasCurrent(); return getCurrent().columnNr; }
 
    bool next();
 
    /*
     * Check if node is empty, like <foo />.
     *
     * Note that empty nodes are communicate by parser two times: as NODE_ELEMENT and next as NODE_ELEMENT_END.
     * So for <foo /> parser work just like for <foo></foo> and only this method allow to check which notation was used.
     * @return if an element is an empty element, like <foo />
     */
    //bool isEmptyElement() const { return irrReader->isEmptyElement(); }
 
    const std::vector<std::string>& getPath() const { return path; }
 
    std::size_t getLevel() const { return path.size(); }
 
    std::size_t getAttributeCount() const { ensureHasCurrent(); return getCurrent().attributes.size(); }
 
    const std::map<std::string, std::string> getAttributes() const;
 
    void ignoreAttribute(const std::string& name) { getAttribute(name); }
 
    void ignoreAllAttributes() const { check_if_all_attributes_were_read = false; }
 
    bool hasAttribute(const std::string& name) const { return bool(getAttribute(name)); }
 
    template <typename EnumT>
    EnumAttributeReader<EnumT> enumAttribute(const std::string attr_name, bool case_sensitive=false) {
        return EnumAttributeReader<EnumT>(*this, attr_name, case_sensitive);
    }
 
    void removeAlienNamespaceAttr();
 
    std::string getNodeName() const;
 
    inline std::string getTagName() const { return getNodeName(); }
 
    std::string getTextContent() const;
 
    template <typename T>
    inline T getTextContent() const {
        return parse<T>(getTextContent());
    }
 
    template <typename T>
    inline T getAttribute(const std::string& name, const T& default_value) const {
        plask::optional<std::string> attr_str = getAttribute(name);
        if (attr_str) {
            return parse<T>(*attr_str, name);
        } else
            return default_value;
    }
 
    plask::optional<std::string> getAttribute(const std::string& name) const;
 
    template <typename T>
    inline plask::optional<T> getAttribute(const std::string& name) const {
        plask::optional<std::string> attr_str = getAttribute(name);
        if (!attr_str) return plask::optional<T>();
        return parse<T>(*attr_str, name);
    }
 
    std::string requireAttribute(const std::string& attr_name) const;
 
    template <typename T>
    inline T requireAttribute(const std::string& name) const {
        return parse<T>(requireAttribute(name), name);
    }
 
    void requireNext();
 
    NodeType requireNext(int required_types, const char *new_tag_name = nullptr);
 
    void requireTag();
 
    void requireTag(const std::string& name);
 
    bool requireTagOrEnd();
 
    bool requireTagOrEnd(const std::string &name);
 
    void requireTagEnd();
 
    std::string requireText();
 
    std::string requireTextInCurrentTag();
 
    template <typename T>
    inline T requireText() {
        return parse<T>(requireText());
    }
 
    template <typename T>
    inline T requireTextInCurrentTag() {
        return parse<T>(requireTextInCurrentTag());
    }
 
    bool gotoNextOnLevel(std::size_t required_level, NodeType required_type = NODE_ELEMENT);
 
    bool gotoNextTagOnCurrentLevel();
 
    void gotoEndOfCurrentTag();
 
};
 
}   // namespace plask
 
 
namespace std {
template<>
inline void swap(plask::XMLReader& a, plask::XMLReader& b) { a.swap(b); }
}   // namespace std
 
#endif // PLASK__UTILS_XML_READER_H