---

guard.H

Go to the documentation of this file.

#ifndef GLUE_GUARD_H
#define GLUE_GUARD_H

#include "event/event.H"


//
//  GUARD - abstract interface
//
//
MAKE_PTR_BASEC(GUARD);
typedef const class GUARD cGUARD;
class GUARD: public REFcounter {
 public:
   virtual     ~GUARD()                      { }
   virtual int  exec(cEVENTptr &e)     const = 0;
   virtual bool guarded()              const = 0;
           int  operator == (cGUARD &) const { return 0; }
   virtual void debug(ostream &o)      const = 0;
};


//
//  GUARDevent - test if EVENTs match
//
//
MAKE_PTR_SUBC(GUARDevent, GUARD);
class GUARDevent : public GUARD {
 protected:
   EVENTptr _event;
 public:
                      GUARDevent(cEVENTptr &e):_event(e) { }

   virtual int        exec(cEVENTptr &e) const  { return _event->test(e); }
   virtual bool       guarded()          const  { return false; }
   virtual cEVENTptr &event()            const  { return _event; }
   virtual void       debug(ostream &o)  const  { _event->debug(o);}
};


//
//  GUARDfunc - test EVENTs with a given function
//
//
class GUARDfunc: public GUARD {
 public:
   typedef bool (*func_t)(cEVENTptr &);

 protected:
   func_t  _func;

 public: 
                  GUARDfunc(func_t f) : _func(f) {}

   virtual bool   guarded()          const  { return false; }
   virtual int    exec(cEVENTptr &e) const  { return (*_func)(e); }
   virtual void   debug(ostream &o)  const  { o << "(GUARDfunc)"; }
};

//
//  GUARDmeth - test EVENTs with a given method on an object
//
//
template <class T, class EVT>
class GUARDmeth: public GUARD {
  public:
    typedef bool (T::*_meth)(EVT) const;

  protected:
    T        *_obj;
    _meth     _method;

  public: 
                  GUARDmeth(T *o, _meth m): _obj(o),_method(m) {}
   virtual       ~GUARDmeth()               { }

   virtual bool   guarded()          const  { return false; }
   virtual int    exec(cEVENTptr &e) const  { EVT x((EVT) e);
                                              if (!x->cast(e)) {
                                                 cerr<< "ERROR: GUARDmeth: event type ";
                                                     e->debug(cerr);
                                                 cerr<<" doesn't match FSA GUARD method " <<  x->static_name() << endl;
                                            return 0;
                                          } else
                                             return (_obj->*_method)(x->cast(e)); }
   virtual void   debug(ostream &o)  const  { o << "(GUARDmeth)"; }
};

//
//  GUARDand - tests two GUARD's, returns true only if both GUARDS return true
//
//
class DllImpExp GUARDand : public GUARD {
   protected:
      GUARDptr _g1;
      GUARDptr _g2;
   public:
                GUARDand(cGUARDptr &g1, cGUARDptr &g2) : _g1(g1), _g2(g2) {}
   virtual     ~GUARDand()                { }

   virtual bool guarded()          const  { return true; }
   virtual int  exec(cEVENTptr &e) const  { return _g1->exec(e)&&_g2->exec(e); }
   virtual void debug(ostream &o)  const  { _g1->debug(o);o<<"&";_g2->debug(o);}
};

//
//  GUARDnot - returns the logical negation of a GUARD
//
//
class GUARDnot : public GUARD {
   protected:
      cGUARDptr _g;
   public:
                  GUARDnot(cGUARDptr &g) : _g(g) { }
   virtual       ~GUARDnot()                { }

   virtual bool   guarded()          const  { return true; }
   virtual int    exec(cEVENTptr &e) const  { return !_g->exec(e); }
   virtual void   debug(ostream &o)  const  { o << "!"; _g->debug(o); }
};
#endif

---