// Purpose. State #include <iostream.h>
//
// Discussion. The boss's behavior is class Boss {
// "morphing" radically as a function public:
// of his mood. Operations have large friend class Disposition;
// "case" constructs that depend on Boss();
// this "state" attribute. Like large void decide();
// procedures, large conditional stmts void direct();
// are undesirable. They're monolith- private:
// ic, and tend to make maintenance Disposition* moods_[2];
// very difficult. The State pattern int current_;
// models individual states with de- };
// rived classes of an inheritance
// hierarchy, and front-ends this class Disposition {
// hierarchy with an "interface" public:
// object that knows its "current" virtual void decide( Boss* ) = 0;
// state. This partitions and local- virtual void direct( Boss* ) = 0;
// izes all state-specific responsi- protected:
// bilities; allowing for a cleaner void toggle( Boss* b ) {
// implementation of dynamic behavior b->current_ = ! b->current_; }
// that must change as internal state };
// changes.
class DilbertZone :
class Boss { public Disposition { public:
public: void decide( Boss* b ) {
Boss() { cout << "Eenie, meenie, mynie,";
mood_ = DilbertZone; cout << " moe.\n"; toggle(b); }
} void direct( Boss* b ) {
void decide() { cout << "My whim - you're";
if (mood_ == DilbertZone) { cout << " nightmare.\n";
cout << "Eenie, meenie,"; toggle(b); }
cout << " mynie, moe.\n"; };
} class Sunny :
else if (mood_ == Sunny) { public Disposition { public:
cout << "You need it - you"; void decide( Boss* b ) {
cout << " got it.\n"; cout << "You need it - you got";
} cout << " it.\n"; toggle(b); }
toggle(); void direct( Boss* b ) {
} cout << "Follow me.\n";
void direct() { toggle(b); }
if (mood_ == DilbertZone) { };
cout << "My whim - you're";
cout << " nightmare.\n"; Boss::Boss() {
} moods_[0] = new DilbertZone;
else if (mood_ == Sunny) moods_[1] = new Sunny;
cout << "Follow me.\n"; current_ = 0; }
toggle(); void Boss::decide() {
} moods_[current_]->decide( this ); }
private: void Boss::direct() {
enum Disposition { Sunny, moods_[current_]->direct( this ); }
DilbertZone};
Disposition mood_; void main( void )
void toggle() { mood_ = ! mood_; } {
}; Boss ph;
for (int i=0; i < 2; i++) {
void main( void ) ph.decide();
{ ph.decide();
Boss ph; ph.direct(); }
for (int i=0; i < 2; i++) }
{ // Eenie, meenie, mynie, moe.
ph.decide(); // You need it - you got it.
ph.decide(); // My whim - you're nightmare.
ph.direct(); // You need it - you got it.
} // Eenie, meenie, mynie, moe.
} // Follow me.




// Purpose. State design pattern - an FSM with two states and
// two events (distributed transition logic - logic in the
// derived state classes)

#include <iostream> \ Event on off
using namespace std; State \ ------- -------
ON nothing OFF
class Machine { OFF ON nothing
class State* current;
public:
Machine();
void setCurrent( State* s ) { current = s; }
void on();
void off();
};

class State {
public:
virtual void on( Machine* m ) { cout << " already ON\n"; }
virtual void off( Machine* m ) { cout << " already OFF\n"; }
};

void Machine::on() { current->on( this ); }
void Machine::off() { current->off( this ); }

class ON : public State {
public:
ON() { cout << " ON-ctor "; };
~ON() { cout << " dtor-ON\n"; };
void off( Machine* m );
};

class OFF : public State {
public:
OFF() { cout << " OFF-ctor "; };
~OFF() { cout << " dtor-OFF\n"; };
void on( Machine* m ) {
cout << " going from OFF to ON";
m->setCurrent( new ON() );
delete this;
}
};

void ON::off( Machine* m ) {
cout << " going from ON to OFF";
m->setCurrent( new OFF() );
delete this;
}

Machine::Machine() { current = new OFF(); cout << '\n'; }

void main( void ) {
void (Machine::*ptrs[])() = { Machine::off, Machine::on };
Machine fsm;
int num;
while (1) {
cout << "Enter 0/1: ";
cin >> num;
(fsm.*ptrs[num])();
} }

// OFF-ctor
// Enter 0/1: 0
// already OFF
// Enter 0/1: 1
// going from OFF to ON ON-ctor dtor-OFF
// Enter 0/1: 1
// already ON
// Enter 0/1: 0
// going from ON to OFF OFF-ctor dtor-ON
// Enter 0/1: 1
// going from OFF to ON ON-ctor dtor-OFF
// Enter 0/1: 0
// going from ON to OFF OFF-ctor dtor-ON
// Enter 0/1: 0
// already OFF
// Enter 0/1:




