simpleStatePattern.h

#pragma once
 
#include <state/statePattern.h>
 
#include <variant>
 
namespace TuringSim::State {
    template <typename T>
    class SimpleStatePattern : public StatePattern<T, std::monostate> {
        typedef StatePattern<T, std::monostate> StatePattern_;
    public:
        using typename StatePattern_::StateType;
        using typename StatePattern_::MatcherType;
 
        static_assert(std::is_same_v<StateType, T>);
        static_assert(std::is_same_v<MatcherType, std::monostate>);
 
        constexpr SimpleStatePattern(const T& acceptedState) :
                StatePattern_(),
                acceptedState(acceptedState)
        {}
 
        constexpr SimpleStatePattern(const SimpleStatePattern& other) :
                StatePattern_(other),
                acceptedState(other.acceptedState)
        {}
 
        constexpr SimpleStatePattern(SimpleStatePattern&& other) :
                StatePattern_(std::move(other)),
                acceptedState(std::move(other.acceptedState))
        {}
 
        constexpr SimpleStatePattern& operator=(const SimpleStatePattern& other) {
            if(this != &other) {
                StatePattern_::operator=(other);
                acceptedState = other.acceptedState;
            }
            return *this;
        }
 
        constexpr SimpleStatePattern& operator=(SimpleStatePattern&& other) {
            if(this != &other) {
                StatePattern_::operator=(std::move(other));
                acceptedState = std::move(other.acceptedState);
            }
            return *this;
        }
 
        virtual ~SimpleStatePattern() override = default;
 
        constexpr const T& getState() const  {
            return acceptedState;
        }
 
        virtual std::optional<MatcherType> match(const T& state) const noexcept override {
            if(acceptedState == state) {
                return std::monostate();
            }
            return std::nullopt;
        }
 
        bool operator<(const SimpleStatePattern<T>& other) const {
            return acceptedState < other.acceptedState;
        }
 
    private:
        T acceptedState;
    };
}