StateMachineImp.h

Go to the documentation of this file.

#ifndef FACT_StateMachineImp
#define FACT_StateMachineImp

#include <map>
#include <list>
#include <mutex>
#include <vector>
#include <memory>
#include <condition_variable>

#include "MainImp.h"
#include "MessageImp.h"

class Event;
class EventImp;

class StateMachineImp : public MainImp, public MessageImp
{
public:
    enum DefaultStates_t
    {
        kSM_KeepState    =    -42,  
        kSM_NotAvailable =     -2,  
        kSM_NotReady     =     -1,  
        kSM_Ready        =      0,  
        kSM_UserMode     =      1,  
        kSM_Error        =  0x100,  
        kSM_FatalError   = 0xffff,  
    };

private:
    std::string fName;   

    int fCurrentState;   

    typedef std::map<const int, std::pair<std::string, std::string>> StateNames;

protected:
    StateNames fStateNames;

private:
    std::vector<EventImp*> fListOfEvents; 
    std::list<std::shared_ptr<Event>> fEventQueue;   

    std::mutex fMutex;    
    std::mutex fMutexEvt; 

    std::condition_variable fCond; 

    bool fBufferEvents;  

protected:
    bool fRunning;       
    int  fExitRequested; 

    virtual void PushEvent(Event *cmd);
    std::shared_ptr<Event> PopEvent();

    bool HandleNewState(int newstate, const EventImp *evt, const char *txt);

protected:
    virtual int Execute() { return fCurrentState; }
    //virtual int Configure(const Event &) { return kSM_FatalError; }
    //virtual int Transition(const Event &) { return kSM_FatalError; }

private:
    virtual EventImp *CreateEvent(const std::string &name, const std::string &fmt) = 0;
    virtual EventImp *CreateService(const std::string &);

    virtual void Lock() { }
    virtual void UnLock() { }

    int Wrapper(const std::function<int(const EventImp &)> &f, const EventImp &imp)
    {
        const int rc = f(imp);
        return rc==kSM_KeepState ? GetCurrentState() : rc;
    }

protected:

    bool HandleEvent(const EventImp &evt);

    virtual std::string SetCurrentState(int state, const char *txt="", const std::string &cmd="");

    EventImp &AddEvent(const std::string &name, const std::string &states, const std::string &fmt);
    EventImp &AddEvent(const std::string &name, int s1=-1, int s2=-1, int s3=-1, int s4=-1, int s5=-1);
    EventImp &AddEvent(const std::string &name, const std::string &fmt, int s1=-1, int s2=-1, int s3=-1, int s4=-1, int s5=-1);

    virtual bool AddStateName(const int state, const std::string &name, const std::string &doc="");

    void SetDefaultStateNames();

public:
    StateMachineImp(std::ostream &out=std::cout, const std::string &name="");
    ~StateMachineImp();

    std::function<int(const EventImp &)> Wrap(const std::function<int(const EventImp &)> &func)
    {
        return bind(&StateMachineImp::Wrapper, this, func, std::placeholders::_1);
    }

    const std::string &GetName() const { return fName; }

    EventImp &Subscribe(const std::string &name);
    void Unsubscribe(EventImp *evt);

    int GetCurrentState() const { return fCurrentState; }

    void SetReady()    { SetCurrentState(kSM_Ready, "set manually");    }
    void SetNotReady() { SetCurrentState(kSM_NotReady, "set manually"); }

    virtual int Run(bool dummy);
    int Run() { return Run(false); }

    virtual void Stop(int code=0);

    bool IsRunning() const { return fRunning; }

    void EnableBuffer(bool b=true) { fBufferEvents=b; }

    bool PostEvent(std::ostream &lout, const std::string &str);
    bool PostEvent(const std::string &evt) { return PostEvent(std::cout, evt); }
    bool PostEvent(const EventImp &evt);
    bool PostEvent(const EventImp &evt, const char *ptr, size_t siz);

    // Event handling
    bool HasEvent(const EventImp *cmd);
    EventImp *FindEvent(const std::string &evt);

    bool IsQueueEmpty() const { return fEventQueue.empty(); }

    //const std::vector<EventImp*> &GetListOfEvents() const { return fListOfEvents; }
    const std::vector<std::string> GetEventNames();

    void PrintListOfEvents(std::ostream &out, const std::string &evt="");
    void PrintListOfEvents(const std::string &str="");

    void PrintListOfAllowedEvents(std::ostream &out);
    void PrintListOfAllowedEvents();

    void PrintListOfStates(std::ostream &out) const;
    void PrintListOfStates() const;


    int GetStateIndex(const std::string &name) const;
    bool HasState(int index) const;

    const std::string GetStateName(int state) const;
    const std::string GetStateName() const { return GetStateName(fCurrentState); }

    const std::string GetStateDesc(int state) const;
    const std::string GetStateDesc() const { return GetStateDesc(fCurrentState); }

    const std::string GetStateDescription(int state) const;
    const std::string GetStateDescription() const { return GetStateDescription(fCurrentState); }
};

#endif

// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************