apply subscript code

Author: minsOne

README.md

@@ -51,6 +51,8 @@ Then get an instance from the container.
 @Inject(AnimalKey.self)
 var cat: Meow
 cat.doSomething() // prints "Meow.."
+// or
+Container[AnimalKey.self].doSomething() // prints "Meow.."
 ```
 
 Where definitions of the protocols and struct are
@@ -113,4 +115,5 @@ The DIContainer are inspired by:
 * [mikeash.com - Friday Q&A 2014-08-08: Swift Name Mangling](https://mikeash.com/pyblog/friday-qa-2014-08-15-swift-name-mangling.html)
 * [Wikipedia - Name mangling](https://en.wikipedia.org/wiki/Name_mangling#Swift)
 * [Github - DerekSelander/dsdump](https://github.com/DerekSelander/dsdump)
+* [Github - Apple/swift-service-context](https://github.com/apple/swift-service-context)
 * [Building a class-dump in 2020](https://derekselander.github.io/dsdump/)

Sources/DIContainer/Container/Container.swift

@@ -5,21 +5,21 @@ public class Container {
     private(set) static var root = Container()
 
     /// Stored object instance factories.
-    var modules: [String: Module] = [:]
+    var _storage: [String: Module] = [:]
 
     public init() {}
-    deinit { modules.removeAll() }
+    deinit { _storage.removeAll() }
 }
 
 public extension Container {
     /// Registers a specific type and its instantiating factory.
     @discardableResult
     func register(module: Module) -> Self {
         let key = module.name
-        if let _ = modules[key] {
+        if let _ = _storage[key] {
             assertionFailure("\(key) Key is existed. Please check module \(module)")
         }
-        modules[key] = module
+        _storage[key] = module
         return self
     }
 
@@ -49,15 +49,15 @@ extension Container {
     static func weakResolve<T, U: InjectionKeyType>(for type: U.Type) -> T? {
         root.module(type)?.resolve() as? T
     }
-    
+
     /// Check if the dependency is registered in the container.
     static func isRegistered<T: InjectionKeyType>(_ type: T.Type) -> Bool {
         root.module(type) != nil
     }
 
     func module<T: InjectionKeyType>(_ type: T.Type) -> Module? {
         let keyName = KeyName(type).name
-        return modules[keyName]
+        return _storage[keyName]
     }
 }
 
@@ -95,6 +95,18 @@ public extension Container {
         // Used later in property wrapper
         Self.root = self
     }
+
+    static subscript<T: InjectionKeyType>(_ type: T.Type) -> T.Value {
+        resolve(for: type)
+    }
+
+    var count: Int {
+        _storage.count
+    }
+
+    var isEmpty: Bool {
+        _storage.isEmpty
+    }
 }
 
 #if DEBUG
@@ -103,6 +115,14 @@ public extension Container {
     static func clear() {
         root = .init()
     }
+
+    static func register(_ module: Module) {
+        root.register(module: module)
+    }
+
+    static func register(contentsOf newElements: [Module]) {
+        root.register(contentsOf: newElements)
+    }
 }
 
 #endif

Sources/DIContainer/Internals/Utils/KeyName.swift

@@ -1,8 +1,9 @@
 import Foundation
 
+@MainActor
 struct KeyName {
     let name: String
-    init(_ type: AnyObject.Type) {
-        name = NSStringFromClass(type)
+    init<T: InjectionKeyType> (_ type: T.Type) {
+        name = type.nameOverride ?? NSStringFromClass(type)
     }
 }

Sources/DIContainer/Key/InjectionKeyType.swift

@@ -3,19 +3,23 @@ import Foundation
 @MainActor
 public protocol InjectionKeyType: AnyObject {
     associatedtype Value
-    static var value: Value { get }
-    static var weakValue: Value? { get }
+    
+    /// The human-readable name of this key.
+    /// This name will be used instead of the type name when a value is printed.
+    ///
+    /// It MAY also be picked up by an instrument (from Swift Tracing) which serializes context items and e.g. used as
+    /// header name for carried metadata. Though generally speaking header names are NOT required to use the nameOverride,
+    /// and MAY use their well known names for header names etc, as it depends on the specific transport and instrument used.
+    ///
+    /// For example, a context key representing the W3C "trace-state" header may want to return "trace-state" here,
+    /// in order to achieve a consistent look and feel of this context item throughout logging and tracing systems.
+    ///
+    /// Defaults to `nil`.
+    static var nameOverride: String? { get }
 }
 
-@MainActor
-public extension InjectionKeyType {
-    static var value: Value {
-        Container.resolve(for: Self.self)
-    }
-
-    static var weakValue: Value? {
-        Container.weakResolve(for: Self.self)
-    }
+extension InjectionKeyType {
+    public static var nameOverride: String? { nil }
 }
 
 /// DO NOT USE THIS CODE DIRECTLY

Sources/DIContainer/Module/AutoModule.swift

@@ -15,13 +15,15 @@ public protocol AutoModulable: AnyObject {
 public typealias AutoModule = AutoModulable & AutoModuleBase
 
 #if DEBUG
+@MainActor
 extension AutoModulable where Self: AutoModuleBase {
     static var module: Module? {
         Self().module
     }
 }
 
 extension AutoModulable {
+    @MainActor
     private var module: Module? {
         guard
             let instance = self as? ModuleKeyType.Value,

Sources/DIContainer/Module/Module.swift

@@ -1,10 +1,12 @@
 import Foundation
 
 /// A type that contributes to the object graph.
+@preconcurrency
 public struct Module: Hashable {
     let name: String
     let resolve: () -> Any
 
+    @MainActor
     public init<T: InjectionKeyType, U>(
         _ keyType: T.Type,
         _ resolve: @escaping () -> U
@@ -13,13 +15,15 @@ public struct Module: Hashable {
         self.init(name: name, resolve: resolve)
     }
 
+    @MainActor
     public init<T: AutoModule>(_ moduleType: T.Type) {
         let name = KeyName(moduleType.ModuleKeyType.self).name
         self.init(name: name, resolve: {
             moduleType.init()
         })
     }
 
+    @MainActor
     init(name: String, resolve: @escaping () -> Any) {
         self.name = name
         self.resolve = resolve

Sources/DIContainer/PropertyWrapper/Inject.swift

@@ -16,7 +16,7 @@ public class Inject<Value> {
 
     public init<K>(_ key: K.Type) where K: InjectionKeyType, Value == K.Value {
         lazyValue = {
-            key.value
+            Container.resolve(for: K.self)
         }
     }
 }

Sources/DIContainer/PropertyWrapper/WeakInject.swift

@@ -16,7 +16,7 @@ public class WeakInject<Value> {
 
     public init<K>(_ key: K.Type) where K: InjectionKeyType, Value == K.Value {
         lazyValue = {
-            key.weakValue
+            Container.weakResolve(for: K.self)
         }
     }
 }

Sources/DIContainer/Scanner/MachOLoader/MachOLoader.swift

@@ -58,6 +58,7 @@ public extension MachOLoader {
         return results
     }
 
+    @MainActor
     var scanModuleList: [Module] {
         scanModuleTypeList
             .compactMap { ($0 as? any AutoModule.Type)?.module }

Sources/DIContainer/Scanner/ObjcRuntime/ModuleScanner.swift

@@ -126,6 +126,7 @@ public struct ModuleScanner {
         return modules
     }
 
+    @MainActor
     public var scanModuleList: [Module] {
         scanModuleTypeList
             .compactMap { ($0 as? any AutoModule.Type)?.module }