Fsa.H

Go to the documentation of this file.

#ifndef FSA_H
#define FSA_H

#include "IS3DCommon.H"

// include Event specifications and functors to allow class method callbacks
#include <Event.H>
// include FsaArc and FsaState helper classes
#include <FsaHelper.H>

namespace IS3D {

typedef ReferenceCountedPointer<class Fsa> FsaRef;
class Fsa : public ReferenceCountedObject
{
public:

  static FsaRef fromQFSMFile(const std::string &filename);

  Fsa(const std::string &name);
  virtual ~Fsa();

  bool addState(const std::string &stateName);

  bool addArc(const std::string &arcName,
          const int &fromState,
          const int &toState,
          const Array<std::string> &triggers);

  bool addArc(const std::string &arcName,
          const std::string &fromState,
          const std::string &toState,
          const Array<std::string> &triggers);


  template <class T>
  void addStateEnterCallback(std::string stateName, T *thisPtr, 
                 void (T::*method)(EventRef)) {
    EventCallbackFunctor *f = 
      new EventCallbackSpecificFunctor<T>(thisPtr, method);
    _states[getIndexOfState(stateName)].addEnterCallback(f);
  }


  template <class T>
  void addStateExitCallback(std::string stateName, T *thisPtr, 
                void (T::*method)(EventRef)) {
    EventCallbackFunctor *f = 
      new EventCallbackSpecificFunctor<T>(thisPtr, method);
    _states[getIndexOfState(stateName)].addExitCallback(f);
  }
  

  template <class T>
  void addArcCallback(std::string arcName, T *thisPtr, 
              void (T::*method)(EventRef)) {
    EventCallbackFunctor *f = 
      new EventCallbackSpecificFunctor<T>(thisPtr, method);
    storeArcCallback(arcName, f);
  }



  void print();

  void setDebug(bool b)  { _debug = b; }

  std::string getCurrentState() { return _states[_curState].getName(); }

  void processEvent(EventRef event);

  bool jumpToState(const std::string &toState);

  std::string getName() { return _name; }

protected:  

  std::string stateName(int i);   

  int getIndexOfState(std::string stateName) {
    for (int s=0;s<_states.size();s++) {
      if (_states[s].getName() == stateName)
        return s;
    }
    alwaysAssertM(false, "Can't find match for state name " + stateName);
    return -1;
  }


  bool checkTriggerMatch(EventRef event, const std::string &triggerName);
  
  void storeArcCallback(std::string arcName, EventCallbackFunctor *f);
  
  Array<FsaState>  _states;
  std::string      _name;
  int              _curState;
  bool             _debug;
};


} // end namespace

#endif

---