deterministicSimplePushdownMachine.h

#pragma once
 
#include <machine/PDM/simplePushdownMachine.h>
#include <transition/PDM/simplePushdownMachineTransition.h>
 
namespace TuringSim::Machine::PDM {
    template <
            typename StateType,
            typename LetterType,
            typename StackSymbolType,
            AcceptingStyle acceptingStyle = AcceptingStyle::Accepting,
            typename AcceptingConstructorArgs = typename impl_details_::StateAcceptingMachineArgs<StateType, acceptingStyle>::AcceptingConstructorArgs
    >
    class DeterministicSimplePushdownMachine;
 
    template <
            typename StateType_,
            typename LetterType_,
            typename StackSymbolType_,
            AcceptingStyle acceptingStyle,
            typename... Args
    >
    class DeterministicSimplePushdownMachine<
            StateType_,
            LetterType_,
            StackSymbolType_,
            acceptingStyle,
            std::tuple<Args...>
    >
            : public SimplePushdownMachine<StateType_, LetterType_, StackSymbolType_, true, acceptingStyle, std::set, std::set>{
        typedef Transition::PDM::SimplePushdownMachineTransition<StateType_, LetterType_, StackSymbolType_> TransitionType_;
        typedef SimplePushdownMachine<StateType_, LetterType_, StackSymbolType_, true, acceptingStyle, std::set, std::set> SimplePushdownMachine_;
    public:
        using typename SimplePushdownMachine_::WordType;
        using typename SimplePushdownMachine_::StackType;
        using typename SimplePushdownMachine_::StateType;
        using typename SimplePushdownMachine_::LetterType;
        using typename SimplePushdownMachine_::IsAccepting;
        using typename SimplePushdownMachine_::StorageType;
        using typename SimplePushdownMachine_::IsAlternating;
        using typename SimplePushdownMachine_::TransitionType;
        using typename SimplePushdownMachine_::ApplyHelperType;
        using typename SimplePushdownMachine_::IsDeterministic;
        using typename SimplePushdownMachine_::StackSymbolType;
        using typename SimplePushdownMachine_::TransitionContainer;
        using typename SimplePushdownMachine_::InitialStateContainer;
        using typename SimplePushdownMachine_::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::true_type>);
        static_assert(std::is_same_v<TransitionContainer, std::set<std::pair<const TransitionType&, ApplyHelperType>>>);
        static_assert(std::is_same_v<InitialStateContainer, std::set<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.");
 
        DeterministicSimplePushdownMachine() = delete;
 
        DeterministicSimplePushdownMachine(
                const StateType& initialState,
                const std::vector<TransitionType>& transitions,
                Args... acceptingArgs
        ) :
                SimplePushdownMachine_(acceptingArgs...),
                initialState(initialState),
                transitions()
        {
            for(const TransitionType& transition: transitions) {
                this->transitions[transition.getPreState()].insert({transition.getPreLetter(), transition});
            }
        }
 
        DeterministicSimplePushdownMachine(const DeterministicSimplePushdownMachine&) = default;
        DeterministicSimplePushdownMachine(DeterministicSimplePushdownMachine&&) = default;
        DeterministicSimplePushdownMachine& operator=(const DeterministicSimplePushdownMachine&) = default;
        DeterministicSimplePushdownMachine& operator=(DeterministicSimplePushdownMachine&&) = default;
        virtual ~DeterministicSimplePushdownMachine() override = default;
 
        virtual StateType getInitialState() const noexcept override final {
            return initialState;
        }
 
        virtual OptionalHelpedTransition getMatchingTransitionFromCurrentLetter(const StateType& state, const std::optional<LetterType>& letter, const StackType& stack) const noexcept override final {
            try {
                return {{transitions.at(state).at(letter.value()).at(stack.top()), std::monostate()}};
            }
            catch(std::out_of_range) {
                return {};
            }
            catch(std::bad_optional_access) {
                return {};
            }
            catch(Memory::Stack::StackTooSmallException) {
                return {};
            }
        }
 
    protected:
        StateType initialState;
 
        std::map<StateType, std::map<LetterType, std::map<StackSymbolType, TransitionType>>> transitions;
    };
}