amnesicMachine.h

#pragma once
 
#include <machine/machine.h>
#include <transition/amnesic/amnesicMachineTransition.h>
 
namespace TuringSim::Machine::Amnesic {
    template <
            typename TransitionType,
            bool deterministic,
            AcceptingStyle acceptingStyle,
            template <typename...> class TransitionContainer = std::vector,
            template <typename...> class InitialStateContainer = std::vector
    >
    class AmnesicMachine;
 
    template <
            typename TransitionType_,
            AcceptingStyle acceptingStyle,
            template <typename...> class TransitionContainer_,
            template <typename...> class InitialStateContainer_
    >
    class AmnesicMachine<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;
 
        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, std::monostate>,
                      "StorageType should be a word.");
        static_assert(std::is_base_of_v<Transition::Amnesic::AmnesicMachineTransition<StateType>, TransitionType>,
                      "TransitionType must be a derived class of AmnesicMachineTransition");
 
        AmnesicMachine() = default;
        AmnesicMachine(const AmnesicMachine&) = default;
        AmnesicMachine(AmnesicMachine&&) = default;
        AmnesicMachine& operator=(const AmnesicMachine&) = default;
        AmnesicMachine& operator=(AmnesicMachine&&) = default;
        virtual ~AmnesicMachine() override = default;
 
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-parameter"
 
        virtual OptionalHelpedTransition getMatchingTransition(const StateType& state, const StorageType& storage) const noexcept override final {
            return this->getMatchingTransitionFromState(state);
        }
 
        virtual OptionalHelpedTransition getMatchingTransitionFromState(const StateType& state) const noexcept = 0;
 
        virtual bool isHaltingConfiguration(const StateType& state, const StorageType& storage) const noexcept override final {
            return this->isHaltingState(state);
        }
#pragma clang diagnostic pop
 
        virtual bool isHaltingState(const StateType& state) const noexcept = 0;
    };
 
    template <
            typename TransitionType_,
            AcceptingStyle acceptingStyle,
            template <typename...> class TransitionContainer_,
            template <typename...> class InitialStateContainer_
    >
    class AmnesicMachine<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;
 
        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, std::monostate>,
                      "StorageType should be a word.");
        static_assert(std::is_base_of_v<Transition::Amnesic::AmnesicMachineTransition<StateType>, TransitionType>,
                      "TransitionType must be a derived class of AmnesicMachineTransition");
 
        AmnesicMachine() = default;
        AmnesicMachine(const AmnesicMachine&) = default;
        AmnesicMachine(AmnesicMachine&&) = default;
        AmnesicMachine& operator=(const AmnesicMachine&) = default;
        AmnesicMachine& operator=(AmnesicMachine&&) = default;
        virtual ~AmnesicMachine() override = default;
 
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-parameter"
 
        virtual TransitionContainer getMatchingTransitions(const StateType& state, const StorageType& storage) const noexcept override final {
            return this->getMatchingTransitionsFromState(state);
        }
 
        virtual TransitionContainer getMatchingTransitionsFromState(const StateType& state) const noexcept = 0;
 
        virtual bool isHaltingConfiguration(const StateType& state, const StorageType& storage) const noexcept override final {
            return this->isHaltingState(state);
        }
#pragma clang diagnostic pop
 
        virtual bool isHaltingState(const StateType& state) const noexcept = 0;
    };
}