deterministicSimpleAmnesicMachine.h

#pragma once
 
#include <machine/amnesic/simpleAmnesicMachine.h>
#include <transition/amnesic/simpleAmnesicMachineTransition.h>
 
namespace TuringSim::Machine::Amnesic {
    template<
            typename StateType,
            AcceptingStyle acceptingStyle,
            typename AcceptingConstructorArgs = typename impl_details_::StateAcceptingMachineArgs<StateType, acceptingStyle>::AcceptingConstructorArgs
    >
    class DeterministicSimpleAmnesicMachine;
 
    template<
            typename StateType_,
            AcceptingStyle acceptingStyle,
            typename... Args
    >
    class DeterministicSimpleAmnesicMachine<StateType_, acceptingStyle, std::tuple<Args...>>
            : public SimpleAmnesicMachine<StateType_, true, acceptingStyle> {
        typedef Transition::Amnesic::SimpleAmnesicMachineTransition<StateType_> TransitionType_;
        typedef SimpleAmnesicMachine<StateType_, true, acceptingStyle> SimpleAmnesicMachine_;
    public:
        using typename SimpleAmnesicMachine_::StateType;
        using typename SimpleAmnesicMachine_::IsAccepting;
        using typename SimpleAmnesicMachine_::StorageType;
        using typename SimpleAmnesicMachine_::IsAlternating;
        using typename SimpleAmnesicMachine_::TransitionType;
        using typename SimpleAmnesicMachine_::ApplyHelperType;
        using typename SimpleAmnesicMachine_::IsDeterministic;
        using typename SimpleAmnesicMachine_::TransitionContainer;
        using typename SimpleAmnesicMachine_::InitialStateContainer;
        using typename SimpleAmnesicMachine_::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::vector<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, std::monostate>,
                      "StorageType should be a word.");
        static_assert(std::is_same_v<TransitionType_, TransitionType>,
                      "TransitionType must be SimpleAmnesicMachineTransition.");
        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.");
 
        DeterministicSimpleAmnesicMachine() = delete;
 
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wshadow-field"
 
        DeterministicSimpleAmnesicMachine(
                const StateType &initialState,
                const std::vector<TransitionType> &transitions,
                const std::set<StateType> &finalStates,
                Args... args
        ) :
                SimpleAmnesicMachine_(finalStates, args...),
                initialState(initialState),
                transitions() {
            for (const TransitionType &transition: transitions) {
                this->transitions.insert({transition.getPreState(), transition});
            }
        }
#pragma clang diagnostic pop
 
        DeterministicSimpleAmnesicMachine(const DeterministicSimpleAmnesicMachine&) = default;
 
        DeterministicSimpleAmnesicMachine(DeterministicSimpleAmnesicMachine&&) = default;
 
        DeterministicSimpleAmnesicMachine& operator=(const DeterministicSimpleAmnesicMachine&) = default;
 
        DeterministicSimpleAmnesicMachine& operator=(DeterministicSimpleAmnesicMachine&&) = default;
 
        virtual ~DeterministicSimpleAmnesicMachine() override = default;
 
        virtual StateType getInitialState() const noexcept override final {
            return initialState;
        }
 
        virtual OptionalHelpedTransition
        getMatchingTransitionFromState(const StateType &state) const noexcept override final {
            if (typename std::map<StateType, TransitionType>::const_iterator it = transitions.find(state); it !=
                                                                                                           transitions.end()) {
                return {{it->second, {}}};
            }
            return {};
        }
 
    private:
        StateType initialState;
        std::map<StateType, TransitionType> transitions;
    };
}