maybeEpsilonFiniteStateMachine.h

#pragma once
 
#include <machine/FSM/stateAcceptingFiniteStateMachine.h>
#include <transition/FSM/maybeEpsilonFiniteStateMachineTransition.h>
 
namespace TuringSim::Machine::FSM {
    template <
            typename StateType,
            typename SymbolType,
            AcceptingStyle acceptingStyle = AcceptingStyle::Accepting,
            typename AcceptingConstructorArgs = typename impl_details_::StateAcceptingMachineArgs<StateType, acceptingStyle>::AcceptingConstructorArgs
    >
    class MaybeEpsilonFiniteStateMachine;
 
    template <
            typename StateType_,
            typename SymbolType_,
            AcceptingStyle acceptingStyle,
            typename... Args
    >
    class MaybeEpsilonFiniteStateMachine<StateType_, SymbolType_, acceptingStyle, std::tuple<Args...>>
            : public StateAcceptingFiniteStateMachine<Transition::FSM::MaybeEpsilonFiniteStateMachineTransition<StateType_, SymbolType_>, false, acceptingStyle, std::set, std::set>{
        typedef Transition::FSM::MaybeEpsilonFiniteStateMachineTransition<StateType_, SymbolType_> TransitionType_;
        typedef StateAcceptingFiniteStateMachine<TransitionType_, false, acceptingStyle, std::set, std::set> StateAcceptingFiniteStateMachine_;
    public:
        using typename StateAcceptingFiniteStateMachine_::StateType;
        using typename StateAcceptingFiniteStateMachine_::SymbolType;
        using typename StateAcceptingFiniteStateMachine_::IsAccepting;
        using typename StateAcceptingFiniteStateMachine_::StorageType;
        using typename StateAcceptingFiniteStateMachine_::IsAlternating;
        using typename StateAcceptingFiniteStateMachine_::TransitionType;
        using typename StateAcceptingFiniteStateMachine_::ApplyHelperType;
        using typename StateAcceptingFiniteStateMachine_::IsDeterministic;
        using typename StateAcceptingFiniteStateMachine_::TransitionContainer;
        using typename StateAcceptingFiniteStateMachine_::InitialStateContainer;
        using typename StateAcceptingFiniteStateMachine_::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::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, Memory::Word::Word<SymbolType>>,
                      "StorageType should be a word.");
        static_assert(std::is_same_v<TransitionType_, TransitionType>,
                      "TransitionType must be MaybeEpsilonFiniteStateMachineTransition");
        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.");
 
        MaybeEpsilonFiniteStateMachine() = delete;
 
        MaybeEpsilonFiniteStateMachine(
                const std::set<StateType>& initialStates,
                const std::vector<TransitionType>& transitions,
                Args... acceptingArgs
        ) :
                StateAcceptingFiniteStateMachine_(acceptingArgs...),
                initialStates(initialStates),
                nonEpsilonTransitions(),
                epsilonTransitions()
        {
            for(const TransitionType& transition: transitions) {
                if(transition.getPreLetter()) {
                    this->nonEpsilonTransitions[transition.getPreState()][*transition.getPreLetter()].insert(transition);
                }
                else {
                    this->epsilonTransitions[transition.getPreState()].insert(transition);
                }
            }
        }
 
        MaybeEpsilonFiniteStateMachine(const MaybeEpsilonFiniteStateMachine&) = default;
        MaybeEpsilonFiniteStateMachine(MaybeEpsilonFiniteStateMachine&&) = default;
        MaybeEpsilonFiniteStateMachine& operator=(const MaybeEpsilonFiniteStateMachine&) = default;
        MaybeEpsilonFiniteStateMachine& operator=(MaybeEpsilonFiniteStateMachine&&) = default;
        virtual ~MaybeEpsilonFiniteStateMachine() override = default;
 
        virtual InitialStateContainer getInitialStates() const noexcept override final {
            return initialStates;
        }
 
        const std::set<TransitionType>& getMatchingNonEpsilonTransitionsWithoutHelper(const StateType& state, const SymbolType& symbol) const {
            return nonEpsilonTransitions.at(state).at(symbol);
        }
 
        const std::set<TransitionType>& getMatchingEpsilonTransitionsWithoutHelper(const StateType& state) const {
            return epsilonTransitions.at(state);
        }
 
        virtual TransitionContainer getMatchingTransitionsFromCurrentLetter(const StateType& state, const std::optional<SymbolType>& symbol) const noexcept override final {
            std::set<std::pair<const TransitionType&, ApplyHelperType>> r;
            try {
                for(const TransitionType& transition : getMatchingNonEpsilonTransitionsWithoutHelper(state, symbol.value())) {
                    r.insert({transition, std::monostate()});
                }
            }
            catch (std::out_of_range) {
            }
            catch (std::bad_optional_access) {
            }
            try {
                for(const TransitionType& transition : getMatchingEpsilonTransitionsWithoutHelper(state)) {
                    r.insert({transition, std::monostate()});
                }
            }
            catch (std::out_of_range) {
            }
            return r;
        }
 
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-parameter"
 
        virtual bool isHaltingConfiguration(const StateType& state, const StorageType& storage) const noexcept override final {
            if constexpr (acceptingStyle == AcceptingStyle::NonAccepting) {
            } else if constexpr (acceptingStyle == AcceptingStyle::Accepting) {
                if(StateAcceptingFiniteStateMachine_::isAcceptingState(state) && storage.isEndOfWord()) {
                    return true;
                }
            } else {
                std::optional<bool> acceptance = Acceptance::toBool(StateAcceptingFiniteStateMachine_::isAcceptingState(state));
                if (acceptance && *acceptance && storage.isEndOfWord()) {
                    return true;
                }
            }
            typename std::map<StateType, std::set<TransitionType>>::const_iterator it = epsilonTransitions.find(state);
            if (it != epsilonTransitions.end() && !it->second.empty()) {
                return false;
            }
            return storage.isEndOfWord();
        }
#pragma clang diagnostic pop
 
    protected:
        std::set<StateType> initialStates;
 
        std::map<StateType, std::map<SymbolType, std::set<TransitionType>>> nonEpsilonTransitions;
 
        std::map<StateType, std::set<TransitionType>> epsilonTransitions;
    };
}