Callbacks.h

Go to the documentation of this file.

//
//------------------------------------------------------------------------
//
// File   : Callbacks.h
// Author : Patrick McCormick (pat@acl.lanl.gov)
//
// $Date: 2003/08/01 04:27:06 $
// $Revision: 1.4 $
//
//
// This header contains some simple wrapper classes around function and
// method pointers.  As it now stands, the code only supports functions 
// and methods which don't return values and take a single void pointer
// as an argument.  Note that the method (member function pointer) class
// uses a template to correctly wrap a method.  The syntax for creating 
// a Method object looks something like:
//
//    MyObjectType *obj = new MyObjectType;
//    Method<MyObjectType> *my_method = 
//      new Method<MyObjectType>(obj, MyObjectType::MyMethod);
//
// Both function and method objects make sure of an overloaded () 
// operator which allows the function/method to be invoked. 
//
// These classes are built in support of active messages -- or any other
// callback-like behavior that is required. 
//
// TODO: It would be nice to implement a flexible way to handler
//       parameters other than the standard void * approach. 
//
// This code is based on the VIF (Visualization Interconnection Framework)
// that helped to drive TRex -- back when there were such beasts... 
// 
//------------------------------------------------------------------------

#ifndef _KOKO_CALLBACK_H_
#define _KOKO_CALLBACK_H_

class KokoBuffer;

class Callback
{
  public:
    inline Callback(void) {};
    inline Callback(const Callback &cb) {};
    inline ~Callback(void) {};

    // We can't have virutal constructors so we have to 
    // use the following method to pull it off.  Subclasses
    // will have to implement the detials...
    virtual Callback *clone(void) = 0;

    // Anything that is a true callback type will impement the 
    // () operator to support invocation. 
    virtual void operator()(KokoBuffer &databuf) const = 0;                                                     
};


class Function : public Callback
{
  public:

    inline Function(const Function &fobj)
    {
      fp = fobj.fp;
    };

    inline Function(void (*funcp)(KokoBuffer &databuf))
    {
      fp = funcp;
    };

    inline ~Function(void)
    { 
      fp = 0; // For complete sanity, let's just make sure we can't do
    };        // something bad by mistake.  Odds of this are likely 
              // very slim but I've seen it happen... 

    inline virtual Callback *clone(void) 
    { return new Function(*this); };

    // Finally, we can get around to invoking the function.
    void operator()(KokoBuffer &databuf) const
    {
      if (fp) { // Check before we get carried away...
        (*fp)(databuf);
      }
    };

  protected:
    void (*fp)(KokoBuffer 
      &databuf); // Function pointer.
};


template <class ObjType>
class Method : public Callback
{
  public:
    
    inline Method(const Method &meth)
    {
      obj = meth.obj;
      mfp = meth.mfp;
    };

    inline Method(ObjType &inobj, void (ObjType::* meth)(KokoBuffer &databuf))
    {
      obj = &inobj;
      mfp = meth;
    };

    inline Method(ObjType *inobj, void (ObjType::* meth)(KokoBuffer &databuf))
    {
      obj = inobj;
      mfp = meth;
    };

    inline ~Method(void)
    {
      obj = 0;  // Once again for complete sanity, make sure we can't 
      mfp = 0;  // do something bad by mistake. 
    };

    inline virtual Callback *clone(void) 
    { return new Method(*this); };


    void operator()(KokoBuffer &databuf) const 
    {
      if (obj && mfp) { // Check before we get carried away...
        (obj->*mfp)(databuf);
      }
    };

  private:
    ObjType        *obj;
    void (ObjType::* mfp)(KokoBuffer &databuf);
};

#endif

---

Send questions, comments, and bug reports to: