 
     // MARK: - Resources
 
+    public var resources: [ResourceType] {
+        return Array(resourcesMap.values)
+    }
+
     public var resourceCount: Int {
         return synchronizer.valueOf {
-            return self.resources.count
+            return self.resourcesMap.count
         }
     }
 
     public func resource<T>(type: T.Type) -> T? {
         return synchronizer.valueOf {
-            return self.resources[TypeKey(type)] as? T
+            return self.resourcesMap[TypeKey(type)] as? T
         }
     }
 
     public func addResource<T>(resource: ResourceType, forProtocol: T.Type) {
         synchronizer.execute {
-            self.resources[TypeKey(T)] = resource
+            self.resourcesMap[TypeKey(T)] = resource
         }
     }
 
     // MARK: - Services
 
+    public var services: [ServiceType] {
+        return Array(servicesMap.values)
+    }
+
     public var serviceCount: Int {
         return synchronizer.valueOf {
-            return self.services.count
+            return self.servicesMap.count
         }
     }
 
     public func service<T>(type: T.Type) -> T? {
         return synchronizer.valueOf {
-            return self.services[TypeKey(T)] as? T
+            return self.servicesMap[TypeKey(T)] as? T
         }
     }
 


    // MARK: - Private variables

    private var resources: [TypeKey: ResourceType] = [:]
    private var services: [TypeKey: ServiceType] = [:]
    private var serviceKeyOrder: [TypeKey] = []
    private var coordinators: [TypeKey: CoordinatorType] = [:]
    private let synchronizer = Synchronizer()
    private var _containerState: ContainerState = .Uninitialized
}

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

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