Merge pull request #25 from macoscope/22-rename-T-to-Schema

renamed `StateMachine<T>` to `StateMachine<Schema>`

Author: narfdotpl

HISTORY.md

@@ -13,6 +13,8 @@
   you can keep using them, but if the only thing you do is `case Foo: return
   "Foo"`, you can safely delete this code.
 
+- Renamed `StateMachine<T>` to `StateMachine<Schema>`.
+
 
 ## [0.2.0][] • 2015-06-06
 

StateMachine/StateMachine.swift

@@ -64,24 +64,24 @@ public struct StateMachineSchema<A, B, C>: StateMachineSchemaType {
 /// block.  It is called after a transition with three arguments:
 /// the state before the transition, the event causing the transition,
 /// and the state after the transition.
-public final class StateMachine<T: StateMachineSchemaType> {
+public final class StateMachine<Schema: StateMachineSchemaType> {
     /// The current state of the machine.
-    public private(set) var state: T.State
+    public private(set) var state: Schema.State
 
     /// An optional block called after a transition with three arguments:
     /// the state before the transition, the event causing the transition,
     /// and the state after the transition.
-    public var didTransitionCallback: ((T.State, T.Event, T.State) -> ())?
+    public var didTransitionCallback: ((Schema.State, Schema.Event, Schema.State) -> ())?
 
     /// The schema of the state machine.  See `StateMachineSchemaType`
     /// documentation for more information.
-    private let schema: T
+    private let schema: Schema
 
     /// Object associated with the state machine.  Can be accessed in
     /// transition blocks.  Closure used to allow for weak references.
-    private let subject: () -> T.Subject?
+    private let subject: () -> Schema.Subject?
 
-    private init(schema: T, subject: () -> T.Subject?) {
+    private init(schema: Schema, subject: () -> Schema.Subject?) {
         self.state = schema.initialState
         self.schema = schema
         self.subject = subject
@@ -92,7 +92,7 @@ public final class StateMachine<T: StateMachineSchemaType> {
     /// becomes `nil`.  If the transition logic of the schema defines a transition
     /// for current state and given event, the state is changed, the optional
     /// transition block is executed, and `didTransitionCallback` is called.
-    public func handleEvent(event: T.Event) {
+    public func handleEvent(event: Schema.Event) {
         guard let
             subject = subject(),
             (newState, transition) = schema.transitionLogic(state, event)
@@ -109,18 +109,18 @@ public final class StateMachine<T: StateMachineSchemaType> {
 }
 
 
-public extension StateMachine where T.Subject: AnyObject {
+public extension StateMachine where Schema.Subject: AnyObject {
     /// Creates a state machine with a weak reference to a subject.  This helps
     /// to remove subject-machine reference cycles, but it also means you have 
     /// to keep a strong reference to a subject somewhere else.  When subject 
     /// reference becomes `nil`, transitions are no longer performed.
-    public convenience init(schema: T, subject: T.Subject) {
+    public convenience init(schema: Schema, subject: Schema.Subject) {
         self.init(schema: schema, subject: { [weak subject] in subject })
     }
 }
 
 public extension StateMachine {
-    public convenience init(schema: T, subject: T.Subject) {
+    public convenience init(schema: Schema, subject: Schema.Subject) {
         self.init(schema: schema, subject: { subject })
     }
 }