设计模式之（State)模式

意图：
允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。
别名：
状态对象(Objects for States)
3、动机
考虑一个表示网络连接的类TCPConnection。一个TCPConnection对象的状态处于若干不同状态之一：
连接已建立（Established),正在监听(Listening),连接已关闭(Closed)。当一个TCPConnection对象
收到其他对象的请求时，它根据自身的当前状态作出不同的反应。例如，一个Open请求结果依赖于该
连接是处于连接已关闭状态还是连接已建立状态。State模式描述了TCPConnection如何在每一种状态
下表现出不同的行为。
这一模式的关键思想是引入了一个称为TCPState的抽象类来表示网络的连接状态。TCPState类为各表示
不同的操作状态的子类声明了一个公共接口。TCPState的子类实现与特定状态相关的行为。例如TCPEstablished
和TCPClosed类分别实现了特定于TCPConnection的连接已建立状态和连接已关闭状态的行为。
TCPConnection类维护一个表示TCP连接当前状态的状态对象（一个TCPState子类的实例）。TCPConnection类
将所有与状态相关的请求委托给这个状态对象。TCPConnection使用它的TCPState子类实例来执行特定于连接
状态的操作。
一旦连接状态改变，TCPConnection对象就会改变它所使用的状态对象。例如当连接从已建立状态转为已关闭
状态时，TCPConnection会用一个TCPClosed的实例来代替原来的TCPEstablished的实例。
4、适用性
在下面的两种情况下均可使用State模式：
一个对象的行为取决于它的状态，并且它必须在运行时刻根据状态改变它的行为。
一个操作中含有庞大的多分支的条件语句，且这些分支依赖于该对象的状态。（State模式将每一个条件分支放入一个独立
的类中。这使得你可以根据对象自身的情况将对象的状态作为一个对象，这一对象可以不依赖于其它对象而独立变化。
5、效果：
它将与特定状态相关的行为局部化，并且将不同状态的行为分割开来。
它使得状态转换显示化。
State对象可被共享。

代码示例：

 

// state.h: interface for the state class.
//
/**///////////////////////////////////////////////////////////////////////
#pragma  once

/**//*
*/

/**//*
*/
class TCPOctetStream;
class TCPState;

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 Transmit(TCPConnection*, TCPOctetStream*);
    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 TCPClosed : public TCPState ...{
public:
    static TCPState* Instance();

    virtual void ActiveOpen(TCPConnection*);
    virtual void PassiveOpen(TCPConnection*);
    // ...
private:
        static TCPState* _instance;

};
/**//*
*/


class TCPEstablished : public TCPState ...{
public:
    static TCPState* Instance();

    virtual void Transmit(TCPConnection*, TCPOctetStream*);
    virtual void Close(TCPConnection*);
private:
        static TCPState* _instance;

};
/**//*
*/
class TCPListen : public TCPState ...{
public:
    static TCPState* Instance();

    virtual void Send(TCPConnection*);
    // ...
private:
        static TCPState* _instance;

};




// state.cpp: implementation of the state class.
//
/**///////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "state.h"

/**///////////////////////////////////////////////////////////////////////
// Construction/Destruction
/**///////////////////////////////////////////////////////////////////////

TCPState* TCPClosed::_instance = NULL;
TCPState* TCPEstablished::_instance = NULL;
TCPState* TCPListen::_instance = NULL;
TCPConnection::TCPConnection () ...{
    _state = TCPClosed::Instance();
}
/**//*
*/
void TCPConnection::ChangeState (TCPState* s) ...{
    _state = s;
}
/**//*
*/
void TCPConnection::ActiveOpen () ...{
    _state->ActiveOpen(this);
}
/**//*
*/
void TCPConnection::PassiveOpen () ...{
    _state->PassiveOpen(this);
}
/**//*
*/
void TCPConnection::Close () ...{
    _state->Close(this);
}

/**//*
*/
void TCPConnection::Acknowledge () ...{
    _state->Acknowledge(this);
}
/**//*
*/
void TCPConnection::Synchronize () ...{
    _state->Synchronize(this);
}
/**//*
*/
void TCPState::Transmit (TCPConnection*, TCPOctetStream*) ...{ }
void TCPState::ActiveOpen (TCPConnection*) ...{ }
void TCPState::PassiveOpen (TCPConnection*) ...{ }
void TCPState::Close (TCPConnection*) ...{ }
void TCPState::Synchronize (TCPConnection*) ...{ }
/**//*
*/
void TCPState::ChangeState (TCPConnection* t, TCPState* s) ...{
    t->ChangeState(s);
}
/**//*
*/


TCPState* TCPClosed::Instance()
...{
    if(_instance == NULL)
    ...{
        _instance = new TCPClosed;
    }
    return _instance;
}
void TCPClosed::ActiveOpen (TCPConnection* t) ...{
    // send SYN, receive SYN, ACK, etc.

    ChangeState(t, TCPEstablished::Instance());
}
/**//*
*/
void TCPClosed::PassiveOpen (TCPConnection* t) ...{
    ChangeState(t, TCPListen::Instance());
}
/**//*
*/

TCPState* TCPEstablished::Instance()
...{
    if(_instance == NULL)
    ...{
        _instance = new TCPEstablished;
    }
    return _instance;
}
void TCPEstablished::Close (TCPConnection* t) ...{
    // send FIN, receive ACK of FIN

    ChangeState(t, TCPListen::Instance());
}
/**//*
*/
void TCPEstablished::Transmit (
    TCPConnection* t, TCPOctetStream* o
) ...{
    t->ProcessOctet(o);
}
/**//*
*/

TCPState* TCPListen::Instance()
...{
    if(_instance == NULL)
    ...{
        _instance = new TCPListen;
    }
    return _instance;
}
void TCPListen::Send (TCPConnection* t) ...{
    // send SYN, receive SYN, ACK, etc.

    ChangeState(t, TCPEstablished::Instance());
}
/**//*
*/