Bernie Bright:

- Major rewrite making it more member function friendly.

src/Include/fg_callback.hxx

@@ -22,169 +22,126 @@
 #ifndef _FG_CALLBACK_HXX
 #define _FG_CALLBACK_HXX
 
-#include <stdlib.h>
+/**
-
+ * Abstract base class for all FlightGear callbacks.
-// -dw- need size_t for params() function
+ */
-#ifdef __MWERKS__
-typedef unsigned long	size_t;
-#endif
-
-
-//-----------------------------------------------------------------------------
-//
-// Abstract base class for all FlightGear callbacks.
-//
 class fgCallback
 {
 public:
+
+    /**
+     * 
+     */
     virtual ~fgCallback() {}
 
+    /**
+     * 
+     */
     virtual fgCallback* clone() const = 0;
-    virtual void* call( void** ) = 0;
 
-    size_t params() const { return n_params; }
+    /**
+     * Execute the callback function.
+     */
+    virtual void operator()() = 0;
 
 protected:
-    fgCallback( size_t params )
+    /**
-	: n_params(params) {}
+     * 
-
+     */
-protected:
+    fgCallback() {}
-    // The number of parameters to pass to the callback routine.
-    size_t n_params;
 
 private:
+    // Not implemented.
+    void operator=( const fgCallback& );
 };
 
-//-----------------------------------------------------------------------------
+/**
-//
+ * Callback for invoking a file scope function.
-// Callback for invoking a file scope function.
+ */
-//
+template< typename Fun >
 class fgFunctionCallback : public fgCallback
 {
 public:
-    // Pointer to function taking no arguments and returning void.
+    /**
-    typedef void (*Proc0v)();
+     * 
+     */
+    fgFunctionCallback( const Fun& fun )
+	: fgCallback(), f_(fun) {}
 
-    // A callback instance to invoke the function 'p'
+    fgCallback* clone() const
-    fgFunctionCallback( Proc0v p );
+    {
+	return new fgFunctionCallback( *this );
+    }
 
-    // Create a clone on the heap.
+    void operator()() { f_(); }
-    virtual fgCallback* clone() const;
-
-private:
-    void* call( void** in );
-    inline void* call0v( void** );
 
 private:
     // Not defined.
     fgFunctionCallback();
 
 private:
-
+    Fun f_;
-    typedef void* (fgFunctionCallback::*DoPtr)( void** );
-    DoPtr doPtr;
-    Proc0v proc0v;
 };
 
-inline
+/**
-fgFunctionCallback::fgFunctionCallback( Proc0v p )
+ * Callback for invoking a member function.
-    : fgCallback(0),
+ */
-      doPtr(&fgFunctionCallback::call0v),
+template< class ObjPtr, typename MemFn >
-      proc0v(p)
-{
-    // empty
-}
-
-inline fgCallback*
-fgFunctionCallback::clone() const
-{
-    return new fgFunctionCallback( *this );
-}
-
-inline void*
-fgFunctionCallback::call( void** in )
-{
-    return (this->*doPtr)( in );
-}
-
-inline void*
-fgFunctionCallback::call0v( void** )
-{
-    (*proc0v)();
-    return (void*) NULL;
-}
-
-//-----------------------------------------------------------------------------
-//
-// Callback for invoking a member function.
-//
-//template< typename Ret, class T >
-template< class T >
 class fgMethodCallback : public fgCallback
 {
 public:
-    // Pointer to method taking no arguments and returning void.
-    typedef void (T::*Method0v)();
-    typedef void (T::*Method0vc)() const;
 
-    // A callback instance to invoke method 'm' of object 'o' 
+    /**
-    fgMethodCallback( T* o, Method0v m )
+     * 
-	: fgCallback(0),
+     */
-	  object(o),
+    fgMethodCallback( const ObjPtr& pObj, MemFn pMemFn )
-	  method0v(m),
+	: fgCallback(),
-	  doPtr(&fgMethodCallback<T>::call0v) {}
+	  pObj_(pObj),
+	  pMemFn_(pMemFn)
+    {
+    }
 
-    // A callback instance to invoke a const method 'm' of object 'o' 
+    /**
-    fgMethodCallback( T* o, Method0vc m )
+     * 
-	: fgCallback(0),
+     */
-	  object(o),
+    fgCallback* clone() const
-	  method0vc(m),
+    {
-	  doPtr(&fgMethodCallback<T>::call0v) {}
+	return new fgMethodCallback( *this );
+    }
 
-    // Create a clone on the heap.
+    /**
-    fgCallback* clone() const;
+     * 
-
+     */
-private:
+    void operator()()
-    //
+    {
-    void* call( void** in );
+	((*pObj_).*pMemFn_)();
-
+    }
-    //
-    void* call0v( void** );
 
 private:
     // Not defined.
     fgMethodCallback();
 
 private:
-    T* object;
+    ObjPtr pObj_;
-    union {
+    MemFn pMemFn_;
-	Method0v  method0v;
-	Method0vc method0vc;
-    };
-
-    // typedef void * (fgMethodCallback::*DoPtr)( void ** );
-    typedef void * (fgMethodCallback<T>::*DoPtr)( void ** );
-    DoPtr doPtr;
 };
 
-template< class T > inline fgCallback*
+/**
-fgMethodCallback<T>::clone() const
+ * Helper template functions.
+ */
+
+template< typename Fun >
+fgCallback*
+make_callback( const Fun& fun )
 {
-    return new fgMethodCallback( *this );
+    return new fgFunctionCallback<Fun>(fun);
 }
 
-template< class T > inline void*
+template< class ObjPtr, typename MemFn >
-fgMethodCallback<T>::call( void** in )
+fgCallback*
+make_callback( const ObjPtr& pObj, MemFn pMemFn )
 {
-    return (this->*doPtr)( in );
+    return new fgMethodCallback<ObjPtr,MemFn>(pObj, pMemFn );
-}
-
-
-template< class T > inline void*
-fgMethodCallback<T>::call0v( void** )
-{
-    (object->*method0v)();
-    return (void*) NULL;
 }
 
 #endif // _FG_CALLBACK_HXX