---

arc.H

Go to the documentation of this file.

/*
 * Copyright 1997, Brown University, Providence, RI.
 * 
 *                         All Rights Reserved
 * 
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose other than its incorporation into a
 * commercial product is hereby granted without fee, provided that the
 * above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of Brown University not be used in
 * advertising or publicity pertaining to distribution of the software
 * without specific, written prior permission.
 * 
 * BROWN UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ANY
 * PARTICULAR PURPOSE.  IN NO EVENT SHALL BROWN UNIVERSITY BE LIABLE FOR
 * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
#ifndef GLUE_ARC_H
#define GLUE_ARC_H

#include "std/ref.H"
#include "std/strings.H"
#include "fsa/guard.H"

typedef const class STATE cSTATE;
class STATE;
#define STATEstart ((STATE *)-1)


//
//  TRIGGER - abstract trigger function for ARC transitions
//
//
MAKE_PTR_BASEC(TRIGGER);
class TRIGGER : public REFcounter {
   public:
      virtual     ~TRIGGER() { }
      virtual void exec(STATE *&, cEVENTptr &) = 0;
};

//
//  TRIGGERfunc - function pointer ARC transition
//
//
class TRIGGERfunc : public TRIGGER {
  public    : 
    typedef void (*_functor)(cEVENTptr &, STATE *&);

  protected : 
    _functor  _func;
    
  public: 
 virtual ~TRIGGERfunc() { }
          TRIGGERfunc(_functor f): _func(f) { }

     void exec(STATE *&s, cEVENTptr &e) { _func(e,s); }
};

//
//  TRIGGERmeth - provides a method for ARC transition
//
//
template <class T, class EVT>
class TRIGGERmeth : public  TRIGGER {
  public:
   typedef void (T::*_meth)(EVT, STATE *&);

  protected:
    T       *_obj;
    _meth    _method;

  public:
 virtual ~TRIGGERmeth() { }
          TRIGGERmeth(T *obj, _meth meth): _obj(obj), _method(meth) { }

   void   exec(STATE *&s, cEVENTptr &e) { EVT x((EVT) e); 
                                          if (!x->cast(e)) {
                                            cerr<< "ERROR: TRIGGERmeth: event type ";
                                                e->debug(cerr);
                                            cerr<<" doesn't match FSA Arc method " <<  x->static_name() << endl;
                                          } else
                                            (_obj->*_method)(x->cast(e),s); }
};


//----------------------------------------------------------
//
//  Arc - 
//     represents an Arc of an FSA.  An Arc is traversed when
//  its specific Event is generated.  Traversing an Arc 
//  results in the Callback associated with the Arc being
//  executed.  The next state of the FSA is returned by the
//  callback.
//
//------------------------------------------------------
typedef const class ARC cARC;
class ARC {
 protected :

  str_ptr    _name;
  STATE     *_next;  // next state transition for ARC
  GUARDptr   _guard; // must be a pointer since we allow subclasses
  TRIGGERptr _trigger;

 public : 
 
             ARC(Cstr_ptr &n, cEVENTptr &e, cTRIGGERptr &t,STATE *s=0):_name(n),
                      _next(s),_guard(new GUARDevent(e)),_trigger(t) {}
             ARC(Cstr_ptr &n, cGUARDptr &g, cTRIGGERptr &t,STATE *s=0):_name(n),
                      _next(s),_guard(g),_trigger(t)  { }
  virtual   ~ARC() {}

  int        match(cEVENTptr &e)    const { return _guard->exec(e); }
  bool       guarded()              const { return _guard->guarded(); }
  cGUARDptr &guard()                const { return _guard; }
  int        operator==(cARC &a)    const { return *_guard == *a._guard; }
  void       debug(ostream &o)      const { if (_name) o << _name << ":";
                                            if (_guard)_guard->debug(o); }
  void       exec(STATE *&s, cEVENTptr &e, STATE *start) { 
                                            if (_next) 
                                               s = _next==STATEstart ? start:_next; 
                                            _trigger->exec(s,e);
                                            if (s == STATEstart) s = start; }
};

#endif

---