src/Include/fg_callback.hxx

   1 /**************************************************************************
   2  * fg_callback.hxx -- Wrapper classes to treat function and method pointers
   3  * as objects.
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 2 of the
   8  * License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  *
  19  * $Id$
  20  **************************************************************************/
  21
  22 #ifndef _FG_CALLBACK_HXX
  23 #define _FG_CALLBACK_HXX
  24
  25 // -dw- need size_t for params() function
  26 #ifdef __MWERKS__
  27 typedef unsigned long   size_t;
  28 #endif
  29
  30
  31 //-----------------------------------------------------------------------------
  32 //
  33 // Abstract base class for all FlightGear callbacks.
  34 //
  35 class fgCallback
  36 {
  37 public:
  38     virtual ~fgCallback() {}
  39
  40     virtual fgCallback* clone() const = 0;
  41     virtual void* call( void** ) = 0;
  42
  43     size_t params() const { return n_params; }
  44
  45 protected:
  46     fgCallback( size_t params )
  47         : n_params(params) {}
  48
  49 protected:
  50     // The number of parameters to pass to the callback routine.
  51     size_t n_params;
  52
  53 private:
  54 };
  55
  56 //-----------------------------------------------------------------------------
  57 //
  58 // Callback for invoking a file scope function.
  59 //
  60 class fgFunctionCallback : public fgCallback
  61 {
  62 public:
  63     // Pointer to function taking no arguments and returning void.
  64     typedef void (*Proc0v)();
  65
  66     // A callback instance to invoke the function 'p'
  67     fgFunctionCallback( Proc0v p );
  68
  69     // Create a clone on the heap.
  70     virtual fgCallback* clone() const;
  71
  72 private:
  73     void* call( void** in );
  74     inline void* call0v( void** );
  75
  76 private:
  77     // Not defined.
  78     fgFunctionCallback();
  79
  80 private:
  81
  82     typedef void* (fgFunctionCallback::*DoPtr)( void** );
  83     DoPtr doPtr;
  84     Proc0v proc0v;
  85 };
  86
  87 inline
  88 fgFunctionCallback::fgFunctionCallback( Proc0v p )
  89     : fgCallback(0),
  90       doPtr(&fgFunctionCallback::call0v),
  91       proc0v(p)
  92 {
  93     // empty
  94 }
  95
  96 inline fgCallback*
  97 fgFunctionCallback::clone() const
  98 {
  99     return new fgFunctionCallback( *this );
 100 }
 101
 102 inline void*
 103 fgFunctionCallback::call( void** in )
 104 {
 105     return (this->*doPtr)( in );
 106 }
 107
 108 inline void*
 109 fgFunctionCallback::call0v( void** )
 110 {
 111     (*proc0v)();
 112     return (void*) NULL;
 113 }
 114
 115 //-----------------------------------------------------------------------------
 116 //
 117 // Callback for invoking an object method.
 118 //
 119 template< class T >
 120 class fgMethodCallback : public fgCallback
 121 {
 122 public:
 123     // Pointer to method taking no arguments and returning void.
 124     typedef void (T::*Method0v)();
 125
 126     // A callback instance to invoke method 'm' of object 'o'
 127     fgMethodCallback( T* o, Method0v m )
 128         : fgCallback(0),
 129           object(o),
 130           method0v(m),
 131           doPtr(&fgMethodCallback<T>::call0v) {}
 132
 133     // Create a clone on the heap.
 134     fgCallback* clone() const;
 135
 136 private:
 137     //
 138     void* call( void** in );
 139
 140     //
 141     void* call0v( void** );
 142
 143 private:
 144     // Not defined.
 145     fgMethodCallback();
 146
 147 private:
 148     T* object;
 149     Method0v method0v;
 150
 151     typedef void * (fgMethodCallback::*DoPtr)( void ** );
 152     DoPtr doPtr;
 153 };
 154
 155 template< class T > inline fgCallback*
 156 fgMethodCallback<T>::clone() const
 157 {
 158     return new fgMethodCallback( *this );
 159 }
 160
 161 template< class T > inline void*
 162 fgMethodCallback<T>::call( void** in )
 163 {
 164     return (this->*doPtr)( in );
 165 }
 166
 167
 168 template< class T > inline void*
 169 fgMethodCallback<T>::call0v( void** )
 170 {
 171     (object->*method0v)();
 172     return (void*) NULL;
 173 }
 174
 175 #endif // _FG_CALLBACK_HXX
 176