ComposedInjector Structure Reference

Key

Declaration

Swift

public typealias Key = K


                    
                    
                    left

The first Injector that shall be wrapped.

Declaration

Swift

public var left: AnyInjector<K>


                    
                    
                    right

The second Injector that shall be wrapped.

Declaration

Swift

public var right: AnyInjector<K>


                    
                    
                    init(left:right:)

Initializes AnyMutableInjector with a given MutableInjector.

Declaration

Swift

public init<L, R>(left: L, right: R) where K == L.Key, L : Injector, R : Injector, L.Key == R.Key

Parameters

`left`	The default `MutableInjector` that shall be wrapped.
`right`	The fallback `MutableInjector` that shall be wrapped.


                    
                    
                    resolve(key:)

See MutableInjector.resolve(key:).

Declaration

Swift

public mutating func resolve(key: Key) throws -> Providable


                    
                    
                    provide(key:usingFactory:)

See MutableInjector.provide(key:usingFactory:).

Declaration

Swift

public mutating func provide(
  key: Key, usingFactory factory: @escaping (inout ComposedInjector) throws -> Providable
)


                    
                    
                    providedKeys

See Injector.providedKeys.

Declaration

Swift

public var providedKeys: [K] { get }

Return Value

The union of the left and right Injector.providedKeys.


                    
                    
                    revoke(key:)

See MutableInjector.revoke(key:).

Declaration

Swift

public mutating func revoke(key: K)


                    
                    
                    resolveLeft(key:)

Returns MutableInjector.resolve(key:) invoked on ComposedInjector.left.

Throws

Just passes all errors.

Declaration

Swift

public mutating func resolveLeft(key: Key) throws -> Providable


                    
                    
                    resolveRight(key:)

Returns MutableInjector.resolve(key:) invoked on ComposedInjector.right.

Throws

Just passes all errors.

Declaration

Swift

public mutating func resolveRight(key: Key) throws -> Providable


                    
                    
                    resolveBoth(key:)

Calls both, ComposedInjector.resolveLeft(key:) and ComposedInjector.resolveRight(key:).

Throws

InjectionError. InjectionError.customError(_:) may contain ComposedInjectionError.

Declaration

Swift

public mutating func resolveBoth(key: Key) throws -> (Providable, Providable)

Return Value

Both results.


                    
                    
                    resolveLeft(from:)

Resolves InjectedProvider.value for a given Provider. Will be performed on the .left Injector.

Throws

InjectionError

Declaration

Swift

public mutating func resolveLeft<Value: Providable>(
  from provider: Provider<Key, Value>
) throws -> Value

Parameters


                                provider

The Provider that has been used previously.

Return Value

The previously added Providable.


                    
                    
                    resolveRight(from:)

Resolves InjectedProvider.value for a given Provider. Will be performed on the .right Injector.

Throws

InjectionError

Declaration

Swift

public mutating func resolveRight<Value: Providable>(
  from provider: Provider<Key, Value>
) throws -> Value

Parameters


                                provider

The Provider that has been used previously.

Return Value

The previously added Providable.


                    
                    
                    resolveBoth(from:)

Resolves InjectedProvider.value for a given Provider. Will be performed on the .left and thereafter on the .right Injector.

Throws

InjectionError, may throw .customError(ComposedInjectionError)

Declaration

Swift

public mutating func resolveBoth<Value: Providable>(
  from provider: Provider<Key, Value>
) throws -> (Value, Value)

Parameters


                                provider

The Provider that has been used previously.

Return Value

The previously added Providable.


                    
                    
                    provideLeft(key:usingFactory:)

Invokes MutableInjector.provide(key:usingFactory:) on ComposedInjector.left.

Declaration

Swift

public mutating func provideLeft(
  key: Key, usingFactory factory: @escaping (inout ComposedInjector) throws -> Providable
)


                    
                    
                    provideRight(key:usingFactory:)

Invokes MutableInjector.provide(key:usingFactory:) on ComposedInjector.right.

Declaration

Swift

public mutating func provideRight(
  key: Key, usingFactory factory: @escaping (inout ComposedInjector) throws -> Providable
)


                    
                    
                    provideBoth(key:usingFactory:)

Invokes MutableInjector.provide(key:usingFactory:) on ComposedInjector.left and ComposedInjector.left.

Declaration

Swift

public mutating func provideBoth(
  key: Key, usingFactory factory: @escaping (inout ComposedInjector) throws -> Providable
)


                    
                    
                    provideLeft(for:usingFactory:)

Additionally provides a value given as a factory for a given Provider. This will only be performed on the .left Injector.

