pushdownMachineTransition.h

#pragma once
 
#include <memory/word.h>
#include <memory/stack.h>
#include <transition/transition.h>
 
namespace TuringSim::Transition::PDM {
    template<typename WordAlphabet, typename StackAlphabet>
    using PushdownMachineStorage = std::tuple<Memory::Word::Word<WordAlphabet>, Memory::Stack::Stack<StackAlphabet>>;
 
    template <
            typename StateType_,
            typename LetterType_,
            typename StackSymbolType_
    >
    class PushdownMachineTransition :
            public Transition<StateType_, PushdownMachineStorage<LetterType_, StackSymbolType_>, std::monostate> {
    public:
        typedef Memory::Word::Word<LetterType_> WordType;
        typedef Memory::Stack::Stack<StackSymbolType_> StackType;
    private:
        typedef std::tuple<WordType, StackType> StorageType_;
        typedef Transition<StateType_, StorageType_, std::monostate> Transition_;
    public:
        using typename Transition_::StateType;
        using typename Transition_::StorageType;
        using typename Transition_::ApplyHelperType;
 
        typedef LetterType_ LetterType;
 
        typedef StackSymbolType_ StackSymbolType;
 
        static_assert(std::is_same_v<StateType, StateType_>);
        static_assert(std::is_same_v<StorageType, StorageType_>);
        static_assert(std::is_same_v<ApplyHelperType, std::monostate>);
 
        PushdownMachineTransition() = default;
 
        PushdownMachineTransition(const PushdownMachineTransition&) = default;
 
        PushdownMachineTransition(PushdownMachineTransition&&) = default;
 
        PushdownMachineTransition& operator=(const PushdownMachineTransition&) = default;
 
        PushdownMachineTransition& operator=(PushdownMachineTransition&&) = default;
 
        virtual ~PushdownMachineTransition() = default;
    };
}