 
     // MARK: - Coordinators
 
+    public var coordinators: [CoordinatorType] {
+        return Array(coordinatorsMap.values)
+    }
+
     public var coordinatorCount: Int {
         return synchronizer.valueOf {
-            return self.coordinators.count
+            return self.coordinatorsMap.count
         }
     }
 
     public func coordinator<T>(type: T.Type) -> T? {
         return synchronizer.valueOf {
-            return self.coordinators[TypeKey(T)] as? T
+            return self.coordinatorsMap[TypeKey(T)] as? T
         }
     }
 
     public func addCoordinator<T>(coordinator: CoordinatorType, forProtocol: T.Type) {
         synchronizer.execute {
-            self.coordinators[TypeKey(T)] = coordinator
+            self.coordinatorsMap[TypeKey(T)] = coordinator
         }
         coordinator.registerRouteSegments(router)
     }

            if let index = self.serviceKeyOrder.indexOf(key) {
                self.serviceKeyOrder.removeAtIndex(index)
            }
            self.services[key] = service
            self.serviceKeyOrder.append(key)

            // if container state has progressed past uninitialized, then call methods that were missed

    private func orderedServices() -> [ServiceType] {
        return synchronizer.valueOf {
            return self.serviceKeyOrder
                .filter { self.servicesMap[$0] != nil }
                .map { self.servicesMap[$0]! }
        }
    }

