---

fsa.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_FSA_H
#define GLUE_FSA_H

#include "std/strings.H"
#include "fsa/guard.H"
#include "fsa/arc.H"
#include "fsa/state.H"


//
//
//  Interactor
//     is a convenience class that makes it easy for an
//  object to define ARC and GUARD methods and ultimately
//  encapsulate an FSA.
//
//
template <class T>
class Interactor {
  protected :
   str_ptr                    _name;
   STATE                      _entry;
  public :
   virtual    ~Interactor() { }
               Interactor(Cstr_ptr &n):_name(n),_entry(n) { }

    STATE     *entry()                           { return &_entry; }
   cSTATE     *entry()                     const { return &_entry; }
   Cstr_ptr   &name()                      const { return _name; }
};

inline GUARD  *Gd(cEVENTptr &e)                  { return new GUARDevent(e); }
inline GUARD  *GDand(cGUARDptr &a, cGUARDptr &b) { return new GUARDand(a, b); }
inline GUARD  *GDnot(cGUARDptr &a)               { return new GUARDnot(a); }

template <class T, class EVT>
inline GUARD *
GdMeth(T *THIS_PTR, bool (T::*m)(EVT) const)
   { return new GUARDmeth<T,EVT>(THIS_PTR, m); }

#ifdef _AIX
template <class T, class EVT>
inline ARC *
Arc(T *THIS_PTR, cGUARDptr &g, void (T::*m)(EVT, STATE *&), STATE *s)
   { return new ARC(((Interactor<T> *)THIS_PTR)->name(), g, new TRIGGERmeth<T,EVT>(THIS_PTR,m),s);}
template <class T, class EVT>
inline ARC *
Arc(T *THIS_PTR, GUARD *g, void (T::*m)(EVT, STATE *&), STATE *s)
   { return new ARC(((Interactor<T> *)THIS_PTR)->name(), g, new TRIGGERmeth<T,EVT>(THIS_PTR,m),s);}
template <class T, class EVT>
inline ARC *
Arc(T *THIS_PTR, cGUARDptr &g, void (T::*m)(EVT, STATE *&))
   { return new ARC(((Interactor<T> *)THIS_PTR)->name(), g, new TRIGGERmeth<T,EVT>(THIS_PTR,m),0);}
template <class T, class EVT>
inline ARC *
Arc(T *THIS_PTR, GUARD *g, void (T::*m)(EVT, STATE *&))
   { return new ARC(((Interactor<T> *)THIS_PTR)->name(), g, new TRIGGERmeth<T,EVT>(THIS_PTR,m),0);}
#else
template <class T, class EVT>
inline ARC *
Arc(T *THIS_PTR, cGUARDptr &g, void (T::*m)(EVT, STATE *&), STATE *s=0)
   { return new ARC(((Interactor<T> *)THIS_PTR)->name(), g, new TRIGGERmeth<T,EVT>(THIS_PTR,m),s);}
template <class T, class EVT>
inline ARC *
Arc(T *THIS_PTR, GUARD *g, void (T::*m)(EVT, STATE *&), STATE *s=0)
   { return new ARC(((Interactor<T> *)THIS_PTR)->name(), g, new TRIGGERmeth<T,EVT>(THIS_PTR,m),s);}
#endif

//
// FSA 
//
class FSA : public EVENThandler {
   protected:
     STATE  *_cur;
     STATE  *_start;

   public:
            FSA():_cur(0), _start(0)          { }
            FSA(STATE *x):_cur(x), _start(x)  { }

     STATE *cur()                             { return _cur; }
     STATE *start()                           { return _start; }
     void   set_cur(STATE *x)                 { _cur = x; }
     void   handle_event(cEVENTptr &e)        { _cur->event(_cur,e,_start); }
     void   reset()                           { _cur = _start; }
     bool   is_reset()                  const { return _cur == _start; }
};

#endif

---