parsnip.h

Go to the documentation of this file.

 
 
#pragma once
 
#include <config.h>
 
#include <exception>
#include <limits>
#include <memory>
#include <istream>
#include <ostream>
#include <iostream>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <vector>
#include <set>
#include <functional>
#ifdef PARSNIP_DICTIONARY_SORTED
#include <map>
#endif
 
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <cstring>
 
namespace Parsnip {
 
    class Exception : public std::exception {
    private:
        std::string location; 
    protected:
        std::string reason; 
 
 
    public:
        virtual const char *what() const noexcept override {
            return reason.c_str();
        };
        inline const char *where () const noexcept {
            return location.empty() ? nullptr : location.c_str();
        }
        void addBacktraceLocation (const std::string &);
    protected:
        Exception (const std::string &why) : reason (why){};
 
        Exception (const std::string &why, const std::string &detail) : reason (why) {
            reason += ": ";
            reason += detail;
        };
    };
 
    class DataRangeError : public Exception {
    public:
        inline DataRangeError() : Exception ("Value out of representable range"){};
        inline DataRangeError (const std::string &value) : Exception ("Value exceeds datatype range", value){};
    };
 
    class Data {
        friend class IncorrectDataType;
        friend class SchemaBase;
        friend class DictionarySchema;
        friend class ConjunctionSchema;
 
    public:
        static const struct dictionary_t {
        } Dictionary;  
        static const struct list_t {
        } List;                             
        static constexpr bool Flexible{false};  
        static constexpr int NoIndent{-32767};  
 
        using StringType = std::string;  // As long as everything is UTF-8 encoded anyway...
        using ListType = std::vector<Data>;
 
        enum class Type {
            Null,            
            Dictionary,      
            List,
            String,          
            FlexibleString,  
            Integer,         
            Real,
            Boolean
        };
 
    protected:
#ifdef PARSNIP_DICTIONARY_SORTED
        using DictionaryType = std::map<std::string, Data>;
#else
        using DictionaryType = std::unordered_map<std::string, Data>;
#endif
 
        Type datatype = Type::Null; 
        union data_t {
            DictionaryType *dictionary;
            ListType *list;
            StringType *str;
            long integer;
            double real;
            bool boolean;
        } data;
 
        void release();
 
    private:
        Data (Type kind);
        void mandateType (Type type) const;
 
        inline void loadDictionary(){};
 
        template <typename... More>
        void loadDictionary (const char *name, Data &&value, More &&... remainder) {
            (*(data.dictionary))[name] = std::move (value);
            loadDictionary (std::forward<More> (remainder)...);
        }
 
        inline void loadArray(){};
 
        template <typename... More>
        void loadArray (Data &&value, More... remainder) {
            data.list->push_back (std::move (value));
            loadArray (std::forward<More> (remainder)...);
        }
 
    public:
        using size_type = ListType::size_type;
 
        struct iterator : std::iterator<std::forward_iterator_tag, Data> {
            const ListType *list = nullptr;
            ListType::size_type position = 0;
            iterator (const Data *l);
            iterator (const Data *l, size_type pos);
            const Data &operator*() const noexcept;
            iterator &operator++() noexcept;
            iterator operator++ (int) noexcept;
            bool operator!= (const iterator &compare) const noexcept;
        };
 
        Data (std::nullptr_t null = nullptr) {
            // Do nothing
        }
 
        Data (const char *value, bool type_certainty = true) {
            data.str = new StringType (value);
            datatype = type_certainty ? Type::String : Type::FlexibleString;
        }
 
        inline Data (const std::string &value, bool type_certainty = true) {
            data.str = new StringType (value);
            datatype = type_certainty ? Type::String : Type::FlexibleString;
        }
 
        template <typename T,
                  typename
                  = typename std::enable_if<!std::is_same<T, bool>::value && std::is_integral<T>::value, int>::type>
        inline Data (T value) noexcept {
            datatype = Type::Integer;
            data.integer = value;
        }
 
        inline Data (double value) noexcept {
            datatype = Type::Real;
            data.real = value;
        }
 
        inline Data (bool value) noexcept {
            datatype = Type::Boolean;
            data.boolean = value;
        }
 
        template <typename... T>
        Data (dictionary_t, T... params) : Data (Type::Dictionary) {
            loadDictionary (std::forward<T> (params)...);
        }
 
        template <typename... T>
        Data (list_t, T... params) : Data (Type::List) {
            loadArray (std::forward<T> (params)...);
        }
 
        inline Data (Data &&from) noexcept {
            datatype = from.datatype;
            data = from.data;
            from.datatype = Type::Null;
        }
 
        inline Data &operator= (Data &&from) noexcept {
            if (this != &from) {
                release();
                datatype = from.datatype;
                data = from.data;
                from.datatype = Type::Null;
            }
            return *this;
        }
 
        // Copy constructor & assignment
        Data (const Data &from);
        Data &operator= (const Data &from);
 
