State模式

意图：允许一个对象在其内部状态改变时改变它的行为；对象看起来似乎修改了它的类；在一个状态即将结束的时候启用下一个状态，可以是一个按需的连锁反应；

适用性：

1、一个对象的行为取决于它的状态，并且它必须在运行过程中可以根据它的状态改变它的行为；

2、一个操作中含有庞大的多分支的条件语句，并且这些分支依赖于该对象的状态；这个状态通常使用一个或多个枚举常量表示；通常，有多个操作包含这一相同的条件结构；State模式把每一个条件分支放入一个独立的类中；这使得你可以根据对象自身的情况把对象的状态作为一个对象，而且这一对象可以不依赖于其它对象而独立变化；

结构图：

应用：
#ifndef _STATE_H_
#define _STATE_H_

#include <iostream>
#include <string>

using namespace std;

class TCPStream;

//需要被改变状态的对象类;它聚合了一个状态对象:TCPState;依据TCPState对象的变化来改变TCPConnection对象的行为;
class TCPConnection
{
  public:
    TCPConnection(void);
    ~TCPConnection(void);

    void ActiveOpen(void);
    void PassiveOpen(void);
    void Close(void);
    void Send(void);
    void Acknowledge(void);
    void Synchronize(void);
    void ProcessStream(TCPStream*);

  private:
    friend class TCPState;
    void ChangeState(TCPState*);

  private:
    TCPState* m_lpState;
};

//TCPConnection类对象的状态对象:TCPState;它实现为一个纯虚基类;
class TCPState
{
  public:
    TCPState(void);
    virtual ~TCPState(void);
    virtual void Transmit(TCPConnection*, TCPStream*);
    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:
    virtual ~TCPEstablished(void);
    static TCPState* Instance(void);
    virtual void Transmit(TCPConnection*, TCPStream*);
    virtual void Close(TCPConnection*);

  private:
    TCPEstablished(void);
};

//连接关闭状态
class TCPClosed: public TCPState
{
  public:
    virtual ~TCPClosed(void);
    static TCPState* Instance(void);
    virtual void ActiveOpen(TCPConnection*);
    virtual void PassiveOpen(TCPConnection*);
  private:
    TCPClosed(void);
};

//监听状态类
class TCPListen: public TCPState
{
  public:
    ~TCPListen(void);
    static TCPState* Instance(void);
    virtual void Send(TCPConnection*);
  private:
    TCPListen(void);
};

TCPConnection::TCPConnection(void)
{
  this->m_lpState = TCPClosed::Instance();
  cout << "call TCPConnection()" << endl;
}

TCPConnection::~TCPConnection(void)
{
  cout << "call ~ TCPConnection()" << endl;
}

void TCPConnection::ActiveOpen(void)
{
  this->m_lpState->ActiveOpen(this);
  cout << "TCPConnection active-open state" << endl;
}

void TCPConnection::PassiveOpen(void)
{
  this->m_lpState->PassiveOpen(this);
  cout << "TCPConnection passive-open state" << endl;
}

void TCPConnection::Close(void)
{
  this->m_lpState->Close(this);
  cout << "TCPConnection close state" << endl;
}

void TCPConnection::Send(void)
{
  this->m_lpState->Send(this);
  cout << "TCPConnection send state" << endl;
}

void TCPConnection::Acknowledge(void)
{
  this->m_lpState->Acknowledge(this);
  cout << "TCPConnection ack state" << endl;
}

void TCPConnection::Synchronize(void)
{
  this->m_lpState->Synchronize(this);
  cout << "TCPConnection sync state" << endl;
}

void TCPConnection::ProcessStream(TCPStream* st)
{
  cout << "TCPConnection ProcessStream" << endl;
}

void TCPConnection::ChangeState(TCPState* state)
{
  if(this->m_lpState)
  {
    delete this->m_lpState;
    this->m_lpState = NULL;
  }
  this->m_lpState = state;
  cout << "TCPConnection::ChangeState()" << endl;
}

TCPState::TCPState(void)
{
  cout << "call TCPState()" << endl;
}

TCPState::~TCPState(void)
{
  cout << "call ~ TCPState()" << endl;
}

void TCPState::Transmit(TCPConnection*, TCPStream*)
{
  cout << "TCPState::Transmit()" << endl; 
}

void TCPState::ActiveOpen(TCPConnection*)
{
  cout << "TCPState::ActiveOpen()" << endl; 
}

void TCPState::PassiveOpen(TCPConnection*)
{
  cout << "TCPState::PassiveOpen()" << endl; 
}

void TCPState::Close(TCPConnection*)
{
  cout << "TCPState::Close()" << endl; 
}

void TCPState::Synchronize(TCPConnection*)
{
  cout << "TCPState::Synchronize()" << endl; 
}

void TCPState::Acknowledge(TCPConnection*)
{
  cout << "TCPState::Acknowledge()" << endl; 
}

void TCPState::Send(TCPConnection*)
{
  cout << "TCPState::Send()" << endl; 
}

void TCPState::ChangeState(TCPConnection* conn, TCPState* state)
{
  cout << "TCPState::ChangeState()" << endl; 
  conn->ChangeState(state);
}

//监听状态类
TCPListen::~TCPListen(void)
{
  cout << "call ~ TCPListen()" << endl;
}

TCPState* TCPListen::Instance(void)
{
  return new TCPListen();
}

void TCPListen::Send(TCPConnection* conn)
{
  //send SYN, recv SYN ACK, etc;
  this->ChangeState(conn, TCPEstablished::Instance());
}

TCPListen::TCPListen(void)
{
  cout << "call TCPListen()" << endl;
}

TCPClosed::~TCPClosed(void)
{
  cout << "call ~ TCPClosed()" << endl;
}

TCPState* TCPClosed::Instance(void)
{
  return new TCPClosed();
}

TCPClosed::TCPClosed(void)
{
  cout << "call TCPClosed()" << endl;
}

void TCPClosed::ActiveOpen(TCPConnection* conn)
{
  //send SYN, receive SYN,ACK;  etc.
  this->ChangeState(conn, TCPEstablished::Instance());
}

void TCPClosed::PassiveOpen(TCPConnection* conn)
{
  // send FIN, receive ACK of FIN, etc;
  this->ChangeState(conn, TCPListen::Instance());
}

TCPEstablished::~TCPEstablished(void)
{
  cout << "call ~ TCPEstablished()" << endl;
}

TCPState* TCPEstablished::Instance(void)
{
  return new TCPEstablished();
}

void TCPEstablished::Transmit(TCPConnection* conn, TCPStream* st)
{
  conn->ProcessStream(st);
}

void TCPEstablished::Close(TCPConnection* conn)
{
  this->ChangeState(conn, TCPListen::Instance());
}

TCPEstablished::TCPEstablished(void)
{
  cout << "call TCPEstablished()" << endl;
}

class StateApplication
{
  public:
    StateApplication(void);
    ~StateApplication(void);

    int doRun(void);
};

StateApplication::StateApplication(void){}

StateApplication::~StateApplication(void){}

int StateApplication::doRun(void)
{
  TCPConnection  tcpConn;
  tcpConn.ActiveOpen();
  tcpConn.Acknowledge();
  tcpConn.Send();
  tcpConn.Synchronize();
  tcpConn.Close();
  tcpConn.PassiveOpen();
  tcpConn.Close();
  return 0;
}
#endif
#include "State.h"

int main(int argc, char** argv)
{
  StateApplication oApp;

  oApp.doRun();
  return 0;
}