parsnip_command.h

Go to the documentation of this file.

 
 
#pragma once
 
#include <string>
#include <memory>
#include <vector>
#include <unordered_map>
#include <exception>
#include <functional>
 
#include "parsnip.h"
 
namespace Parsnip {
    class NumberOutOfRange : public Exception {
    public:
        inline NumberOutOfRange() : Exception ("Value out of range"){};
        inline NumberOutOfRange (const std::string &value) : Exception ("Value out of range", value){};
    };
 
    class NotNumeric : public Exception {
    public:
        inline NotNumeric() : Exception ("Not a number"){};
        inline NotNumeric (const std::string &value) : Exception ("Not a number", value){};
    };
 
    class InvalidValue : public Exception {
    public:
        inline InvalidValue() : Exception ("Invalid value"){};
        inline InvalidValue (const std::string &value) : Exception ("Invalid value", value){};
    };
 
    class IncompleteCommand : public Exception {
    public:
        inline IncompleteCommand() : Exception ("Incomplete command"){};
        inline IncompleteCommand (const std::string &value) : Exception ("Incomplete command", value){};
    };
 
    class RunOnCommand : public Exception {
    public:
        inline RunOnCommand() : Exception ("Run-on command"){};
        inline RunOnCommand (const std::string &value) : Exception ("Run-on command", value){};
    };
    
    class DuplicateOption : public Exception {
    public:
        inline DuplicateOption() : Exception ("Option respecified: "){};
        inline DuplicateOption (const std::string &value) : Exception ("Option respecified", value){};
    };
 
    class NoSchemaDefined : public Exception {
    public:
        inline NoSchemaDefined() : Exception ("No Schema defined: "){};
        inline NoSchemaDefined (std::string command) : Exception ("No schema defined", command){};
        inline NoSchemaDefined (const int command) : Exception ("No schema defined", std::to_string (command)){};
    };
 
    extern const std::string EmptyString;
 
    struct EvaluatorDeleter {
        void operator() (class Evaluator *free_me);
    };
    using EvaluatorRef = std::unique_ptr<class Evaluator, EvaluatorDeleter>;
 
    class OptionParser {
        friend class OptionEvaluator;
        friend class Schema;
    public:
        EvaluatorRef evaluator;
 
    public:
        // Structure for defining new option patterns.
        using Definitions = std::vector<const char *>;
 
        OptionParser() = default;
        OptionParser (const Definitions &defs, class Parser * = nullptr);
        void addOptions (const Definitions &defs, class Parser * = nullptr);
        bool operator== (const OptionParser &) const;
    };
    using OptionParserRef = std::shared_ptr<OptionParser>;
 
    class Parser {
        friend class OptionEvaluator;
        friend class SchemaSet;
    private:
        EvaluatorRef evaluator;
        using OptionParsers = std::unordered_map<std::string, OptionParserRef>;
        OptionParsers option_parsers;
 
    public:
        using CommandId = int;
        using StringType = std::string;
 
        // Structure for defining new parser patterns.
        struct Definition {
            CommandId command_id;
            const char *statement;
        };
        using Definitions = std::vector<Definition>;
 
        // Structure for evaluation results.
        struct Result {
            CommandId command_id;
            Parsnip::Data parameters{Parsnip::Data::Dictionary};
        };
 
        Parser() = default;
        Parser (const Definitions &defs);
        virtual ~Parser() = default;
        void addOptionParser (const std::string &name, const OptionParserRef &add);
        void addStatements (const Definitions &defs);
        Result evaluate (const StringType &command) const;
        bool operator== (const Parser &) const;
        inline bool operator!= (const Parser &other) const {
            return !(*this == other);
        }
    };
    using ParserRef = std::shared_ptr<Parser>;
 
    template <typename ReturnType, typename ContextType>
    class Interpreter {
    public:
        virtual ReturnType interpret (Parser::CommandId command_id, const Parsnip::Data &parameters, ContextType context) = 0;
    };
    
