simplePushdownMachine.h

#pragma once
 
#include <machine/PDM/stateAcceptingPushdownMachine.h>
#include <transition/PDM/simplePushdownMachineTransition.h>
 
namespace TuringSim::Machine::PDM {
    template<
            typename StateType,
            typename LetterType,
            typename StackSymbolType,
            bool deterministic,
            AcceptingStyle acceptingStyle = AcceptingStyle::Accepting,
            template <typename...> class TransitionContainer_ = std::vector,
            template <typename...> class InitialStateContainer_ = std::vector,
            typename AcceptingConstructorArgs = typename impl_details_::StateAcceptingMachineArgs<StateType, acceptingStyle>::AcceptingConstructorArgs
    >
    class SimplePushdownMachine;
 
    template<
            typename StateType_,
            typename LetterType_,
            typename StackSymbolType_,
            bool deterministic,
            AcceptingStyle acceptingStyle,
            template <typename...> class TransitionContainer_,
            template <typename...> class InitialStateContainer_,
            typename... Args
    >
    class SimplePushdownMachine<
            StateType_,
            LetterType_,
            StackSymbolType_,
            deterministic,
            acceptingStyle,
            TransitionContainer_,
            InitialStateContainer_,
            std::tuple<Args...>
    > : public PushdownMachine<Transition::PDM::SimplePushdownMachineTransition<StateType_, LetterType_, StackSymbolType_>, deterministic, acceptingStyle, TransitionContainer_, InitialStateContainer_> {
        typedef Transition::PDM::SimplePushdownMachineTransition<StateType_, LetterType_, StackSymbolType_> TransitionType_;
        typedef PushdownMachine<TransitionType_, deterministic, acceptingStyle, TransitionContainer_, InitialStateContainer_> PushdownMachine_;
    public:
        using typename PushdownMachine_::WordType;
        using typename PushdownMachine_::StackType;
        using typename PushdownMachine_::StateType;
        using typename PushdownMachine_::LetterType;
        using typename PushdownMachine_::IsAccepting;
        using typename PushdownMachine_::StorageType;
        using typename PushdownMachine_::IsAlternating;
        using typename PushdownMachine_::TransitionType;
        using typename PushdownMachine_::ApplyHelperType;
        using typename PushdownMachine_::IsDeterministic;
        using typename PushdownMachine_::StackSymbolType;
        using typename PushdownMachine_::TransitionContainer;
        using typename PushdownMachine_::InitialStateContainer;
        using typename PushdownMachine_::OptionalHelpedTransition;
 
        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::integral_constant<bool, deterministic>>);
        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_same_v<TransitionType_, TransitionType>,
                      "TransitionType must be SimplePushdownTransition");
        static_assert(std::is_same_v<std::tuple<Args...>, typename impl_details_::StateAcceptingMachineArgs<StateType, acceptingStyle>::AcceptingConstructorArgs>,
                      "The only valid value for AcceptingConstructorArgs is the default parameter.");
 
        SimplePushdownMachine() = delete;
 
        SimplePushdownMachine(Args... acceptingArgs) :
                PushdownMachine_(acceptingArgs...)
        {}
 
        SimplePushdownMachine(const SimplePushdownMachine&) = default;
        SimplePushdownMachine(SimplePushdownMachine&&) = default;
        SimplePushdownMachine& operator=(const SimplePushdownMachine&) = default;
        SimplePushdownMachine& operator=(SimplePushdownMachine&&) = default;
        virtual ~SimplePushdownMachine() override = default;
 
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-parameter"
 
        virtual bool isHaltingConfiguration(const StateType& state, const StorageType& storage) const noexcept override final {
            return storage.isEndOfWord();
        }
#pragma clang diagnostic pop
    };
}