pushdownMachine.h

#pragma once
 
#include <machine/machine.h>
#include <transition/PDM/pushdownMachineTransition.h>
 
namespace TuringSim::Machine::PDM {
    template <
            typename TransitionType_,
            bool deterministic,
            AcceptingStyle acceptingStyle = AcceptingStyle::Accepting,
            template <typename...> class TransitionContainer_ = std::vector,
            template <typename...> class InitialStateContainer_ = std::vector
    >
    class PushdownMachine;
 
    template <
            typename TransitionType_,
            AcceptingStyle acceptingStyle,
            template <typename...> class TransitionContainer_,
            template <typename...> class InitialStateContainer_
    >
    class PushdownMachine<TransitionType_, true, acceptingStyle, TransitionContainer_, InitialStateContainer_> :
            public Machine<TransitionType_, true, acceptingStyle, TransitionContainer_, InitialStateContainer_>{
        typedef Machine<TransitionType_, true, acceptingStyle, TransitionContainer_, InitialStateContainer_> Machine_;
    public:
        using typename Machine_::StateType;
        using typename Machine_::IsAccepting;
        using typename Machine_::StorageType;
        using typename Machine_::IsAlternating;
        using typename Machine_::TransitionType;
        using typename Machine_::ApplyHelperType;
        using typename Machine_::IsDeterministic;
        using typename Machine_::TransitionContainer;
        using typename Machine_::InitialStateContainer;
        using typename Machine_::OptionalHelpedTransition;
 
        typedef typename TransitionType::WordType WordType;
 
        typedef typename TransitionType::StackType StackType;
 
        typedef typename TransitionType::LetterType LetterType;
 
        typedef typename TransitionType::StackSymbolType StackSymbolType;
 
        static_assert(std::is_same_v<StateType, typename TransitionType::StateType>);
        static_assert(std::is_same_v<StorageType, typename TransitionType::StorageType>);
        static_assert(std::is_same_v<TransitionType, TransitionType_>);
        static_assert(std::is_same_v<ApplyHelperType, typename TransitionType::ApplyHelperType>);
        static_assert(std::is_same_v<ApplyHelperType, std::monostate>);
        static_assert(std::is_same_v<IsDeterministic, std::true_type>);
        static_assert(std::is_same_v<TransitionContainer, TransitionContainer_<std::pair<const TransitionType&, ApplyHelperType>>>);
        static_assert(std::is_same_v<InitialStateContainer, InitialStateContainer_<StateType>>);
        static_assert(std::is_same_v<OptionalHelpedTransition, std::optional<std::pair<const TransitionType&, ApplyHelperType>>>);
 
        static_assert(std::is_same_v<StorageType, Transition::PDM::PushdownMachineStorage<LetterType, StackSymbolType>>,
                      "StorageType should be a word and a stack.");
        static_assert(std::is_base_of_v<Transition::PDM::PushdownMachineTransition<StateType, LetterType, StackSymbolType>, TransitionType>,
                      "TransitionType must be a derived class of PushdownMachineTransition");
 
 
        PushdownMachine() = default;
        PushdownMachine(const PushdownMachine&) = default;
        PushdownMachine(PushdownMachine&&) = default;
        PushdownMachine& operator=(const PushdownMachine&) = default;
        PushdownMachine& operator=(PushdownMachine&&) = default;
        virtual ~PushdownMachine() override = default;
 
        virtual OptionalHelpedTransition getMatchingTransition(const StateType& state, const StorageType& storage) const noexcept override final {
            return this->getMatchingTransitionFromCurrentLetter(state, std::get<WordType>(storage).front_opt(), std::get<StackType>(storage));
        }
 
        virtual OptionalHelpedTransition getMatchingTransitionFromCurrentLetter(const StateType& state, const std::optional<LetterType>& letter, const StackType& stack) const noexcept = 0;
    };
 
    template <
            typename TransitionType_,
            AcceptingStyle acceptingStyle,
            template <typename...> class TransitionContainer_,
            template <typename...> class InitialStateContainer_
    >
    class PushdownMachine<TransitionType_, false, acceptingStyle, TransitionContainer_, InitialStateContainer_> :
            public Machine<TransitionType_, false, acceptingStyle, TransitionContainer_, InitialStateContainer_> {
        typedef Machine<TransitionType_, false, acceptingStyle, TransitionContainer_, InitialStateContainer_> Machine_;
    public:
        using typename Machine_::StateType;
        using typename Machine_::IsAccepting;
        using typename Machine_::StorageType;
        using typename Machine_::IsAlternating;
        using typename Machine_::TransitionType;
        using typename Machine_::ApplyHelperType;
        using typename Machine_::IsDeterministic;
        using typename Machine_::TransitionContainer;
        using typename Machine_::InitialStateContainer;
        using typename Machine_::OptionalHelpedTransition;
 
        typedef typename TransitionType::WordType WordType;
 
        typedef typename TransitionType::StackType StackType;
 
        typedef typename TransitionType::LetterType LetterType;
 
        typedef typename TransitionType::StackSymbolType StackSymbolType;
 
        static_assert(std::is_same_v<StateType, typename TransitionType::StateType>);
        static_assert(std::is_same_v<StorageType, typename TransitionType::StorageType>);
        static_assert(std::is_same_v<TransitionType, TransitionType_>);
        static_assert(std::is_same_v<ApplyHelperType, typename TransitionType::ApplyHelperType>);
        static_assert(std::is_same_v<ApplyHelperType, std::monostate>);
        static_assert(std::is_same_v<IsDeterministic, std::false_type>);
        static_assert(std::is_same_v<TransitionContainer, TransitionContainer_<std::pair<const TransitionType&, ApplyHelperType>>>);
        static_assert(std::is_same_v<InitialStateContainer, InitialStateContainer_<StateType>>);
        static_assert(std::is_same_v<OptionalHelpedTransition, std::optional<std::pair<const TransitionType&, ApplyHelperType>>>);
 
        static_assert(std::is_same_v<StorageType, Transition::PDM::PushdownMachineStorage<LetterType, StackSymbolType>>,
                      "StorageType should be a word and a stack.");
        static_assert(std::is_base_of_v<Transition::PDM::PushdownMachineTransition<StateType, LetterType, StackSymbolType>, TransitionType>,
                      "TransitionType must be a derived class of PushdownMachineTransition");
 
        PushdownMachine() = default;
        PushdownMachine(const PushdownMachine&) = default;
        PushdownMachine(PushdownMachine&&) = default;
        PushdownMachine& operator=(const PushdownMachine&) = default;
        PushdownMachine& operator=(PushdownMachine&&) = default;
        virtual ~PushdownMachine() override = default;
 
        virtual TransitionContainer getMatchingTransitions(const StateType& state, const StorageType& storage) const noexcept override final {
            return this->getMatchingTransitionsFromCurrentLetter(state, std::get<WordType>(storage).front_opt(), std::get<StackType>(storage));
        }
 
        virtual TransitionContainer getMatchingTransitionsFromCurrentLetter(const StateType& state, const std::optional<LetterType>& letter, const StackType& stack) const noexcept = 0;
    };
}