Declaration

Swift

public mutating func provideLeft<Value: Providable>(
  for provider: Provider<Key, Value>,
  usingFactory factory: @escaping (inout ComposedInjector) throws -> Value
)

Parameters

`provider`	The `Provider`, an `InjectedProvider` is constructed of.
`factory`	Creates a value out of a new `Injector`.


                    
                    
                    provideRight(for:usingFactory:)

Additionally provides a value given as a factory for a given Provider. This will only be performed on the .right Injector.

Declaration

Swift

public mutating func provideRight<Value: Providable>(
  for provider: Provider<Key, Value>,
  usingFactory factory: @escaping (inout ComposedInjector) throws -> Value
)

Parameters

`provider`	The `Provider`, an `InjectedProvider` is constructed of.
`factory`	Creates a value out of a new `Injector`.


                    
                    
                    provideBoth(for:usingFactory:)

Additionally provides a value given as a factory for a given Provider. This will only be performed on the .left and thereafter on the .right Injector.

Declaration

Swift

public mutating func provideBoth<Value: Providable>(
  for provider: Provider<Key, Value>,
  usingFactory factory: @escaping (inout ComposedInjector) throws -> Value
)

Parameters

`provider`	The `Provider`, an `InjectedProvider` is constructed of.
`factory`	Creates a value out of a new `Injector`.


                    
                    
                    revokeLeft(key:)

Invokes MutableInjector.revoke(key:) on ComposedInjector.left.

Declaration

Swift

public mutating func revokeLeft(key: K)

Parameters

key

The key to be removed.


                    
                    
                    revokeRight(key:)

Invokes MutableInjector.revoke(key:) on ComposedInjector.right.

Declaration

Swift

public mutating func revokeRight(key: K)

Parameters

key

The key to be removed.


                    
                    
                    revokeBoth(key:)

Invokes MutableInjector.revoke(key:) on ComposedInjector.left and ComposedInjector.right.

Declaration

Swift

public mutating func revokeBoth(key: K)

Parameters

key

The key to be removed.


                    
                    
                    resolvingLeft(from:)

Resolves InjectedProvider.value for a given Provider. Will be performed on the .left Injector.

Throws

InjectionError

Declaration

Swift

public func resolvingLeft<Value: Providable>(
  from provider: Provider<Key, Value>
) throws -> Value

Parameters


                                provider

The Provider that has been used previously.

Return Value

The previously added Providable.


                    
                    
                    resolvingRight(from:)

Resolves InjectedProvider.value for a given Provider. Will be performed on the .right Injector.

Throws

InjectionError

Declaration

Swift

public func resolvingRight<Value: Providable>(
  from provider: Provider<Key, Value>
) throws -> Value

Parameters


                                provider

The Provider that has been used previously.

Return Value

The previously added Providable.


                    
                    
                    resolvingBoth(from:)

Resolves InjectedProvider.value for a given Provider. Will be performed on the .left and thereafter on the .right Injector.

Throws

InjectionError, may throw .customError(ComposedInjectionError)

Declaration

Swift

public func resolvingBoth<Value: Providable>(from provider: Provider<Key, Value>) throws -> (
  Value, Value
)

Parameters


                                provider

The Provider that has been used previously.

Return Value

A tuple of the left and right Providable, that have been added.


                    
                    
                    providingLeft(for:usingFactory:)

Additionally provides a value given as a factory for a given Provider. This will only be performed on the .left Injector.

Declaration

Swift

public func providingLeft<Value: Providable>(
  for provider: Provider<Key, Value>,
  usingFactory factory: @escaping (inout ComposedInjector) throws -> Value
) -> ComposedInjector

Parameters

`provider`	The `Provider`, an `InjectedProvider` is constructed of.
`factory`	Creates a value out of a new `Injector`.

Return Value

A new Injector with contents of self and the newly provided value.


                    
                    
                    providingRight(for:usingFactory:)

Additionally provides a value given as a factory for a given Provider. This will only be performed on the .right Injector.

Declaration

Swift

public func providingRight<Value: Providable>(
  for provider: Provider<Key, Value>,
  usingFactory factory: @escaping (inout ComposedInjector) throws -> Value
) -> ComposedInjector

Parameters

`provider`	The `Provider`, an `InjectedProvider` is constructed of.
`factory`	Creates a value out of a new `Injector`.

Return Value

A new Injector with contents of self and the newly provided value.


                    
                    
                    providingBoth(for:usingFactory:)

Additionally provides a value given as a factory for a given Provider. This will only be performed on the .left and thereafter on the .right Injector.

