parsnip_evaluate.h

Go to the documentation of this file.

 
 
#include <vector>
#include <regex>
 
#include "parsnip_command.h"
#include "parsnip_schema.h"
 
namespace Parsnip {
    inline void parser_assert (bool requirement, const char *explanation) {
        if (!requirement) {
            throw std::runtime_error (explanation);
        }
    }
 
    inline void parser_assert (bool requirement, const char *explanation, const std::string &detail) {
        if (!requirement) {
            throw std::runtime_error (std::string (explanation) + ": " + detail);
        }
    }
 
    class Evaluator {
        friend class ValueEvaluator;
        friend class KeywordEvaluator;
        friend class RemainingValuesEvaluator;
        friend class RemainderEvaluator;
        friend class OptionEvaluator;
        friend class OptionParser;
        friend class Schema;
        friend class SchemaSet;
 
    public:
        using StringType = std::string;
        using CommandId = int;
 
    private:
        static const CommandId NoCommand = -1;
        static const CommandId EndOfOption = -2;
 
    protected:
        CommandId command_id{NoCommand};
        std::string name;
 
        Evaluator() = default;
 
    public:
        Evaluator (Evaluator *original);
        virtual ~Evaluator() = default;
 
    protected:
        static void set_name (EvaluatorRef &target, const std::string &name);
        void setCommandId (CommandId id);
 
        virtual Evaluator *getNextEvaluator (const StringType &token) const = 0;
 
        virtual Parsnip::Data evaluateToken (class ArgvCursor *cursor) const = 0;
 
        virtual void convertToOptionEvaluator() = 0;
        
        virtual void constructSchema (const DictionarySchema &schema,
                                      const Schema::OptionSchemas &option_schemas,
                                      const SchemaIntegratorCallback &integrator) const = 0;
 
    public:
        static void construct (EvaluatorRef &evaluator,
                               const ArgvCursor &cursor,
                               CommandId id,
                               Parser *parent_parser);
        int evaluate (ArgvCursor *cursor, Parsnip::Data &result_dict);
        virtual bool operator== (const Evaluator &) const;
        inline bool operator!= (const Evaluator &other) const {
            return !(*this == other);
        }
    };
 
    template <class DesiredEvaluator>
    static inline DesiredEvaluator *uptype_construct (EvaluatorRef &parser, bool *existed = nullptr) {
        DesiredEvaluator *possess = dynamic_cast<DesiredEvaluator *> (parser.get());
        if (existed) {
            // If not null, set existed to indicate if object was already of required type.
            *existed = (possess != nullptr);
        }
        if (!possess) {
            possess = new DesiredEvaluator (parser.get());
            parser.reset (possess);
        }
        return possess;
    }
 
    class TerminatorEvaluator : public Evaluator {
        virtual Evaluator *getNextEvaluator (const StringType &value) const override;
        virtual Parsnip::Data evaluateToken (ArgvCursor *cursor) const override;
        virtual void convertToOptionEvaluator() override;
        virtual void constructSchema (const DictionarySchema &scheme,
                                      const Schema::OptionSchemas &option_schemas,
                                      const SchemaIntegratorCallback &integrator) const override;
    };
 
    class EndOfOptionEvaluator : public Evaluator {
        virtual Evaluator *getNextEvaluator (const StringType &value) const override;
        virtual Parsnip::Data evaluateToken (ArgvCursor *cursor) const override;
        virtual void convertToOptionEvaluator() override;
        virtual void constructSchema (const DictionarySchema &scheme,
                                      const Schema::OptionSchemas &option_schemas,
                                      const SchemaIntegratorCallback &integrator) const override;
 
    public:
        using Evaluator::Evaluator;
    };
 
    class ValueEvaluator : public Evaluator {
    protected:
        EvaluatorRef next_evaluator;
 
        virtual Evaluator *getNextEvaluator (const StringType &value) const override;
 
    public:
        using Evaluator::Evaluator;
        virtual bool operator== (const Evaluator &other) const override;
        virtual void convertToOptionEvaluator() override;
 
        virtual SchemaBase *getSchema() const = 0;
        virtual void constructSchema (const DictionarySchema &scheme,
                                      const Schema::OptionSchemas &option_schemas,
                                      const SchemaIntegratorCallback &integrator) const override;
 
        static void construct (EvaluatorRef &parser,
                               const ArgvCursor &cursor,
                               CommandId id,
                               Parser *parent_parser,
                               std::string name,
                               std::string keywords);
    };
 
    class StringEvaluator : public ValueEvaluator {
    public:
        using ValueEvaluator::ValueEvaluator;
        virtual Parsnip::Data evaluateToken (ArgvCursor *cursor) const override;
        virtual SchemaBase *getSchema() const override;
    };
    
