mConfigurationParser.h

#pragma once
 
#include <state/mConfiguration/mConfiguration.h>
 
namespace TuringSim::State::MConfiguration {
    class MConfigurationParser {
    public:
        enum class TokenKind {
            SEPARATOR,  
            LEFT,  
            RIGHT,  
            IDENT,  
            BLANK,  
            EOS,  
        };
 
        typedef std::tuple<TokenKind, size_t, size_t> Token;
 
        MConfigurationParser();
 
        MConfigurationParser(char left, char right, char separator, std::set<char> ignore, const std::string& variablePrefix);
 
        void checkInitialization() const;
 
        std::shared_ptr<const MConfiguration<std::string>> parse(const std::string& mConfiguration) const;
 
        std::string sub(const std::string& mConfiguration, const Token& token) const;
 
        Token tokenize(const std::string& mConfiguration, size_t start) const;
 
        std::vector<Token> tokenize(const std::string& mConfiguration) const;
 
        std::optional<Token> translateKeyword(const std::string& mConfiguration, const Token& token) const;
 
        void translateKeywords(const std::string& mConfiguration, std::vector<Token>& tokens) const;
 
        std::pair<bool, std::string> isVariableNode(const std::string& node) const;
 
        std::pair<std::shared_ptr<const MConfiguration<std::string>>, size_t> parse_tokens_m_func(const std::string& mConfiguration, const std::vector<Token>& tokens, size_t start) const;
 
        std::pair<std::vector<std::shared_ptr<const MConfiguration<std::string>>>, size_t> parse_tokens_m_func_list(const std::string& mConfiguration, const std::vector<Token>& tokens, size_t start) const;
 
        template<typename CharT, typename Traits>
        friend std::basic_ostream<CharT, Traits>& operator<< (std::basic_ostream<CharT, Traits>& os, const TokenKind& tokenKind) {
            using TokenKind = MConfigurationParser::TokenKind;
            switch(tokenKind) {
                case TokenKind::IDENT:
                    os << "IDENT"; break;
                case TokenKind::LEFT:
                    os << "LEFT"; break;
                case TokenKind::RIGHT:
                    os << "RIGHT"; break;
                case TokenKind::SEPARATOR:
                    os << "SEPARATOR"; break;
                case TokenKind::BLANK:
                    os << "BLANK"; break;
                case TokenKind::EOS:
                    os << "EOS";
            }
            return os;
        }
 
        template<typename CharT, typename Traits>
        friend std::basic_ostream<CharT, Traits>& operator<< (std::basic_ostream<CharT, Traits>& os, const Token& token) {
            using Utils::Debug::operator<<;
            return os << Utils::Debug::debug(token);
        }
    private:
        char left{'('};
        char right{')'};
        char separator{','};
        std::set<char> ignore{'\n', ' ', '\t'};
        std::string variablePrefix{"_"};
    };
 
    class MConfigurationParserSyntaxErrorException : public Utils::MessageException {
    public:
        MConfigurationParserSyntaxErrorException() = delete;
 
        MConfigurationParserSyntaxErrorException(std::string message, std::string toParse, const std::vector<MConfigurationParser::Token>& tokens, size_t position , std::string additionalMessage=""):
                Utils::MessageException(message),
                additionalMessage(additionalMessage),
                toParse(toParse),
                tokens(tokens),
                position(position)
        {}
 
    protected:
        virtual std::string makeFullMessage() const override {
            using Utils::Debug::operator<<;
            std::ostringstream ss;
            ss << this->msg << std::endl;
            if(!additionalMessage.empty()) {
                ss << "  " << additionalMessage << std::endl;
            }
            ss << "  toParse: " << toParse << std::endl;
            ss << "  tokens (" << tokens.size() << "): " << Utils::Debug::debug(tokens) << std::endl;
            ss << "  position: " << position << std::endl;
            if(position == tokens.size()) {
                ss << "  position at the end" << std::endl;
            }
            else if(position > tokens.size()) {
                ss << "  position after the end" << std::endl;
            }
            else {
                ss << "  token at position" << tokens[position] << std::endl;
            }
            return ss.str();
        }
 
        std::string additionalMessage;
 
        std::string toParse;
 
        std::vector<MConfigurationParser::Token> tokens;
 
        size_t position;
    };
 
    class MConfigurationParserBadInitializationException : public Utils::MessageException {
    public:
        MConfigurationParserBadInitializationException() = delete;
 
        MConfigurationParserBadInitializationException(std::string message, char left, char right, char separator, std::set<char> ignore, const std::string& variablePrefix) :
                Utils::MessageException(message),
                left(left),
                right(right),
                separator(separator),
                ignore(ignore),
                variablePrefix(variablePrefix)
        {}
 
        virtual std::string makeFullMessage() const override {
            using Utils::Debug::operator<<;
            std::ostringstream ss;
            ss << this->msg << std::endl;
            ss << "  left: " << left << std::endl;
            ss << "  right: " << right << std::endl;
            ss << "  separator: " << separator << std::endl;
            ss << "  ignore: " << Utils::Debug::debug(ignore) << std::endl;
            ss << "  variablePrefix: " << variablePrefix << std::endl;
            return ss.str();
        }
 
    protected:
        char left;
 
        char right;
 
        char separator;
 
        std::set<char> ignore;
 
        std::string variablePrefix;
    };
}