nonDeterministicSimpleAmnesicMachine.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 NonDeterministicSimpleAmnesicMachine;
 
    template<
            typename StateType_,
            AcceptingStyle acceptingStyle,
            typename... Args
    >
    class NonDeterministicSimpleAmnesicMachine<StateType_, acceptingStyle, std::tuple<Args...>>
            : public SimpleAmnesicMachine<StateType_, false, acceptingStyle> {
        typedef Transition::Amnesic::SimpleAmnesicMachineTransition <StateType_> TransitionType_;
        typedef SimpleAmnesicMachine<StateType_, false, 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::false_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.");
 
        NonDeterministicSimpleAmnesicMachine() = delete;
 
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wshadow-field"
 
        NonDeterministicSimpleAmnesicMachine(
                const std::set<StateType>& initialStates,
                const std::vector<TransitionType>& transitions,
                const std::set<StateType>& finalStates,
                Args... args
        ) :
                SimpleAmnesicMachine_(finalStates, args...),
                initialStates(initialStates),
                transitions() {
            for (const TransitionType& transition: transitions) {
                this->transitions[transition.getPreState()].insert(transition);
            }
        }
 
#pragma clang diagnostic pop
 
        NonDeterministicSimpleAmnesicMachine(const NonDeterministicSimpleAmnesicMachine&) = default;
 
        NonDeterministicSimpleAmnesicMachine(NonDeterministicSimpleAmnesicMachine&&) = default;
 
        NonDeterministicSimpleAmnesicMachine& operator=(const NonDeterministicSimpleAmnesicMachine&) = default;
 
        NonDeterministicSimpleAmnesicMachine& operator=(NonDeterministicSimpleAmnesicMachine&&) = default;
 
        virtual ~NonDeterministicSimpleAmnesicMachine() override = default;
 
        virtual InitialStateContainer getInitialStates() const noexcept override final {
            return initialStates;
        }
 
        virtual TransitionContainer getMatchingTransitionsFromState(const StateType& state) const noexcept override final {
            if (typename std::map<StateType, std::set<TransitionType>>::const_iterator it = transitions.find(state); it != transitions.end()) {
                TransitionContainer matchingTransitionsWithHelpers;
                for (const TransitionType& matchingTransition: it->second) {
                    matchingTransitionsWithHelpers.push_back({matchingTransition, {}});
                }
                return matchingTransitionsWithHelpers;
            }
            return {};
        }
 
    private:
        std::set<StateType> initialStates;
        std::map<StateType, std::set<TransitionType>> transitions;
    };
}