    // A string evaluator that is checked by a regular expression
    class RegExEvaluator : public StringEvaluator {
        StringType expression; 
        using RegexType = std::basic_regex <StringType::value_type>;
        RegexType regex; 
    public:
        using StringEvaluator::StringEvaluator;
        virtual Parsnip::Data evaluateToken (ArgvCursor *cursor) const override;
        virtual bool operator== (const Evaluator &other) const override;
        virtual SchemaBase *getSchema() const override final;
 
        static RegExEvaluator *construct (EvaluatorRef &evaluator,
                                          const std::string &name,
                                          const StringType &expression,
                                          const bool case_blind);
    };
 
    class RawRemainderEvaluator : public StringEvaluator {
    public:
        using StringEvaluator::StringEvaluator;
        virtual Parsnip::Data evaluateToken (ArgvCursor *cursor) const override;
    };
 
    class IntegerEvaluator : public ValueEvaluator {
        long minimum;   
        long maximum;   
        int radix = 1;  
 
    public:
        using ValueEvaluator::ValueEvaluator;
        virtual Parsnip::Data evaluateToken (ArgvCursor *cursor) const override;
        virtual bool operator== (const Evaluator &other) const override;
        virtual SchemaBase *getSchema() const override final;
 
        static IntegerEvaluator *construct (EvaluatorRef &evaluator,
                                            const std::string &name,
                                            const std::string &min,
                                            const std::string &max);
    };
 
    class RealEvaluator : public ValueEvaluator {
        double minimum;  
        double maximum;  
 
    public:
        using ValueEvaluator::ValueEvaluator;
        virtual Parsnip::Data evaluateToken (ArgvCursor *cursor) const override;
        virtual bool operator== (const Evaluator &other) const override;
        virtual SchemaBase *getSchema() const override final;
 
        static RealEvaluator *construct (EvaluatorRef &parser,
                                         const std::string &name,
                                         const std::string &min,
                                         const std::string &max);
    };
 
    class KeywordEvaluator : public Evaluator {
        friend class ValueEvaluator;
        friend class OptionEvaluator;
 
        EvaluatorRef numeric_evaluator;
        std::unordered_map<StringType, EvaluatorRef> tokens;
        bool numbers_present{false};  
 
    public:
        using Evaluator::Evaluator;
 
        inline static bool is_numeric (const std::string &value) {
            return ((!value.empty() && isdigit (value[0]))
                    || (value.size() >= 2 && value[0] == '-' && isdigit (value[1])));
        }
 
        inline static std::string tolower (std::string value) {
            for (auto &ch : value) {
                ch = ::tolower (ch);
            }
            return value;
        }
 
        virtual Parsnip::Data evaluateToken (ArgvCursor *cursor) const override;
        virtual Evaluator *getNextEvaluator (const StringType &token) const override;
        virtual bool operator== (const Evaluator &other) const override;
        virtual void convertToOptionEvaluator() override;
 
        static void construct (EvaluatorRef &parser,
                               const ArgvCursor &cursor,
                               CommandId id,
                               Parser *parent_parser,
                               const std::string &name,
                               std::string keywords);
        virtual void constructSchema (const DictionarySchema &scheme,
                                      const Schema::OptionSchemas &option_schemas,
                                      const SchemaIntegratorCallback &integrator) const override;
    };
 
    class RemainderEvaluator : public Evaluator {
        friend class Evaluator;
        friend class RemainingValuesEvaluator;
        friend class ValueEvaluator;
 
    protected:
        EvaluatorRef terminating_evaluator;
 
    public:
        using Evaluator::Evaluator;
 
        virtual Evaluator *getNextEvaluator (const StringType &value) const override;
        virtual bool operator== (const Evaluator &other) const override;
        virtual void convertToOptionEvaluator() override;
    };
 
    class RemainingValuesEvaluator : public RemainderEvaluator {
        friend ValueEvaluator;
 
    public:
        using RemainderEvaluator::RemainderEvaluator;
 
        virtual Parsnip::Data evaluateToken (ArgvCursor *cursor) const override;
        virtual void constructSchema (const DictionarySchema &scheme,
                                      const Schema::OptionSchemas &option_schemas,
                                      const SchemaIntegratorCallback &integrator) const override;
    };
 
    class OptionEvaluator : public RemainderEvaluator {
        friend class OptionParser;
        OptionParserRef option_parser;
        bool regurgitate {false}; 
        bool iterate {false}; 
 
    protected:
        virtual Parsnip::Data evaluateToken (class ArgvCursor *cursor) const override;
 
    public:
        using RemainderEvaluator::RemainderEvaluator;
        virtual bool operator== (const Evaluator &) const override;
 
        static std::vector<OptionEvaluator *> construct (EvaluatorRef &evaluator,
                                                         std::string option_parser_type,
                                                         bool iterative,
                                                         const Parser *parent_parser);
        virtual void constructSchema (const DictionarySchema &scheme,
                                      const Schema::OptionSchemas &option_schemas,
                                      const SchemaIntegratorCallback &integrator) const override;
    };
 
}  // namespace Parsnip