        inline ~Data() {
            release();
        }
 
        bool operator== (const Data &compare) const;
        inline bool operator!= (const Data &compare) const {
            return !operator== (compare);
        }
 
        const Data &makeFlexible () const;
 
        inline bool isNull (void) const noexcept {
            return (datatype == Type::Null);
        }
 
        // Retrieve values by asking for type directly.
        const StringType &asString() const;
        long asLong (int base = 0) const;
        int asInteger (int base = 0) const;
        double asDouble() const;
        bool asBoolean() const;
        ListType asList() const;
 
        template <typename DataType,
                  typename = typename std::enable_if<std::is_same<DataType, std::string>::value>::type>
        inline const std::string &as() const {
            return asString();
        }
 
        template <typename DataType,
                  typename
                  = typename std::enable_if<!std::is_same<DataType, bool>::value && std::is_integral<DataType>::value>::type>
        inline DataType as (int base = 0) const {
            long result = asLong (base);
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsign-compare"
            if (result < std::numeric_limits<DataType>::lowest() || result > std::numeric_limits<DataType>::max()) {
#pragma GCC diagnostic pop
                throw DataRangeError (std::to_string (result));
            }
            return result;
        }
 
        template <typename DataType, typename = typename std::enable_if<std::is_floating_point<DataType>::value>::type>
        inline DataType as() const {
            double result = asDouble();
            if (result < std::numeric_limits<DataType>::lowest() || result > std::numeric_limits<DataType>::max()) {
                throw DataRangeError (std::to_string (result));
            }
            return result;
        }
 
        template <typename DataType, typename = typename std::enable_if<std::is_same<DataType, bool>::value>::type>
        inline bool as() const {
            return asBoolean();
        }
 
        template <typename DataType, typename = typename std::enable_if<std::is_same<DataType, Data>::value>::type>
        inline const Data &as() const {
            return *this;
        }
        
        template <typename Container,
                  typename = typename std::enable_if<std::is_class<Container>::value && !std::is_same<Container, Data>::value
                                                     && !std::is_same<Container, std::string>::value>::type>
        inline Container as(std::nullptr_t null = nullptr) const {
            mandateType (Type::List);
            Container result;
            for (const auto &item : *(data.list)) {
                result.push_back (item.as <typename Container::value_type>());
            }
            return result;
        }
        
        template <typename Datatype>
        inline Datatype getOr (const std::string &name, const Datatype &defvalue) const {
            return (contains (name) ? (*this)[name].as<Datatype>() : defvalue);
        }
        
        inline StringType getOr (const std::string &name, const char *defvalue) const {
            return (contains (name) ? (*this)[name].asString() : StringType (defvalue));
        }
 
        inline Data getOr (const std::string &name, const Data &defvalue) const {
            return (contains (name) ? (*this)[name] : defvalue);
        }
        
        template <typename Datatype>
        inline std::vector<Datatype> toList () const {
            if (datatype == Type::List) {
                return as<std::vector <Datatype>> ();
            } else if (datatype == Type::Dictionary) {
                mandateType (Type::List);
            }
            std::vector<Datatype> results;
            results.push_back (as <Datatype>());
            return results;
        }
 
        // Dictionary accessors
        const Data &operator[] (const std::string &word) const;
        Data &operator[] (const std::string &word);
        bool contains (const std::string &word) const;
        void remove (const std::string &word);
        inline const Data &at (const std::string &word) const {
            return (*this) [word];
        }
 
        template <typename DataType, typename = typename std::enable_if<std::is_trivial<DataType>::value>::type>
        void foreach (std::function<void (const std::string &, DataType)> func) const {
            mandateType (Type::Dictionary);
            for (const auto &it : *(data.dictionary)) {
                func (it.first, it.second.as<DataType>());
            }
        }
 
        template <typename DataType>
        void foreach (std::function<void (const std::string &, const DataType &)> func) const {
            mandateType (Type::Dictionary);
            for (const auto &it : *(data.dictionary)) {
                func (it.first, it.second.as<DataType>());
            }
        }
 
        // List accessors
        const Data &operator[] (size_type index) const;
        Data &operator[] (size_type index);
        void remove (size_type index);
        void push_back (const Data &value);
        void push_back (Data &&value);
        size_type size() const;
 
        inline bool empty () const {
            return (datatype == Type::Null ||
                    (datatype == Type::List && size() == 0) ||
                    (datatype == Type::Dictionary && (*data.dictionary).empty()));
 
        }
 
        template <typename DataType, typename = typename std::enable_if<std::is_trivial<Type>::value>::type>
        void foreach (std::function<void (const DataType)> func) const {
            mandateType (Type::List);
            for (const auto &it : *(data.list)) {
                func (it.as<DataType>());
            }
        }
 
        template <typename DataType>
        void foreach (std::function<void (const DataType &)> func) const {
            mandateType (Type::List);
            for (const auto &it : *(data.list)) {
                func (it.as<DataType>());
            }
        }
 
