Conform State<S> & Event<E> to RawRepresentable.

Sources/EventType.swift

@@ -10,25 +10,41 @@ public protocol EventType: Hashable {}
 
 // MARK: Event
 
-/// `EventType` wrapper for handling`.Any` event.
-public enum Event<E: EventType>: Hashable
+/// `EventType` wrapper for handling `.Any` event.
+public enum Event<E: EventType>
 {
     case Some(E)
     case Any
-
-    public var value: E?
+}
+
+extension Event: Hashable
+{
+    public var hashValue: Int
     {
         switch self {
-            case .Some(let x):  return x
-            default:            return nil
+            case .Some(let x):  return x.hashValue
+            case .Any:          return _hashValueForAny
+        }
+    }
+}
+
+extension Event: RawRepresentable
+{
+    public init(rawValue: E?)
+    {
+        if let rawValue = rawValue {
+            self = .Some(rawValue)
+        }
+        else {
+            self = .Any
         }
     }
 
-    public var hashValue: Int
+    public var rawValue: E?
     {
         switch self {
-            case .Some(let x):  return x.hashValue
-            case .Any:          return _hashValueForAny
+            case .Some(let x):  return x
+            default:            return nil
         }
     }
 }
@@ -45,6 +61,16 @@ public func == <E: EventType>(lhs: Event<E>, rhs: Event<E>) -> Bool
     }
 }
 
+public func == <E: EventType>(lhs: Event<E>, rhs: E) -> Bool
+{
+    return lhs.hashValue == rhs.hashValue
+}
+
+public func == <E: EventType>(lhs: E, rhs: Event<E>) -> Bool
+{
+    return lhs.hashValue == rhs.hashValue
+}
+
 // MARK: NoEvent
 
 /// Useful for creating StateMachine without events, i.e. `StateMachine<MyState, NoEvent>`.

Sources/Machine.swift

