generalPushdownMachineTransition.h

#pragma once
 
#include <memory/word.h>
#include <memory/stack.h>
#include <transition/PDM/pushdownMachineTransition.h>
 
namespace TuringSim::Transition::PDM {
    template <
            typename StateType_,
            typename LetterType_,
            typename StackSymbolType_
    >
    class GeneralPushdownMachineTransition :
            public PushdownMachineTransition<StateType_, LetterType_, StackSymbolType_> {
        typedef PushdownMachineTransition<StateType_, LetterType_, StackSymbolType_> PushdownMachineTransition_;
    public:
        using typename PushdownMachineTransition_::WordType;
        using typename PushdownMachineTransition_::StackType;
        using typename PushdownMachineTransition_::StateType;
        using typename PushdownMachineTransition_::LetterType;
        using typename PushdownMachineTransition_::StorageType;
        using typename PushdownMachineTransition_::ApplyHelperType;
        using typename PushdownMachineTransition_::StackSymbolType;
 
        static_assert(std::is_same_v<StateType, StateType_>);
        static_assert(std::is_same_v<ApplyHelperType, std::monostate>);
 
        GeneralPushdownMachineTransition() = delete;
 
        GeneralPushdownMachineTransition(
                StateType preState,
                std::optional<LetterType> preLetter,
                std::vector<StackSymbolType> preSymbols,
                StateType postState,
                std::vector<StackSymbolType> postSymbols) :
                preState(preState),
                preLetter(preLetter),
                preSymbols(preSymbols),
                postState(postState),
                postSymbols(postSymbols)
        {}
 
        GeneralPushdownMachineTransition(const GeneralPushdownMachineTransition&) = default;
 
        GeneralPushdownMachineTransition(GeneralPushdownMachineTransition&&) = default;
 
        GeneralPushdownMachineTransition& operator=(const GeneralPushdownMachineTransition&) = default;
 
        GeneralPushdownMachineTransition& operator=(GeneralPushdownMachineTransition&&) = default;
 
        virtual ~GeneralPushdownMachineTransition() = default;
 
        virtual std::optional<ApplyHelperType> match(const StateType& state, const StorageType& storage) const override final {
            return this->matchFromCurrentLetter(state, std::get<WordType>(storage).front_opt(), std::get<StackType>(storage));
        }
 
        virtual std::optional<ApplyHelperType> matchFromCurrentLetter(const StateType& state, const std::optional<LetterType>& letter, const StackType& stack) const {
            if(state != preState || (!letter && preLetter) || (letter && preLetter && *letter != *preLetter)) {
                return {};
            }
 
            size_t preSymbolsSize = preSymbols.size();
            try {
                std::vector<StackSymbolType> tops = stack.tops(preSymbolsSize);
 
                if(tops != preSymbols) {
                    return {};
                }
            }
            catch(Memory::Stack::StackTooSmallException) {
                return {};
            }
            return {std::monostate{}};
        }
 
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-parameter"
 
        virtual StateType apply(const StateType& state, StorageType& storage, ApplyHelperType&& helper, bool& running) const override final {
            size_t preSymbolsSize = preSymbols.size();
            std::get<StackType>(storage).pops(preSymbolsSize);
            std::get<StackType>(storage).pushs(postSymbols);
            if(preLetter) {
                std::get<WordType>(storage).read();
            }
            return postState;
        }
#pragma clang diagnostic pop
 
        const StateType& getPreState() const noexcept {
            return preState;
        }
 
        const std::optional<LetterType>& getPreLetter() const noexcept {
            return preLetter;
        }
 
        const std::vector<StackSymbolType>& getPreSymbols() const noexcept {
            return preSymbols;
        }
 
        size_t getPreSymbolsSize() const noexcept {
            return preSymbols.size();
        }
 
    private:
        StateType preState;
        std::optional<LetterType> preLetter;
        std::vector<StackSymbolType> preSymbols;
        StateType postState;
        std::vector<StackSymbolType> postSymbols;
    };
}