simplePushdownMachineTransition.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 SimplePushdownMachineTransition :
            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>);
 
        SimplePushdownMachineTransition() = default;
 
        SimplePushdownMachineTransition(const SimplePushdownMachineTransition&) = default;
 
        SimplePushdownMachineTransition(SimplePushdownMachineTransition&&) = default;
 
        SimplePushdownMachineTransition& operator=(const SimplePushdownMachineTransition&) = default;
 
        SimplePushdownMachineTransition& operator=(SimplePushdownMachineTransition&&) = default;
 
        virtual ~SimplePushdownMachineTransition() = 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).top_opt());
        }
 
        virtual std::optional<ApplyHelperType> matchFromCurrentLetter(const StateType& state, const std::optional<LetterType>& letter, const std::optional<StackSymbolType>& symbol) const {
            if(state == preState && letter && symbol && *letter == preLetter && *symbol == preSymbol) {
                return {std::monostate{}};
            }
            return {};
        }
 
#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 {
            std::get<StackType>(storage).pop();
            std::get<StackType>(storage).pushs(postSymbols);
            std::get<WordType>(storage).read();
            return postState;
        }
#pragma clang diagnostic pop
 
    private:
        StateType preState;
        LetterType preLetter;
        StackSymbolType preSymbol;
        StateType postState;
        std::vector<StackSymbolType> postSymbols;
    };
}