state

#include <iostream>
using namespace std;
class tcpoctetstream;
class tcpstate;
class tcpclosed;
class tcpconnection {
public:
  tcpconnection();
  void activeopen();
  void passiveopen();
  void close();
  void send();
  void acknowledge();
  void synchronize();
  void processoctet(tcpoctetstream *);
private:
  friend class tcpstate;
  void changestate(tcpstate *);
private:
  tcpstate * _state;
};
class tcpstate {
public:
  virtual void activeopen(tcpconnection *){}
  virtual void passiveopen(tcpconnection *){}
  virtual void close(tcpconnection *){}
  virtual void synchronize(tcpconnection *){}
  virtual void acknowledge(tcpconnection *){}
  virtual void send(tcpconnection *){}
protected:
  void changestate(tcpconnection *, tcpstate *);
};
class tcpestablished : public tcpstate {
public:
  static tcpstate *instance();
  virtual void close(tcpconnection *){}
private:
  static tcpestablished* _instance;
};
tcpestablished * tcpestablished::_instance = 0;
tcpstate *tcpestablished::instance()
{
  if (_instance == 0)
    _instance = new tcpestablished;
  cout << "tcp established" << endl;
  return _instance;
}
class tcpclosed : public tcpstate {
public:
  static tcpstate *instance();
  virtual void activeopen(tcpconnection *);
  virtual void passiveopen(tcpconnection *);
private:
  static tcpclosed * _instance;
};
tcpclosed *tcpclosed::_instance = 0;
tcpstate *tcpclosed::instance()
{
  if (_instance == 0)
    _instance = new tcpclosed;
  cout << "tcp closed" << endl;
  return _instance;
}
class tcplisten : public tcpstate {
public:
  static tcpstate *instance();
private:
  static tcplisten *_instance;
};
tcplisten *tcplisten::_instance = 0;
tcpstate *tcplisten::instance()
{
  if (_instance == 0)
    _instance = new tcplisten;
  cout << "tcp listen" << endl;
  return _instance;
}
void tcpclosed::activeopen(tcpconnection *t)
{
  changestate(t, tcpestablished::instance());
}
void tcpclosed::passiveopen(tcpconnection *t)
{
  changestate(t, tcplisten::instance());
}
tcpconnection::tcpconnection(){ _state = tcpclosed::instance();}
void tcpconnection::activeopen(){_state->activeopen(this);}
void tcpconnection::passiveopen(){_state->passiveopen(this);}
void tcpconnection::close(){_state->close(this);}
void tcpconnection::synchronize(){_state->synchronize(this);}
void tcpconnection::acknowledge(){_state->acknowledge(this);}
void tcpconnection::send(){_state->send(this);}
void tcpconnection::changestate(tcpstate *newstate){_state = newstate;}
void tcpstate::changestate(tcpconnection *t, tcpstate *s)
{
  t->changestate(s);
}

int main()
{
  tcpconnection *tconn = new tcpconnection;
  tconn->activeopen();
  tconn->passiveopen();
  delete tconn;
  return 0;
}