@@ -70,8 +70,8 @@ public class Machine<S: StateType, E: EventType>
     /// Check for added routes & routeMappings.
     public func hasRoute(event event: E, transition: Transition<S>, userInfo: Any? = nil) -> Bool
     {
-        guard let fromState = transition.fromState.value,
-            toState = transition.toState.value else
+        guard let fromState = transition.fromState.rawValue,
+            toState = transition.toState.rawValue else
         {
             assertionFailure("State = `.Any` is not supported for `hasRoute()` (always returns `false`)")
             return false
@@ -110,7 +110,7 @@ public class Machine<S: StateType, E: EventType>
 
             if let event = event {
                 for (ev, routeDict) in self._routes {
-                    if ev.value == event || ev == .Any {
+                    if ev.rawValue == event || ev == .Any {
                         routeDicts += [routeDict]
                     }
                 }
@@ -165,7 +165,7 @@ public class Machine<S: StateType, E: EventType>
                 if transition.fromState == .Some(self.state) || transition.fromState == .Any {
                     for (_, condition) in keyConditionDict {
                         // if toState is `.Any`, always treat as identity transition
-                        let toState = transition.toState.value ?? self.state
+                        let toState = transition.toState.rawValue ?? self.state
 
                         if _canPassCondition(condition, forEvent: event, fromState: self.state, toState: toState, userInfo: userInfo) {
                             return toState
@@ -426,7 +426,7 @@ public class Machine<S: StateType, E: EventType>
                 return
             }
 
-            if triggeredEvent == event.value || event == .Any {
+            if triggeredEvent == event.rawValue || event == .Any {
                 handler(context)
             }
         }

Sources/StateMachine.swift

@@ -49,8 +49,8 @@ public final class StateMachine<S: StateType, E: EventType>: Machine<S, E>
     /// - Note: This method also checks for event-based-routes.
     public func hasRoute(transition: Transition<S>, userInfo: Any? = nil) -> Bool
     {
-        guard let fromState = transition.fromState.value,
-            toState = transition.toState.value else
+        guard let fromState = transition.fromState.rawValue,
+            toState = transition.toState.rawValue else
         {
             assertionFailure("State = `.Any` is not supported for `hasRoute()` (always returns `false`)")
             return false

Sources/StateType.swift

@@ -10,21 +10,37 @@ public protocol StateType: Hashable {}
 
 // MARK: State
 
-/// `StateType` wrapper for handling`.Any` state.
-public enum State<S: StateType>: Hashable
+/// `StateType` wrapper for handling `.Any` state.
+public enum State<S: StateType>
 {
     case Some(S)
     case Any
-
+}
+
+extension State: Hashable
+{
     public var hashValue: Int
     {
         switch self {
             case .Some(let x):  return x.hashValue
             case .Any:          return _hashValueForAny
         }
     }
+}
+
+extension State: RawRepresentable
+{
+    public init(rawValue: S?)
+    {
+        if let rawValue = rawValue {
+            self = .Some(rawValue)
+        }
+        else {
+            self = .Any
+        }
+    }
 
-    public var value: S?
+    public var rawValue: S?
     {
         switch self {
             case .Some(let x):  return x

Tests/RouteTests.swift

@@ -14,18 +14,18 @@ class RouteTests: _TestCase
     func testInit()
     {
         let route = Route<MyState, NoEvent>(transition: .State0 => .State1, condition: nil)
-        XCTAssertEqual(route.transition.fromState.value, MyState.State0)
-        XCTAssertEqual(route.transition.toState.value, MyState.State1)
+        XCTAssertEqual(route.transition.fromState.rawValue, MyState.State0)
+        XCTAssertEqual(route.transition.toState.rawValue, MyState.State1)
         XCTAssertTrue(route.condition == nil)
 
         let route2 = Route<MyState, NoEvent>(transition: .State1 => .State2, condition: { _ in false })
-        XCTAssertEqual(route2.transition.fromState.value, MyState.State1)
-        XCTAssertEqual(route2.transition.toState.value, MyState.State2)
+        XCTAssertEqual(route2.transition.fromState.rawValue, MyState.State1)
+        XCTAssertEqual(route2.transition.toState.rawValue, MyState.State2)
         XCTAssertTrue(route2.condition != nil)
 
         let route3 = Route<MyState, NoEvent>(transition: .State2 => .State3, condition: { context in false })
-        XCTAssertEqual(route3.transition.fromState.value, MyState.State2)
-        XCTAssertEqual(route3.transition.toState.value, MyState.State3)
+        XCTAssertEqual(route3.transition.fromState.rawValue, MyState.State2)
+        XCTAssertEqual(route3.transition.toState.rawValue, MyState.State3)
         XCTAssertTrue(route3.condition != nil)
     }
 }

Tests/TransitionTests.swift

@@ -14,37 +14,37 @@ class TransitionTests: _TestCase
     func testInit()
     {
         let transition = Transition<MyState>(fromState: .State0, toState: .State1)
-        XCTAssertEqual(transition.fromState.value, MyState.State0)
-        XCTAssertEqual(transition.toState.value, MyState.State1)
+        XCTAssertEqual(transition.fromState.rawValue, MyState.State0)
+        XCTAssertEqual(transition.toState.rawValue, MyState.State1)
 
         // shorthand
         let transition2 = MyState.State1 => .State0
-        XCTAssertEqual(transition2.fromState.value, MyState.State1)
-        XCTAssertEqual(transition2.toState.value, MyState.State0)
+        XCTAssertEqual(transition2.fromState.rawValue, MyState.State1)
+        XCTAssertEqual(transition2.toState.rawValue, MyState.State0)
     }
 
     func testInit_fromAny()
     {
         let transition = Transition<MyState>(fromState: .Any, toState: .State1)
-        XCTAssertNil(transition.fromState.value)
-        XCTAssertEqual(transition.toState.value, MyState.State1)
+        XCTAssertNil(transition.fromState.rawValue)
+        XCTAssertEqual(transition.toState.rawValue, MyState.State1)
 
         // shorthand
         let transition2 = .Any => MyState.State0
-        XCTAssertNil(transition2.fromState.value)
-        XCTAssertEqual(transition2.toState.value, MyState.State0)
+        XCTAssertNil(transition2.fromState.rawValue)
+        XCTAssertEqual(transition2.toState.rawValue, MyState.State0)
     }
 
     func testInit_toAny()
     {
         let transition = Transition<MyState>(fromState: .State0, toState: .Any)
-        XCTAssertEqual(transition.fromState.value, MyState.State0)
-        XCTAssertNil(transition.toState.value)
+        XCTAssertEqual(transition.fromState.rawValue, MyState.State0)
+        XCTAssertNil(transition.toState.rawValue)
 
         // shorthand
         let transition2 = MyState.State1 => .Any
-        XCTAssertEqual(transition2.fromState.value, MyState.State1)
-        XCTAssertNil(transition2.toState.value)
+        XCTAssertEqual(transition2.fromState.rawValue, MyState.State1)
+        XCTAssertNil(transition2.toState.rawValue)
     }
 
     func testNil()