Declaration

Swift

public func providingBoth<Value: Providable>(
  for provider: Provider<Key, Value>,
  usingFactory factory: @escaping (inout ComposedInjector) throws -> Value
) -> ComposedInjector

Parameters

`provider`	The `Provider`, an `InjectedProvider` is constructed of.
`factory`	Creates a value out of a new `Injector`.

Return Value

A new Injector with contents of self and the newly provided value.


                    
                    
                    revokingLeft(key:)

Invokes Injector.revoking(key:) on ComposedInjector.left.

Declaration

Swift

public func revokingLeft(key: K) -> ComposedInjector

Parameters

key

The key to be removed.

Return Value

A ComposedInjector that revoked the key on ComposedInjector.left.


                    
                    
                    revokingRight(key:)

Invokes Injector.revoking(key:) on ComposedInjector.right.

Declaration

Swift

public func revokingRight(key: K) -> ComposedInjector

Parameters

key

The key to be removed.

Return Value

A ComposedInjector that revoked the key on ComposedInjector.right.


                    
                    
                    revokingBoth(key:)

Invokes Injector.revoking(key:) on ComposedInjector.left and ComposedInjector.right.

Declaration

Swift

public func revokingBoth(key: K) -> ComposedInjector

Parameters

key

The key to be removed.

Return Value

A ComposedInjector that revoked the key on ComposedInjector.left and ComposedInjector.right.


                    
                    
                    providingLeft(_:for:)

Creates an instance providing a value for a given Provider. This will only be performed on ComposedInjector.left.

Declaration

Swift

public func providingLeft<Value: Providable>(
  _ instance: @autoclosure @escaping () -> Value,
  for provider: Provider<Key, Value>
) -> ComposedInjector

Parameters

`provider`	The `Provider`, an `InjectedProvider` is constructed of.
`instance`	The provided `Providable`. Depending on `Self`, evaluated lazily.

Return Value

A new Injector with contents of self and the newly provided value.


                    
                    
                    providingRight(_:for:)

Creates an instance providing a value for a given Provider. This will only be performed on the ComposedInjector.right.

Declaration

Swift

public func providingRight<Value: Providable>(
  _ instance: @autoclosure @escaping () -> Value,
  for provider: Provider<Key, Value>
) -> ComposedInjector

Parameters

`provider`	The `Provider`, an `InjectedProvider` is constructed of.
`instance`	The provided `Providable`. Depending on `Self`, evaluated lazily.

Return Value

A new Injector with contents of self and the newly provided value.


                    
                    
                    providingBoth(_:for:)

Creates an instance providing a value for a given Provider. This will only be performed on ComposedInjector.left and thereafter on ComposedInjector.right.

Declaration

Swift

public func providingBoth<Value: Providable>(
  _ instance: @autoclosure @escaping () -> Value,
  for provider: Provider<Key, Value>
) -> ComposedInjector

Parameters

`provider`	The `Provider`, an `InjectedProvider` is constructed of.
`instance`	The provided `Providable`. Depending on `Self`, evaluated lazily.

Return Value

A new Injector with contents of self and the newly provided value.


                    
                    
                    provideLeft(_:for:)

Additionally provides a value for a given Provider. This will only be performed on ComposedInjector.left.

Declaration

Swift

public mutating func provideLeft<Value: Providable>(
  _ instance: @autoclosure @escaping () -> Value,
  for provider: Provider<Key, Value>
)

Parameters

`instance`	The provided `Providable`. Depending on `Self`, evaluated lazily.
`provider`	The `Provider`, an `InjectedProvider` will be constructed of.


                    
                    
                    provideRight(_:for:)

Additionally provides a value for a given Provider. This will only be performed on ComposedInjector.right.

Declaration

Swift

public mutating func provideRight<Value: Providable>(
  _ instance: @autoclosure @escaping () -> Value,
  for provider: Provider<Key, Value>
)

Parameters

`instance`	The provided `Providable`. Depending on `Self`, evaluated lazily.
`provider`	The `Provider`, an `InjectedProvider` will be constructed of.


                    
                    
                    provideBoth(_:for:)

Additionally provides a value for a given Provider. This will only be performed on ComposedInjector.left and thereafter on ComposedInjector.right.

Declaration

Swift

public mutating func provideBoth<Value: Providable>(
  _ instance: @autoclosure @escaping () -> Value,
  for provider: Provider<Key, Value>
)

Parameters

`instance`	The provided `Providable`. Depending on `Self`, evaluated lazily.
`provider`	The `Provider`, an `InjectedProvider` will be constructed of.