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