This document describes the TCallBack class.
The class encapsulates a pointer to a function which takes an argument of type TAny* and returns a TInt. The class is generally useful but, in particular, simplifies the programming interface of the CIdle and CPeriodic classes.
Given a suitable function and a pointer to an object, a callback is constructed simply. The function must be a non-member function or a static member of a class. For example:
TInt Foo(TAny *); // a non-member function X* pX=new X; // a class X object
or, as a static member of class X:
TInt X::Foo(TAny *); // a static function of class X X* pX=new X; // a class X object
A callback function returns a true value to indicate whether it should be called again. This is important when used with the CIdle and CPeriodic classes. The following code fragment shows the programming paradigm:
TCallBack cb(Foo,pX); // construction of the callback
for (;;) { if (!cb.CallBack()) // invoke callback until it returns { // a false value break; } }
Calling cb.CallBack() results in a call to the callback function Foo() passing it the pointer pX.
A common requirement is for the callback function to be a non-static member of a class. This can be implemented by passing, to the callback function, a pointer to an instance of the class of which it is a static member. For example:
class X { static X* NewL(); static TInt Foo(TAny* pX); private: TInt DoFoo(); ... }
where the static function Foo() is implemented as:
static TInt X::Foo(TAny* pX) { return ((X*)pX)->DoFoo(); }
Typically, create an instance of class X and, at some later stage, create the callback:
... X* pX = X::NewL(); ... TCallBack cb(Foo,pX); ...