State Machine

state-machine.cpp

#include <iostream>
#include <functional>
#include <memory>

// impl ----------

struct state {
    using pointer = std::shared_ptr<state>;
    virtual pointer operator()() = 0;
};

class state_machine {
public:
    using state_ptr = state::pointer;
    
    template <typename T>
    using state_deleter = std::function<void (T *)>;
    
    state_machine() = default;
    state_machine(state_ptr &p) : _state(std::move(p)) {}
    
    void operator()() {
        if (_state) {
            auto next_state = (*_state.get())();
            if (next_state) reset(std::move(next_state));
        }
    }
    
    void reset(state_ptr &&p) { _state = std::move(p); }
    
    template <typename T>
    void reset(T *p, state_deleter<T> deleter = std::default_delete<T>()) {
        reset(std::move(state_ptr(p, deleter)));
    }
    
    state_ptr current_state() { return _state; }
    
private:
    state_ptr _state;
};

// usage ----------

class foo_state : public state {
public:
    foo_state(int value) : _value(value) {}

    int value() const { return _value; }
    
    virtual pointer operator()() override {
        std::cout << "foo: " << value() << std::endl;
        return pointer(new foo_state(value() + 1000));
    }
    
private:
    int _value;
};

int main()
{
    state_machine sm;
    sm.reset(new foo_state(123));
    sm();
    sm();
    sm();
    return 0;
}