Chapter 1

Exit();
break;
I just cancel the active object from here. I destroy it from its owning class's destructor – this
is the right place to destroy it, since the destructor gets called in cleanup situations, while the
command handler does not. Prior to coding this Cancel() explicitly in the exit command
handling code, my DoCancel() was being called from the active object's destructor and
was trying to draw to an environment that by then had been destroyed.
You should always be careful about doing anything fancy from an active object's
DoCancel(). Nothing in a DoCancel() should leave or allocate resources, and
DoCancel() should complete very quickly. I got myself into trouble because I don't simply
stop flashing when I cancel; instead, I restore the visibility state, which involves drawing. In
fact, this is a good rule for any kind of cleanup or destructor; just cleanup and destroy – don't
do anything else.
17.3.2 State Machines
Active objects can be used to implement state machines. As an example, say, we wish to
amalgamate the CDelayedHello and CFlashingHello functionality and so produce the
effect of the Hello world! message flashing on/off once followed by the info-message with the
same greeting. This cycle repeats until cancelled. This behavior can be represented by the
state diagram shown in Figure 17.11.
Figure 17.11
The state machine is initially in the Idle state and starting the machine moves it into the
Show Hello state. The greeting is shown and a timer is started. When the timer completes,
it notifies the state machine and it moves to the Hide Hello state – the greeting is
removed. The state machine then moves itself into the Show Info Hello state. Here, an
info-message is produced showing the greeting text. Again, the state machine moves itself
into the Wait State in which it starts a timer. When the timer completes, it notifies the
state machine and it moves to Show Hello state and the cycle repeats. Cancelling the
state machine can be done in any state and simply moves the state machine into the Idle
state.
This is a very simple state machine but demonstrates the idea. The CMultiPartHello
object implements the state machine. Essentially, it is an active object that maintains an
outstanding request once it has been started until it is cancelled.
class CMultiPartHello : public CActive
{
public: