Chapter 1

class TState
{
public:
virtual void EnterL() = 0;
virtual TState* CompleteL() = 0;
virtual TState* ErrorL(TInt aCode) = 0;
virtual void Cancel() = 0;
};
protected:
CGdpStateMachine(TPriority aPriority);
void ChangeState(TState* aNextState);
inline TState* CurrentState();
void SetNextState(TState* aNextState);
void ReEnterCurrentState();
// Methods to be implemented by concrete state machines
virtual TState* ErrorOnStateEntry(TInt aError) = 0;
virtual TState* ErrorOnStateExit(TInt aError) = 0;
private:
// Overrides of CActive functions
void RunL();
void DoCancel();
private:
TState* iState; // Current state
};
CGdpStateMachine derives from CActive and implements the pure virtual functions
declared in that class – namely, RunL() and DoCancel(). This means that any concrete
state machine can use the features provided by CActive without actually having to redefine
these functions.
Derived concrete classes do, however, have to implement further abstract functions from
CGdpStateMachine – namely, ErrorOnStateEntry() and ErrorOnStateExit(),
which I will come to in a moment. In addition, the concrete state machine must provide
appropriate means to interface with external objects.
The state base class, TState, is defined as a nested class within CGdpStateMachine.
Each specific concrete state within a task must provide an instance of a class derived from
this base. The iState member in CGdpStateMachine points to the current state – it is
private, so derived classes must access it through the various getters and setters provided.