        inline Data::iterator begin() const {
            return iterator{this};
        }
 
        inline Data::iterator end() const {
            iterator it{this, size()};
            return it;
        }
 
        static const char *type_name (Type ty);
 
        template <typename T = Data>
        static Data make_dictionary (std::initializer_list <std::pair <const char *, const T>> initial_data) {
            Data data (Type::Dictionary);
            for (auto &it : initial_data) {
                data [it.first] = it.second;
            }
            return data;
        }
 
        template <typename... T>
        static Data make_list(T&&... params) {
            Data data (Type::List);
            data.loadArray (std::forward<T> (params)...);
            return data;
        }
 
    public:
        std::string toJson (int indent = NoIndent) const;
        std::ostream &toJson (std::ostream &target, int indent = NoIndent, bool suppress = false) const;
        std::ostream &dumpJson (const std::string &intro, std::ostream &target = std::clog) const;
    };
 
    Data parse_json (std::istream &from, bool check_termination = true);
    Data parse_json (const std::string &from);
 
 
#ifdef PARSNIP_JSON_TRACK_POSITION
    class StreamPositionCounter;
    using InputStream = StreamPositionCounter;
#else
    using InputStream = std::istream;
#endif
 
    class DataFormatError : public Exception {
#ifdef PARSNIP_JSON_TRACK_POSITION
    public:
        struct Location {
            unsigned line = 0;
            unsigned character = 0;
            Location () = default;
            Location (const Location &) = default;
            Location &operator =(const Location &) = default;
            Location (unsigned l, unsigned c): line (l), character (c) {};
        };
    private:
        const Location error_location {};
    public:
        inline Location where() const {
            return error_location;
        }
#endif
    public:
        inline DataFormatError (const std::string &detail): Exception ("Invalid data format", detail) {};
        DataFormatError (const InputStream &loc, const std::string &detail);
    };
 
    class NoSuchKey : public Exception {
    public:
        inline NoSuchKey (const std::string &key) : Exception ("No such key", key){};
    };
 
    class IncorrectDataType : public Exception {
    public:
        IncorrectDataType (Data::Type expected, Data::Type actual) : Exception ("Incorrect data type", "Expected: ") {
            reason += Data::type_name (expected);
            reason += ", Actual: ";
            reason += Data::type_name (actual);
        }
    };
 
    inline std::ostream &operator<< (std::ostream &out, const Parsnip::Data &data) {
        data.toJson (out);
        return out;
    }
 
    class IncorrectListSize : public Exception {
    public:
        inline IncorrectListSize () : Exception ("Wrong list size") {};
        inline IncorrectListSize (int size, int min, int max) :
        Exception ("wrong list size", std::to_string (size) + " (expected " + std::to_string (min) + "-" + std::to_string (max) + "") {};
    };
 
    class InvalidKey : public Exception {
    public:
        inline InvalidKey (const std::string &key) : Exception ("invalid key", key) {};
    };
 
    class SchemaConflict : public Exception {
    public:
        inline SchemaConflict (const std::string &reason) : Exception ("schema conflict", reason) {};
        SchemaConflict (const std::string &reason, const class SchemaBase &from, const class SchemaBase &into);
    };
 
    struct SchemaBaseDeleter {
        void operator () (class SchemaBase *free_me);
    };
 
    class SchemaBaseRef: public std::unique_ptr<class SchemaBase, SchemaBaseDeleter> {
    public:
        using std::unique_ptr<class SchemaBase, SchemaBaseDeleter>::unique_ptr;
        SchemaBaseRef() = default;
        SchemaBaseRef (const SchemaBaseRef &);
        SchemaBaseRef &operator =(const SchemaBaseRef &);
    };
 
    using SchemaRef = std::shared_ptr <class Schema>;
 
    class Schema {
        friend class OptionSchema;
    public:
        using OptionSchemas = std::unordered_map <class OptionParser *, SchemaRef>;
        using Dependencies = std::set <std::string>;
        static const Dependencies NoDependencies;
 
    private:
        SchemaBaseRef schema;
        void integrateSchema (const int, const class DictionarySchema &);
        std::ostream &dump (std::ostream &target, int indent, bool suppress_indent) const;
 
        Schema (SchemaBase *from);
    public:
        Schema () = default;
        Schema (const class OptionParser &from, const OptionSchemas &option_schemas);
        Schema (Schema &&) = default;
        Schema &operator =(Schema &&) = default;
        Schema (const Parsnip::Data &schema_spec);
 
        void addMember (const char *name, const SchemaBase &new_schema, bool mandatory = false,
                        const Dependencies &dependencies = NoDependencies);
        void replaceMember (const char *name, const SchemaBase &new_schema);
        void removeMember (const char *name);
 
        void validate (const Data &) const;
        std::ostream &dump (const std::string &intro, std::ostream &target = std::clog) const;
    };
 
}  // namespace Parsnip