A minimalistic, thread-safe, non-boilerplate and super easy to use state machine in Swift.
Clone or download
albertodebortoli Merge pull request #3 from albertodebortoli/execution-block
Add optional execution block to process(event:callback:) function
Latest commit 1c43351 Dec 27, 2018
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
Example.playground
Example
Stateful Add optional execution block to process(event:callback:) function Dec 27, 2018
.gitignore First working version Dec 16, 2018
.travis.yml First working version Dec 16, 2018
Gemfile First working version Dec 16, 2018
Gemfile.lock First working version Dec 16, 2018
LICENSE First working version Dec 16, 2018
README.md Update README.md Dec 25, 2018
Stateful.podspec Version 2.0.0 Dec 18, 2018
_Pods.xcodeproj

README.md

Stateful 🦜

Build Status Version License Platform

The easiest state machine in Swift.

Stateful is a minimalistic, thread-safe, non-boilerplate and super easy to use state machine in Swift.

Example

  • define the events and statuses you need. E.g.:
enum EventType {
    case start
    case pause
}

enum StateType {
    case idle
    case started
}
  • create a state machine with the initial state (you might want to retain it in a property)
let stateMachine = StateMachine<StateType, EventType>(initialState: .idle)

StateMachine will use the main queue to execute the transition pre and post blocks but you can optionally provide a custom one.

let dispatchQueue = DispatchQueue(label: "com.albertodebortoli.someSerialCallbackQueue")
let stateMachine = StateMachine<StateType, EventType>(initialState: StateType.idle, callbackQueue: dispatchQueue)
  • create transitions and add them to the state machine (the state machine will automatically recognize the new statuses)
let t1 = Transition<StateType, EventType>(with: .start,
                    from: .idle,
                    to: .started)
                    
let t2 = Transition<StateType, EventType>(with: .pause,
                    from: .started,
                    to: .idle,
                    preBlock: {
                        print("Going to move from \(StateType.started) to \(StateType.idle)!")
                    }, postBlock: {
                        print("Just moved from \(StateType.started) to \(StateType.idle)!")
    })

stateMachine.add(transition: t1)
stateMachine.add(transition: t2)
  • process events like so
stateMachine.process(event: .start)
stateMachine.process(event: .pause, callback: { result in
    switch result {
    case .success:
        print("Event 'pause' was processed")
    case .failure:
        print("Event 'pause' cannot currently be processed.")
    }
})

Logging

You can optionally enable logging to print extra state change information on the console

stateMachine.enableLogging = true

Example:

[Stateful 🦜]: Processing event 'start' from 'idle'
[Stateful 🦜]: Processed pre condition for event 'start' from 'idle' to 'started'
[Stateful 🦜]: Processed state change from 'idle' to 'started'
[Stateful 🦜]: Processed post condition for event 'start' from 'idle' to 'started'
[Stateful 🦜]: Processing event 'stop' from 'started'
[Stateful 🦜]: Processed pre condition for event 'stop' from 'started' to 'idle'
[Stateful 🦜]: Processed state change from 'started' to 'idle'
[Stateful 🦜]: Processed post condition for event 'stop' from 'started' to 'idle'

Installation

Stateful is available through CocoaPods. To install it, simply add the following line to your Podfile:

pod 'Stateful'

Author

Alberto De Bortoli, albertodebortoli.website@gmail.com

License

Stateful is available under the MIT license. See the LICENSE file for more info.