    // A parser that includes dispatching capabilities.
    template <typename DispatchReturnType, typename DispatchContextType>
    class Dispatcher {
    protected:
        const ParserRef parser;
    public:
        using ReturnType = DispatchReturnType;
        using ContextType = DispatchContextType;
        using ExecutorType = std::function <ReturnType (Parser::CommandId, const Parsnip::Data &, ContextType)>;
    private:
        std::unordered_map <Parser::CommandId, ExecutorType> handlers;
#ifndef NDEBUG
        int parser_number = 0;
        std::unordered_map <Parser::CommandId, int> mapping_check;
#endif
    public:
        Dispatcher (const ParserRef &parser);
        void addHandler (const Parser::Definitions &defs, const ExecutorType &handler);
        inline void addHandler (const Parser::Definitions &defs, Interpreter<DispatchReturnType, DispatchContextType> *interpreter);
        void addStatements (const Parser::Definitions &defs, ExecutorType handler);
        ReturnType operator () (Parser::CommandId command_id, const Parsnip::Data &parameters, DispatchContextType context) const;
        ReturnType operator () (Parser::StringType command, ContextType context) const;
    };
 
    class SchemaSet {
    public:
        using CommandId = int;
        using CommandSchemas = std::unordered_map <CommandId, SchemaBaseRef>;
        using OptionSchemas = Schema::OptionSchemas;
        using Dependencies = Schema::Dependencies;
    private:
        CommandSchemas schemas;
        void integrateSchema (const int, const class DictionarySchema &);
        SchemaBaseRef &getSchemaForCommand (CommandId command_id);
        const SchemaBaseRef &getSchemaForCommand (CommandId command_id) const;
 
    public:
        OptionSchemas option_schemas;
    public:
        SchemaSet (const class Parser &from);
        void validate (const CommandId, const Data &) const;
        std::ostream &dump (const std::string &intro, const CommandId command_id, std::ostream &target = std::clog) const;
 
        void addMember (const CommandId, const char *name, const SchemaBase &schema, bool mandatory = false,
                        const Dependencies &dependencies = Schema::NoDependencies);
        void addMember (const char *name, const SchemaBase &schema, bool mandatory = false,
                        const Dependencies &dependencies = Schema::NoDependencies);
        void replaceMember (const CommandId, const char *name, const SchemaBase &schema);
        void removeMember (const CommandId, const char *name);
    };
    using SchemaSetRef = std::shared_ptr <SchemaSet>;
 
 
    /*
     *
     *              TEMPLATE IMPLEMENTATIONS
     *
     */
     
    /*
     *              Dispatcher
     */
 
    template <typename DispatchReturnType, typename DispatchContextType>
    Dispatcher<DispatchReturnType, DispatchContextType>::Dispatcher (const ParserRef &par)
    : parser (par) {
    }
 
    template <typename DispatchReturnType, typename DispatchContextType>
    void Dispatcher<DispatchReturnType, DispatchContextType>::addHandler (const Parser::Definitions &defs, const ExecutorType &handler) {
#ifndef NDEBUG
        parser_number++;
#endif
        for (auto &it : defs) {
#ifndef NDEBUG
            if (mapping_check [it.command_id]) {
                assert (mapping_check [it.command_id] == parser_number);
            } else {
                mapping_check [it.command_id] = parser_number;
            }
#endif
            handlers [it.command_id] = handler;
        }
    }
 
 
    template <typename DispatchReturnType, typename DispatchContextType>
    void Dispatcher<DispatchReturnType, DispatchContextType>::addHandler (const Parser::Definitions &defs,
                Interpreter <DispatchReturnType, DispatchContextType> *interpreter) {
        ExecutorType handler { std::bind (&Interpreter<DispatchReturnType, DispatchContextType>::interpret,
                               interpreter, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3) };
        addHandler (defs, handler);
    }
 
    template <typename DispatchReturnType, typename DispatchContextType>
    void Dispatcher<DispatchReturnType, DispatchContextType>::addStatements (const Parsnip::Parser::Definitions &defs, ExecutorType handler) {
        parser->addStatements (defs);
        addHandler (defs, handler);
    }
 
    template <typename DispatchReturnType, typename DispatchContextType>
    DispatchReturnType Dispatcher<DispatchReturnType, DispatchContextType>::operator () (Parser::CommandId command_id,
                                                                                         const Parsnip::Data &parameters,
                                                                                         ContextType context) const {
        return handlers.at (command_id) (command_id, parameters, context);
    }
    
    template <typename DispatchReturnType, typename DispatchContextType>
    DispatchReturnType Dispatcher<DispatchReturnType, DispatchContextType>::operator () (Parser::StringType command,
                                                                                         ContextType context) const {
        Parser::Result result = parser->evaluate (command);
        return (*this) (result.command_id, result.parameters, context);
    }
 
}  // namespace Parsnip