// Purpose. State design pattern - an FSM with two states and two events
// (distributed transition logic - logic in the derived state classes)

// State\Event Suck up money Drive through
//
// RedLight you're a you're
// victim, dead,
// maybe change change to RED
// to GREEN
//
// GreenLight you're an you're free
// idiot but you're
// still a victim,
// change to RED

#include <iostream>
#include <ctime>
using namespace std;

class FSM {
class State* current;
public:
FSM();
void setCurrent( State* s ) { current = s; }
void suckUpMoney( int );
void carDrivesThrough();
};

class State {
int total;
protected:
int getTotal() { return total; }
public:
State() { total = 0; }
virtual void suckUpMoney( int in, FSM* fsm ) {
total += in;
cout << "total is " << total << '\n';
}
virtual void carDrivesThrough( FSM* fsm ) = 0;
};

class GreenLight : public State {
public:
GreenLight() { cout << "GREEN light\n"; }
void suckUpMoney( int in, FSM* fsm ) {
cout << " You're an idiot, ";
State::suckUpMoney( in, fsm );
}
void carDrivesThrough( FSM* fsm );
};

class RedLight : public State {
public:
RedLight() { cout << "RED light\n"; }
void suckUpMoney( int in, FSM* fsm ) {
cout << " ";
State::suckUpMoney( in, fsm );
if (getTotal() >= 50) {
fsm->setCurrent( new GreenLight );
delete this;
} }
void carDrivesThrough( FSM* fsm ) {
cout << "Sirens!! Heat-seeking missile!! Confiscate net worth!!\n";
fsm->setCurrent( new RedLight );
delete this;
} };

FSM::FSM() {
current = new RedLight();
}
void FSM::suckUpMoney( int in ) {
current->suckUpMoney( in, this );
}
void FSM::carDrivesThrough() {
current->carDrivesThrough( this );
}
void GreenLight::carDrivesThrough( FSM* fsm ) {
cout << "Good-bye sucker!!\n";
fsm->setCurrent( new RedLight );
delete this;
}

int getCoin() {
static int choices[3] = { 5, 10, 25 };
return choices[rand() % 3];
}

void main( void ) {
srand( time(0) );
FSM fsm;
int ans;
while (true) {
cout << " Shell out (1), Drive thru (2), Exit (0): ";
cin >> ans;
if (ans == 1) fsm.suckUpMoney( getCoin() );
else if (ans == 2) fsm.carDrivesThrough();
else break;
} }



// Purpose. State demo (centralized transition logic - logic in the FSM)
//
// Discussion. Who defines the state transitions? The State pattern does not
// specify which participant defines the criteria for state transitions. The
// logic can be implemented entirely in the Context (FSM). It is generally
// more flexible and appropriate, however, to let the State subclasses them-
// selves specify their successor state and when to make the transition. This
// requires adding an interface to the Context that lets State objects set the
// Context's current state explicitly. A disadvantage of decentralization is
// that State subclasses will be coupled to other sibling subclasses. [GOF308]

#include <iostream.h>

class FSMstate { public:
virtual void on() { cout << "undefined combo" << endl; }
virtual void off() { cout << "undefined combo" << endl; }
virtual void ack() { cout << "undefined combo" << endl; } };

class FSM {
public:
FSM();
void on() { states[current]->on(); current = next[current][0]; }
void off() { states[current]->off(); current = next[current][1]; }
void ack() { states[current]->ack(); current = next[current][2]; }
private:
FSMstate* states[3];
int current;
int next[3][3];
};

class A : public FSMstate { public:
void on() { cout << "A, on ==> A" << endl; }
void off() { cout << "A, off ==> B" << endl; }
void ack() { cout << "A, ack ==> C" << endl; }
};
class B : public FSMstate { public:
void off() { cout << "B, off ==> A" << endl; }
void ack() { cout << "B, ack ==> C" << endl; }
};
class C : public FSMstate { public:
void ack() { cout << "C, ack ==> B" << endl; }
};

FSM::FSM() {
states[0] = new A; states[1] = new B; states[2] = new C;
current = 1;
next[0][0] = 0; next[0][1] = 1; next[0][2] = 2;
next[1][0] = 1; next[1][1] = 0; next[1][2] = 2;
next[2][0] = 2; next[2][1] = 2; next[2][2] = 1; }

enum Message { On, Off, Ack };
Message messageArray[10] = { On,Off,Off,Ack,Ack,Ack,Ack,On,Off,Off };

void main( void ) {
FSM fsm;
for (int i = 0; i < 10; i++) {
if (messageArray[i] == On) fsm.on();
else if (messageArray[i] == Off) fsm.off();
else if (messageArray[i] == Ack) fsm.ack(); }
}

// undefined combo // B, ack ==> C
// B, off ==> A // C, ack ==> B
// A, off ==> B // undefined combo
// B, ack ==> C // B, off ==> A
// C, ack ==> B // A, off ==> B