stateAcceptingMachine.h

#pragma once
 
#include <machine/acceptingMachine.h>
 
#include <map>
#include <set>
 
namespace TuringSim::Machine {
    namespace impl_details_ {
        template<
                typename StateType,
                AcceptingStyle acceptingStyle
        >
        struct StateAcceptingMachineArgs;
 
        template<typename StateType_>
        struct StateAcceptingMachineArgs<StateType_, AcceptingStyle::NonAccepting> {
            typedef std::tuple<> AcceptingConstructorArgs;
        };
 
        template<typename StateType_>
        struct StateAcceptingMachineArgs<StateType_, AcceptingStyle::Accepting> {
            typedef std::tuple<const std::set<StateType_> &> AcceptingConstructorArgs;
        };
 
        template<typename StateType_>
        struct StateAcceptingMachineArgs<StateType_, AcceptingStyle::Alternating> {
            typedef std::tuple<bool, const std::set<StateType_> &, const std::set<StateType_> &, const std::set<StateType_> &, const std::set<StateType_> &> AcceptingConstructorArgs;
        };
    }
 
    template<
            typename MachineType,
            AcceptingStyle acceptingStyle
    >
    class StateAcceptingMachine;
 
    template<typename MachineType_>
    class StateAcceptingMachine<MachineType_, AcceptingStyle::NonAccepting> : public MachineType_ {
    public:
        using typename MachineType_::StateType;
        using typename MachineType_::IsAccepting;
        using typename MachineType_::StorageType;
        using typename MachineType_::IsAlternating;
        using typename MachineType_::TransitionType;
        using typename MachineType_::ApplyHelperType;
        using typename MachineType_::IsDeterministic;
        using typename MachineType_::TransitionContainer;
        using typename MachineType_::InitialStateContainer;
        using typename MachineType_::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<ApplyHelperType, typename TransitionType::ApplyHelperType>);
        static_assert(std::is_same_v<OptionalHelpedTransition, std::optional<std::pair<const TransitionType& , ApplyHelperType>>>);
 
        StateAcceptingMachine() = default;
 
        StateAcceptingMachine(const StateAcceptingMachine&) = default;
 
        StateAcceptingMachine(StateAcceptingMachine&&) = default;
 
        StateAcceptingMachine& operator=(const StateAcceptingMachine&) = default;
 
        StateAcceptingMachine& operator=(StateAcceptingMachine&&) = default;
 
        virtual ~StateAcceptingMachine() override = default;
    };
 
    template<typename MachineType_>
    class StateAcceptingMachine<MachineType_, AcceptingStyle::Accepting> : public MachineType_ {
    public:
        using typename MachineType_::StateType;
        using typename MachineType_::IsAccepting;
        using typename MachineType_::StorageType;
        using typename MachineType_::IsAlternating;
        using typename MachineType_::TransitionType;
        using typename MachineType_::ApplyHelperType;
        using typename MachineType_::IsDeterministic;
        using typename MachineType_::TransitionContainer;
        using typename MachineType_::InitialStateContainer;
        using typename MachineType_::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<ApplyHelperType, typename TransitionType::ApplyHelperType>);
        static_assert(std::is_same_v<OptionalHelpedTransition, std::optional<std::pair<const TransitionType& , ApplyHelperType>>>);
 
        StateAcceptingMachine() = delete;
 
        StateAcceptingMachine(const std::set<StateType>& acceptingStates) :
                MachineType_(),
                acceptingStates(acceptingStates) {}
 
        StateAcceptingMachine(const StateAcceptingMachine&) = default;
 
        StateAcceptingMachine(StateAcceptingMachine&&) = default;
 
        StateAcceptingMachine& operator=(const StateAcceptingMachine&) = default;
 
        StateAcceptingMachine& operator=(StateAcceptingMachine&&) = default;
 
        virtual ~StateAcceptingMachine() override = default;
 
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-parameter"
 
        virtual bool isAcceptingConfiguration(const StateType& state, const StorageType& storage) const noexcept override final {
            return isAcceptingState(state);
        }
#pragma clang diagnostic pop
 
        bool isAcceptingState(const StateType& state) const noexcept {
            return acceptingStates.count(state) > 0;
        }
 
    protected:
        std::set<StateType> acceptingStates;
    };
 
    template<typename MachineType_>
    class StateAcceptingMachine<MachineType_, AcceptingStyle::Alternating> : public MachineType_ {
    public:
        using typename MachineType_::StateType;
        using typename MachineType_::IsAccepting;
        using typename MachineType_::StorageType;
        using typename MachineType_::IsAlternating;
        using typename MachineType_::TransitionType;
        using typename MachineType_::ApplyHelperType;
        using typename MachineType_::IsDeterministic;
        using typename MachineType_::TransitionContainer;
        using typename MachineType_::InitialStateContainer;
        using typename MachineType_::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<ApplyHelperType, typename TransitionType::ApplyHelperType>);
        static_assert(std::is_same_v<OptionalHelpedTransition, std::optional<std::pair<const TransitionType& , ApplyHelperType>>>);
 
        StateAcceptingMachine() = delete;
 
        StateAcceptingMachine(
                bool initiallyUniversal,
                const std::set<StateType>& accepting,
                const std::set<StateType>& rejecting,
                const std::set<StateType>& universal,
                const std::set<StateType>& existential) :
                MachineType_(),
                initiallyUniversal(initiallyUniversal), acceptance() {
            std::vector<std::tuple<const std::set<StateType>*, Acceptance::NodeType>> categories = {
                    {&accepting,   Acceptance::Accept},
                    {&rejecting,   Acceptance::Reject},
                    {&universal,   Acceptance::Universal},
                    {&existential, Acceptance::Existential},
            };
            for (auto&[set, category]: categories) {
                for (const StateType& state: *set) {
                    acceptance[state] = category;
                }
            }
        }
 
        StateAcceptingMachine(const StateAcceptingMachine&) = default;
 
        StateAcceptingMachine(StateAcceptingMachine&&) = default;
 
        StateAcceptingMachine& operator=(const StateAcceptingMachine& ) = default;
 
        StateAcceptingMachine& operator=(StateAcceptingMachine&& ) = default;
 
        virtual ~StateAcceptingMachine() override = default;
 
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-parameter"
 
        virtual Acceptance::NodeType isAcceptingConfiguration(const StateType& state, const StorageType& storage) const noexcept override final {
            return isAcceptingState(state);
        }
#pragma clang diagnostic pop
 
        Acceptance::NodeType isAcceptingState(const StateType& state) const noexcept {
            if (typename std::map<StateType, Acceptance::NodeType>::const_iterator it = acceptance.find(state);
                    it != acceptance.end()) {
                return it->second;
            }
            return Acceptance::Existential;
        }
 
        virtual bool isInitiallyUniversal() const noexcept override final {
            return initiallyUniversal;
        }
 
    protected:
        bool initiallyUniversal;
 
        std::map<StateType, Acceptance::NodeType> acceptance;
    };
}