swift 状态机

先说下状态机 :
意图:允许一个对象在其状态改变时，改变它的行为。看起来对象似乎修改了它的类。
适用性:
1、一个对象的行为取决于它的状态，并且它必须在运行过程中可以根据它的状态改变它的行为；
2、一个操作中含有庞大的多分支的条件语句，并且这些分支依赖于该对象的状态；这个状态通常使用一个或多个枚举常量表示；通常，有多个操作包含这一相同的条件结构；State模式把每一个条件分支放入一个独立的类中；这使得你可以根据对象自身的情况把对象的状态作为一个对象，而且这一对象可以不依赖于其它对象而独立变化；

• 示例如下

  
  
• 简单来说 你的对象的行为取决于state 就可以算是状态机 ，比如我们APP中实现的promise 也是一种状态机，

 [QXPromise promise:^(ResolveHandler resolve, RejectHandler reject) {
        //                    bill_id=&user_id=
    [[MXNetTool defaultManager] getWithParams:@{@"bill_id":model.model.bill_id,@"user_id":[AppSetting appsetting].userid} url:Biztask_cancelbill success:^(NSURLSessionDataTask *task, id responseObject) {
              resolve(responseObject[responseObject]);   
        } failure:^(NSURLSessionDataTask *task, NSError *error) {
            reject(error);
        }];
        
    }].then(^id(id data){
        
        if ([data[@"data"] isEqualToString:CODE200]) {
            [self showMXHint:@"取消账单成功" yOffset:0];
        }
        
        return nil;
    })
.catch(^id(NSError *e){
        [self showHint:e];
}).finally(^(){
        
    });

• 废话少说 我们看下实现一个swift状态机
  stateMachine
event
state
  将会实现这三个类。
  event 会绑定事件，有原始状态至目标状态。
  state绑定每个状态进入或退出的事件。
  statemachine 会操作event。

---

event 代码

open class Event<T:Hashable> : Equatable {
    open let name : String
    open let sourceValues:[T]
    open let destinationValue:T
    
    open var shouldFireEvent:((_ event:Event)->Bool)?
    
    open var willFireEvent:((_ event:Event)->Void)?
    
    open var didFireEvent:((_ event:Event)->Void)?
    
    required public init(name:String,sourceValues sources:[T],destinationValue destination:T){
        self.name = name
        self.sourceValues = sources
        self.destinationValue = destination
    }
    
    static open func == (lhs:Event<T>,rhs:Event<T>)->Bool{
        return lhs.name == rhs.name
    }
}

看到 event绑定了事件以及状态。

---

state

open class State<T:Hashable> {
    
    public typealias enterStateHandle = ((_ enteringState:State<T>)->Void)
    open let value:T
    open var willEnterState:enterStateHandle?
    
    open var didEnterState:enterStateHandle?
    
    open var willExitState: enterStateHandle?
    
    open var didExitState: enterStateHandle?
    
    public init(_ value:T){
        self.value = value
    }
    
    
}

同样 state也会绑定事件 以及值 该值为你的几种状态。一般可以为枚举。

---

现在就差状态机了

open class StateMachine<T:Hashable> {
    var initialState:State<T>
open private(set) var currentState:State<T>
    
    private lazy var availableStates:[State<T>] = []
    
    private lazy var events : [Event<T>] = []
    
    required public init(initialState:State<T>){
        self.initialState = initialState;
        self.currentState = initialState;
        availableStates.append(initialState)
    }

    open func activateState(_ stateValue:T) {
        if (isStateAvailable(stateValue)){
            let oldState = currentState
            let newState = stateWithValue(stateValue)!
            
            newState.willEnterState?(newState)
            oldState.willExitState?(oldState)
            
            currentState = newState
            
            oldState.didExitState?(oldState)
            newState.didEnterState?(newState)
        }

    @discardableResult
    open func fireEvent(_ event:Event<T>) -> Transition<T> {
        return _fireEventNamed(event.name)
    }
    
    @discardableResult
    open func fireEvent(_ eventName:String) ->Transition<T> {
        return _fireEventNamed(eventName)
    }
    }

private extension StateMachine {
    
    func _fireEventNamed(_ eventName:String)->Transition<T> {
        if let event = eventWithName(eventName) {
            let possibleTransition = possibleTransitionForEvent(event)
            
            switch possibleTransition {
            case .success(sourceState: let sourceState, destinationState: let destinationState):
                
                if let shouldBlock = event.shouldFireEvent {
                    if shouldBlock(event) {
                        event.willFireEvent?(event)
                        activateState(event.destinationValue)
                        event.didFireEvent?(event)
                        return Transition.success(sourceState: sourceState, destinationState: destinationState)
                    } else {
                        return Transition.error(.transitionDeclined)
                    }
                }
                else {
                    let sourceState = self.currentState
                    event.willFireEvent?(event)
                    activateState(event.destinationValue)
                    event.didFireEvent?(event)
                    return Transition.success(sourceState: sourceState, destinationState: destinationState)
                }
                
            default:
                return possibleTransition
            }
        } else {
            return Transition.error(.unknownEvent)
        }
    }
 }

 }

下面就不贴代码了。
statemachine 绑定了事件以及 状态。若需要改变状态，只需要调用 fireEvenet即可 如若调用成功将会触发state以及event绑定的事件。

以下为测试代码

var machine: StateMachine<String>!
let state = State("Initial")
state.willExitState = { _ in
    print("fuck 1")
}

state.willEnterState = { _ in
    print("fuck 2")
}

state.didEnterState = { _ in
    print("fuck 3")
}

state.didExitState = { _ in
    print("fuck 4")
}
let passedState = State("Passed")

passedState.willExitState = { _ in
    print("fuck pass 1")
}

passedState.willEnterState = { _ in
    print("fuck pass 2")
}

passedState.didEnterState = { _ in
    print("fuck pass 3")
}

passedState.didExitState = { _ in
    print("fuck pass 4")
}
machine = StateMachine(initialState: state)
machine.addState(passedState)

let event = Event(name: "Pass", sourceValues: ["Initial"], destinationValue: "Passed")

 _ = try? machine.addEvent(event)

let transition = machine.fireEvent("Pass")

let event2 = Event(name: "Pass3", sourceValues: ["Passed"], destinationValue: "Initial")
 _ = try? machine.addEvent(event2)
let transition2 = machine.fireEvent("Pass3")

执行结果为

fuck pass 2
fuck 1
fuck 4
fuck pass 3
fuck 2
fuck pass 1
fuck pass 4
fuck 3

此状态机还是比较好理解的。虽然我们用枚举也能很方便的知道状态变化。但是这种做法更加抽象。并且代码也是漂亮的。