tegral-di-core/guru.zoroark.tegral.di.environment

Package-level declarations

Environment classes and functions. Environments manage pools of inter-dependent and injectable components using different heuristics.

Types

Declaration

sealed class Declaration<T : Any>

A declaration within an environment that is being built. These declarations can be:

Declarations

typealias Declarations = Map<Identifier<*>, Declaration<*>>

A map that maps identifiers to declarations.

The general contract is:

For any key-value pair, key == value.identifier
For any key-value pair, key: Identifier of T => value: Declaration of T

EmptyQualifier

object EmptyQualifier : Qualifier

The empty qualifier object must be used when there is no qualifier being used.

EnvironmentComponents

typealias EnvironmentComponents = Map<Identifier<*>, IdentifierResolver<*>>

EnvironmentContext

class EnvironmentContext(val declarations: Declarations)

Data objects that contain all of the information passed to InjectionEnvironment constructors to let them initialize their data.

ExtensibleEnvironmentBasedScope

class ExtensibleEnvironmentBasedScope(env: ExtensibleInjectionEnvironment) : InjectionScope

An injection scope that delegates the injection to the given environment (for inject) or its meta-environment (for meta).

FullTypeQualifier

data class FullTypeQualifier(val type: KType) : Qualifier

A qualifier specifically intended to be used for fully qualifying a type.

Identifier

data class Identifier<T : Any>(val kclass: KClass<T>, val qualifier: Qualifier = EmptyQualifier)

Identifies an injectable component via its type and optionally via other elements called qualifiers.

InjectableModule

class InjectableModule(val name: String, defs: Collection<Declaration<*>>)

A module that can be injected in environments. At their core, injectable modules are just lists of declarations that get copied over when adding this module to environments.

InjectionEnvironment

interface InjectionEnvironment

An injection environment is, in a nutshell, a container for injectable components. These injectable components can be retrieved in two ways:

InjectionEnvironmentKind

fun interface InjectionEnvironmentKind<E : InjectionEnvironment>

An environment kind is a facility for building InjectionEnvironment in a nicer way. This should be implemented by the companion object of an InjectionEnvironment class.

InjectionScope

interface InjectionScope : MetalessInjectionScope

An injection scope provides an entrypoint for components to retrieve the dependencies they need.

Injector

fun interface Injector<out T> : ReadOnlyProperty<Any?, T>

An injector is a read-only property delegator that has constraints on T.

MetalessInjectionScope

interface MetalessInjectionScope

An injection scope without meta-related operations. Because InjectionScope.meta itself returns (in theory) an InjectionScope, people may do scope.meta.meta.meta.meta... to infinity and beyond, which does not make sense. In order to prevent this, InjectionScope.meta instead returns a MetalessInjectionScope.

MixedImmutableEnvironment

class MixedImmutableEnvironment(context: ExtensibleEnvironmentContext, metaEnvironmentKind: InjectionEnvironmentKind<*> = EagerImmutableMetaEnvironment) : DefaultExtensibleInjectionEnvironment

An injection environment implementation with a mixed evaluation strategy.

MultiQualifier

class MultiQualifier(val qualifiers: Set<Qualifier>) : Qualifier

A multi-qualifier represents multiple qualifiers grouped as a set. This is useful for combining qualifiers (e.g. a named qualifier and a type qualifier).

NameQualifier

data class NameQualifier(val name: String) : Qualifier

A qualifier that is based on a string. You can also use named to construct name qualifiers in a more DSL-ish approach.

Qualifier

interface Qualifier

Qualifiers are simple objects that can be used within Identifier objects to provide additional differentiators between two same-type objects or components.

ResolvableDeclaration

abstract class ResolvableDeclaration<T : Any>(identifier: Identifier<T>) : Declaration<T>

A declaration that can be built into an IdentifierResolver.

ScopedContext

interface ScopedContext

An object that contains a scope. For use as a receiver in lambdas (e.g. ScopedSupplier)

ScopedSupplier

typealias ScopedSupplier<T> = ScopedContext.() -> T

A supplier of T that takes a ScopedContext as a receiver.

ScopedSupplierDeclaration

class ScopedSupplierDeclaration<T : Any>(identifier: Identifier<T>, val supplier: ScopedSupplier<T>) : Declaration<T>

A declaration within an EnvironmentContext.

SimpleEnvironmentBasedScope

class SimpleEnvironmentBasedScope(env: InjectionEnvironment) : InjectionScope

An injection scope that delegates the injection to the given environment, without any support for injecting from meta-environments.

Functions

ensureInstance

fun <T : Any> ensureInstance(kclass: KClass<T>, obj: Any): T

Utility function - asserts that obj is an instance of kclass. Throws an exception if it is not or returns obj cast to T on success.

EnvironmentBasedScope

fun EnvironmentBasedScope(env: InjectionEnvironment): InjectionScope

Creates an injection scope based on the given environment. If the given environment supports meta-environments (i.e. if it is extensible), an ExtensibleEnvironmentBasedScope will be returned. Otherwise, a SimpleEnvironmentBasedScope is used.

get

inline fun <T : Any> Declarations.get(): Declaration<T>

Retrieves the declaration that corresponds to the given type parameter. This function does not check for the validity or coherence of the returned declaration.

inline fun <T : Any> InjectionEnvironment.get(qualifier: Qualifier = EmptyQualifier): T

Gets the component identified by the given type turned into an Identifier with an optional qualifier. Throws an exception if no component with this identifier exists.

getOrNull

inline fun <T : Any> InjectionEnvironment.getOrNull(qualifier: Qualifier = EmptyQualifier): T?

Gets the component identified by the given type turned into an Identifier with an optional qualifier. Returns null if no component with this identifier exists.

invoke

operator fun <T : Any> InjectionScope.invoke(identifier: Identifier<T>): ReadOnlyProperty<Any?, T>

Create an injector for the given identifier. See InjectionScope.inject for more information.

inline operator fun <T : Any> MetalessInjectionScope.invoke(qualifier: Qualifier = EmptyQualifier): ReadOnlyProperty<Any?, T>

Create an injector for the given class, turned to an identifier, and an optional qualifier. See InjectionScope.inject for more information.

named

fun named(name: String): NameQualifier

Creates a NameQualifier with the given name.

optional

inline fun <T : Any> MetalessInjectionScope.optional(qualifier: Qualifier = EmptyQualifier): ReadOnlyProperty<Any?, T?>

Create an injector for the given class and optional qualifier. If such an identifier cannot be found within the environment, returns null (unlike other functions which throw a ComponentNotFoundException).

plus

operator fun Qualifier.plus(other: Qualifier): Qualifier

Combines this qualifier with the other.

ScopedContext

fun ScopedContext(scope: InjectionScope): ScopedContext

Creates a ScopedContext that contains the given scope as-is as a property.

typed

inline fun <T : Any> typed(): FullTypeQualifier

Creates a full type qualifier with the given T as the type.

fun typed(type: KType): FullTypeQualifier

Creates a full type qualifier with the given KType as the type.