rfsm.h

Go to the documentation of this file.

// -*- mode:C++; tab-width:4; c-basic-offset:4; indent-tabs-mode:nil -*-

/*
 * Copyright (C) 2017 iCub Facility
 * Authors: Ali Paikan <ali.paikan@iit.it>, Nicolo' Genesio <nicolo.genesio@iit.it>
 * CopyPolicy: Released under the terms of the LGPLv2.1 or later, see LGPL.TXT
 */

#ifndef RFSM_H
#define RFSM_H


#include <string>
#include <vector>
#include <map>

namespace rfsm {
    class StateMachine;
    class StateCallback;
    class StateGraph;
    class LuaTraceCallback;
}

#ifndef luaL_reg
    #define luaL_reg luaL_Reg
#endif

class rfsm::StateCallback {
public:
    virtual ~StateCallback() {}
    virtual void entry() {}

    virtual void doo() {}

    virtual void exit() {}
};


class rfsm::LuaTraceCallback {
public:
    virtual void onTrace(const std::string& message ) { }
};


class rfsm::StateGraph {
public:
    struct LuaFuncCode {
        int startLine;
        int endLine;
        std::string fileName;
    };


    struct State {
        std::string name;
        std::string type;
        LuaFuncCode entry;
        LuaFuncCode doo;
        LuaFuncCode exit;
        bool operator==(const State& s) const {
            return (s.name == name);
        }
    };

    struct Transition {
        std::string source;
        std::string target;
        std::vector<std::string> events;
        int priority;
        bool operator==(const Transition& s) const {
            //return (s.source == source) && (s.target == target) && (s.events == events);
            return (s.source == source) && (s.target == target);
        }
    };

    typedef std::vector<Transition>::iterator TransitionItr;
    typedef std::vector<State>::iterator StateItr;

    void clear();

public:
    std::vector<State> states;
    std::vector<Transition> transitions;


};


class rfsm::StateMachine : public rfsm::LuaTraceCallback{
public:

    StateMachine(bool verbose=false);

    virtual ~StateMachine();

    const std::string getFileName();

    bool load(const std::string& filename);

    bool run();

    bool step(unsigned int n=1);

    bool sendEvent(const std::string& event);

    bool sendEvents(unsigned int n, ...);

    bool doString(const std::string& command);

    bool doFile(const std::string& filename);

    void addLuaPackagePath(const std::string& path);

    void close();

    bool setStateCallback(const std::string& state, rfsm::StateCallback& callback);

    const std::string getCurrentState();

    const std::vector<std::string>& getEventsList();

    bool getEventQueue(std::vector<std::string>& equeue);

    const rfsm::StateGraph& getStateGraph();

    bool enablePreStepHook();

    bool enablePostStepHook();

    bool catchPrintOutput();

public:
    virtual void onPreStep();

    virtual void onPostStep();

    virtual void onWarning(const std::string message);

    virtual void onError(const std::string message);

    virtual void onInfo(const std::string message);

private:
    virtual void onTrace(const std::string& message );

private:
    class Private;
    Private * const mPriv;
    bool verbose;
};


#endif // RFSM_H