Implement indexOf methods for alphabet and series

These methods are implemented on the classes that own those sequences. Less confusion is good. :)

Enigma/Components.swift

@@ -10,8 +10,10 @@ import Foundation
 
 
 enum EncoderError: ErrorType {
-    /** Thrown when an input character is found that is not in the alphabet. */
+    /** Input character is not in the alphabet. */
-    case InvalidCharacter(ch: Character)
+    case CharacterNotInAlphabet(ch: Character)
+    /** Input character is not found in a rotor's series. */
+    case CharacterNotInSeries(ch: Character)
 }
 
 
@@ -24,6 +26,14 @@ protocol Encoder {
 class Cryptor {
     /** Array of all possible characters to encrypt. */
     static let alphabet: [Character] = Array("ABCDEFGHIJKLMNOPQRSTUVWXYZ".characters)
+
+    func indexOfInAlphabet(c: Character) throws -> Int {
+        if let index = Cryptor.alphabet.indexOf(c) {
+            return index
+        } else {
+            throw EncoderError.CharacterNotInAlphabet(ch: c)
+        }
+    }
 }
 
 
@@ -49,18 +59,18 @@ class FixedRotor: Cryptor, Encoder {
     }
 
     func encode(c: Character) throws -> Character {
-        if let offset = FixedRotor.alphabet.indexOf(c) {
+        return series[try indexOfInAlphabet(c)]
-            return series[offset]
-        } else {
-            throw EncoderError.InvalidCharacter(ch: c)
-        }
     }
 
     func inverseEncode(c: Character) throws -> Character {
-        if let offset = series.indexOf(c) {
+        return Cryptor.alphabet[try indexOfInSeries(c)]
-            return FixedRotor.alphabet[offset]
+    }
+
+    func indexOfInSeries(c: Character) throws -> Int {
+        if let index = series.indexOf(c) {
+            return index
         } else {
-            throw EncoderError.InvalidCharacter(ch: c)
+            throw EncoderError.CharacterNotInSeries(ch: c)
         }
     }
 }
@@ -123,19 +133,11 @@ class Rotor: FixedRotor {
     }
 
     override func encode(c: Character) throws -> Character {
-        if let offset = Rotor.alphabet.indexOf(c) {
+        return series[(try indexOfInAlphabet(c) + ringPosition + position) % series.count]
-            return series[(offset + ringPosition + position) % series.count]
-        } else {
-            throw EncoderError.InvalidCharacter(ch: c)
-        }
     }
 
     override func inverseEncode(c: Character) throws -> Character {
-        if let offset = series.indexOf(c) {
+        return Cryptor.alphabet[(try indexOfInSeries(c) + ringPosition + position) % Rotor.alphabet.count]
-            return Rotor.alphabet[(offset + ringPosition + position) % Rotor.alphabet.count]
-        } else {
-            throw EncoderError.InvalidCharacter(ch: c)
-        }
     }
 }
 
@@ -164,12 +166,8 @@ class Reflector: FixedRotor {
 
     func validateReflector(series: [Character]) throws {
         for (offset, c) in series.enumerate() {
-            if let alphabetOffset = Reflector.alphabet.indexOf(c) {
+            if series[try indexOfInAlphabet(c)] != Cryptor.alphabet[offset] {
-                if series[alphabetOffset] != Reflector.alphabet[offset] {
+                throw Error.InvalidReflection
-                    throw Error.InvalidReflection
-                }
-            } else {
-                throw EncoderError.InvalidCharacter(ch: c)
             }
         }
     }
@@ -191,7 +189,7 @@ class Plugboard: Cryptor, Encoder {
         } else if Plugboard.alphabet.contains(c) {
             return c
         } else {
-            throw EncoderError.InvalidCharacter(ch: c)
+            throw EncoderError.CharacterNotInAlphabet(ch: c)
         }
     }