State design pattern in MQL4?

//////////////////////DECLARATIONS
//forward declaration, otherwise the compiler doesn't know how to manage it within the
//Breakout declaration itself
class State; 
/**
* This class provides the "cotext" or "controller" class of all the
* state design
*/
class Context {
 public:
                Context();  //Constructor
  virtual void  ~Context(); //Destructor
  //The methods which will be implemented in the various states, which
  //correspond to the transitions into a state diagram
  virtual void  GetDownTick();
  virtual void  GetUpTick();
  //Common method SetCurrent will set the current state
  void  SetCurrent(State* state);
  //The various states are class-wide instances of the State objects
  State* bullish_state_;
  State* bearish_state_;
  //And the state_ one will hold the current state
  State* state_;
};

/**
* This is the generic interface defining how a state should look like
*/
class State {
 public:
  //it contains the methods-transitions, defined with a pointer to the
  //context class
  virtual void GetDownTick(Context* my_ctxt) = 0;
  virtual void GetUpTick(Context* my_ctxt) = 0;
};

/**
* Then we need to define the concrete implementation of the defined states,
* in this case BullishState and BearishState
*/
class BullishState : public State {
 public:
                BullishState();
  virtual       ~BullishState();
  virtual void  GetDownTick(Context* my_ctxt);
  virtual void  GetUpTick(Context* my_ctxt);
};

class BearishState : public State {
 public:
                BearishState();
  virtual       ~BearishState();
  virtual void  GetDownTick(Context* my_ctxt);
  virtual void  GetUpTick(Context* my_ctxt);
};

/////////////////// end of DECLARATIONS

/////////////////// DEFINITIONS

/**
* Let's start constructing the context. The constructor prints out
* its performance for demonstration purposes and instantiates its objects
*/
Context::Context(void) {
  Print("Constructing the context");
  // instantiating the state objects
  bearish_state_ = new BearishState();
  bullish_state_ = new BullishState();
  state_ = bullish_state_; //you must start from somewhere....
}

/**
* Also the destructor is verbose and performs memory clean-up
*/
Context::~Context(void) {
  Print("I am destroying the Context");
  delete  bearish_state_;
  delete  bullish_state_;
  bearish_state_  = NULL;
  bullish_state_  = NULL;
}


/**
* Now we define the method-transitions. In the context, they simply delegate to
* the concrete state's  implementations. Easy!
* The "GetPointer(this)" construct is a horrible mql4 syntactic sugar which is
* absurdely mimicking what is in every other language is the obvious use of the
* keyword "this" (what else could "this" mean if not returning the pointer of
* "this"????). But we can live with inelegance, as long as it works!!!!!
*/
void Context::GetDownTick(void) {
  Print(__FUNCTION__ " was called and transfers action to the concrete state");
  state_.GetDownTick(GetPointer(this));
}

void Context::GetUpTick(void) {
  Print(__FUNCTION__ " was called and transfers action to the concrete state");
  state_.GetUpTick(GetPointer(this));
}

/**
* Finally we define the SetState method, which provides for State transitions,
* of course
* \param *state the pointer to the relevant State object instance
*/
void Context::SetCurrent(State *state) {
  Print(__FUNCTION__ " was called and changes state to ", state);
  state_ = state;
}

/**
* Now we provide the implementation of the concrete states and we are done!
* Constructors and destructors here will be pretty silly and will be just
* made "loud" to speak out that they have been called
*/
BullishState::BullishState(void) {
  Print("BullishState constructed!");
}

BullishState::~BullishState(void) {
  Print("BullishState destroyed!");
}

/**
* And here the implementation of the concrete actions that must be performed,
* conditionally, when we are in the different states. Here, for instance,
* what we do when we get a down tick and we are in the bullish state: we
* print a nice message and we switch to the bearish state (i.e. we instruct
* the context that we need to switch state)
* \param *my_ctxt the pointer to the context that must control the whole machine
*/
void BullishState::GetDownTick(Context *my_ctxt) {
  Print(__FUNCTION__, " called with a down tick");
  Print("I was so glad to be in a bullish state!");
  Print("I have to notify the context that we have to change state");
  my_ctxt.SetCurrent(my_ctxt.bearish_state_);
}

/**
* Here, we do when we get an up tick and we are in the bullish state: we
* print a nice message and we remain into same state
* \param *my_ctxt the pointer to the context that must control the whole machine
*/
void BullishState::GetUpTick(Context *my_ctxt) {
  Print(__FUNCTION__, " called with an up tick");
  Print("I am happy that we remain bullish, and we have nothing else to do!");
  return;
}

/**
* Constructor and destructor have merely demonstration purposes
*/
BearishState::BearishState(void) {
  Print("Constructing BearishState!");
}

BearishState::~BearishState(void) {
  Print("Destroying BearhisState!");
}

/**
* If we come with a down tick when we are in a bearish status the situation is
* reversed: we are happy and we remain in the same status!
* \param *my_ctxt the pointer to the context that must control the whole machine
*/
void BearishState::GetDownTick(Context *my_ctxt) {
  Print(__FUNCTION__, " called with a down tick");
  Print("I am happy that we remain bearish, and we have nothing else to do!");
  return;
}

/**
* If we come with an up tick when we are in a bearish state, we notify the situation
* and we instruct the contexts that we have to change state to bullish state and the
* cycle will go on over and over again...
*/
void BearishState::GetUpTick(Context *my_ctxt) {
  Print(__FUNCTION__, " called with an up tick");
  Print("I was so glad to be in a bearish state!");
  Print("I have to notify the context that we have to change state");
  my_ctxt.SetCurrent(my_ctxt.bullish_state_);
}

#property version   "1.00"
#property strict

#include <Sandbox/StateTemplate.mqh>
Context* my_sentiment = NULL;
//+---------------------------------------------------------------------------+
//| Expert initialization function                                            |
//+---------------------------------------------------------------------------+
int OnInit() {
  my_sentiment = new Context();
  return(INIT_SUCCEEDED);
}
//+---------------------------------------------------------------------------+
//| Expert deinitialization function                                          |
//+---------------------------------------------------------------------------+
void OnDeinit(const int reason) {
  delete my_sentiment;
  my_sentiment = NULL;
}
//+---------------------------------------------------------------------------+
//| Expert tick function                                                      |
//+---------------------------------------------------------------------------+
void OnTick() {
  if (Close[0] > Close[1]) {
    my_sentiment.GetUpTick();
  } else {
    my_sentiment.GetDownTick();
  }
  return;
}