// Purpose. State design pattern lab
//
// Problem. A large monolithic case drives the application. As
// the program evolves, this case statemen may have to be duplicated in
// multiple places. We want to migrate to an OO design, but we need to be
// careful not to encapsulate multiple distinct "behaviors" in a single
// object.
//
// FSM: Message ==> on off ack
// State A A B C
// State B A C
// State C B
//
// Assignment.
// o Define an FSM context (wrapper, handle, interface) class
// o FSM declares a private data member of type FSMstate* to remember its
// "current state"
// o FSM defines the member functions on(), off(), and ack(). Each of these
// functions delegates to the contained object by calling its member func-
// tion of the same name, and passing the FSM's "this" pointer. [GOF, p310,
// bottom]
// o FSM declares class FSMstate as friend (because FSMstate will be setting
// the "current state" member)
// o Define an FSMstate base class
// o FSMstate defines a default implementation for all FSM messages (on, off,
// ask). The implementation of each will look like -
// virtual void on( FSM* ) { cout << "undefined combo" << endl; }
// o FSMstate defines a protected member function -
// void changeState( FSM*, FSMstate* )
// This is used by the derived state classes to set the "current state"
// member of the FSM. This "indirection" is necessary because "friendship"
// is not inherited by derived classes. [GOF, p311]
// o Declare states A, B, and C as derived classes of FSMstate
// o Design states A, B, and C as Singletons
// o Each of these classes override only those messages that they respond to
// o The bodies of the on(), off(), and ack() methods are simply the bodies
// of the "case" clauses below, except that the state machine's state is
// changed by calling the base class's changeState() method and passing the
// "instance" of the desired FSMstate derived class. [Note: state
// transitions are defined in each individual state object. This results
// in coupling between the derived classes, but it also provides for
// decentralization of intelligence or control.]
// o FSM's constructor initializes its "current state" member to state "B"
// o The body of main() reduces to "FSM fsm;" plus a minimal driver loop

#include <iostream.h>

enum State { A, B, C };
enum Message { on, off, ack };
State currentState;
Message messageArray[10] = { on,off,off,ack,ack,ack,ack,on,off,off };

void main( void ) {
currentState = B;
for (int index=0; index < 10; index++) {
if (currentState == A) {
if (messageArray[index] == on) {
cout << "A, on ==> A" << endl;
currentState = A;
} else if (messageArray[index] == off) {
cout << "A, off ==> B" << endl;
currentState = B;
} else if (messageArray[index] == ack) {
cout << "A, ack ==> C" << endl;
currentState = C;
}
} else if (currentState == B) {
if (messageArray[index] == on) {
cout << "undefined combo" << endl;
} else if (messageArray[index] == off) {
cout << "B, off ==> A" << endl;
currentState = A;
} else if (messageArray[index] == ack) {
cout << "B, ack ==> C" << endl;
currentState = C;
}
} else if (currentState == C) {
if (messageArray[index] == on) {
cout << "undefined combo" << endl;
} else if (messageArray[index] == off) {
cout << "undefined combo" << endl;
} else if (messageArray[index] == ack) {
cout << "C, ack ==> B" << endl;
currentState = B;
}
}
}
}

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