Container

Get the class name of the first parameter of the given Closure.

Get the class names of the first parameter of the given Closure, including union types.

Get the class names / types of the parameters of the given Closure.

Get the class names / types of the return type of the given Closure.

Define a contextual binding.

Define a contextual binding based on an attribute.

Determine if the given abstract type has been bound.

No description

Determine if the given abstract type has been resolved.

Determine if a given type is shared.

Determine if a given type has an explicit shared lifetime.

Determine if a given abstract is a scoped binding.

Determine if the object is a resolved scoped instance in this coroutine.

Determine if a scoped binding has already been resolved in this coroutine.

Scoped instances live in coroutine-local context, so this is false at the start of every request even for a binding resolved many times before. Callers that would only inspect an instance can use this to avoid paying for a full resolution — and the construction it implies — when nothing in the request asked for one.

Only the scoped resolution path writes this context key, so its presence already implies the binding is scoped; singletons, auto-singletons and transient bindings never produce one. An instance() registration that replaced a scoped binding also counts: it supersedes the scoped lifetime during resolution — tests swap scoped services this way — so an existing instance must be reported as resolved rather than skipped.

Determine if the container holds a worker-shared instance for the given type.

Determine if a ReflectionClass has scoping attributes applied.

Determine if a given string is an alias.

Register a binding with the container.

Bindings persist on the worker-lifetime container; runtime use races across coroutines and changes resolution for every subsequent request.

Register one binding and its lifecycle.

Get the Closure to be used when building a type.

Determine if the container has a method binding.

Bind a callback to resolve with Container::call.

Method bindings persist on the worker-lifetime container and affect every subsequent Container::call() for the bound method.

Get the method to be bound in class@method format.

Get the method binding for the given method.

Add a contextual binding to the container.

Contextual bindings persist on the worker-lifetime container; runtime use races across coroutines and changes dependency resolution for every subsequent build of the concrete.

Register a binding if it hasn't already been registered.

Conditional bindings mutate the worker-lifetime container for every subsequent request.

Register a shared binding in the container.

Singleton bindings persist on the worker-lifetime container; runtime use races across coroutines and changes shared resolution for every subsequent request.

Register a shared binding if it hasn't already been registered.

Conditional singleton bindings mutate the worker-lifetime container for every subsequent request.

Register a scoped binding in the container.

Scoped binding definitions persist on the worker-lifetime container; only their resolved instances are coroutine-scoped.

Register a scoped binding if it hasn't already been registered.

Conditional scoped bindings mutate the worker-lifetime container for every subsequent request.

Register a binding with the container based on the given Closure's return types.

"Extend" an abstract type in the container.

The extender persists in the container's $extenders array for the worker lifetime and runs on every subsequent resolution of $abstract.

Register an existing instance as shared in the container.

Replaces a worker-lifetime shared instance; runtime use races across coroutines and changes the object returned to every subsequent resolver.

Remove an alias from the contextual binding alias cache.

Assign a set of tags to a given binding.

Tags persist on the worker-lifetime container and affect every subsequent tagged() resolution.

Resolve all of the bindings for a given tag.

Alias a type to a different name.

Aliases persist on the worker-lifetime container; runtime use races across coroutines and changes resolution for every subsequent request.

Bind a new callback to an abstract's rebind event.

Rebinding callbacks persist on the worker-lifetime container and run whenever the abstract is rebound later in the worker.

Refresh an instance on the given target and method.

Registers a rebinding callback on the worker-lifetime container; runtime use leaks the callback across later rebindings.

Fire the "rebound" callbacks for the given abstract type.

Get the rebound callbacks for a given type.

Wrap the given closure such that its dependencies will be injected when executed.

Call the given Closure / class@method and inject its dependencies.

Get the class name for the given callback, if one can be determined.

Closures are handled directly in call() before this method is reached, so this only needs to handle non-closure callable types.

Get a closure to resolve the given type from the container.

An alias function name for make().

Resolve the given type from the container.

Resolve the given type with a transient implicit lifetime.

Explicit lifetimes remain authoritative.

No description

Resolve the given type from the container.

Determine whether this miss can publish a worker-shared instance.

Wait for a shared resolution without introducing a coordinator cycle.

Determine whether the resolution owner is an ancestor of a coroutine.

Determine whether adding a container wait edge would close a cycle.

Get the concrete type for a given abstract.

Get the concrete binding for an abstract from the BindWhen or Bind attributes.

Resolve the concrete from the Bind and BindWhen attributes in declaration order.

Get the contextual concrete binding for the given abstract.

Get the resolution state for the current coroutine.

Get or create the mutable resolution state for the current coroutine.

Get this container's coroutine context key for the given entry.

Get the current build stack without creating resolution state.

Find the concrete binding for the given abstract in the contextual binding array.

Determine if the given concrete is buildable.

Get the cached build recipe for the given concrete class.

Compute the build recipe for the given concrete class.

Analyzes the class via reflection and caches the result as a BuildRecipe. This happens once per class per worker lifetime, avoiding repeated reflection on every build() call.

Instantiate a concrete instance with the given parameter overrides.

Bypasses all binding lookups and the auto-singleton cache, so the returned instance is always freshly constructed. Class-typed dependencies are still resolved via the container.

Resolve the contextual constructor parameters of a class within its build context.

Contextual bindings for the class apply to dependencies the attributes resolve, and each parameter's attribute callbacks fire here. Pass the values to buildWith() as overrides so they are not resolved again. Variadic parameters are skipped, because an override is passed as one argument; the container resolves them when the class is built.

Instantiate a concrete instance of the given type.

Build a concrete as part of container resolution.

Instantiate a concrete instance of the given self building type.

Resolve all constructor parameters using cached recipe metadata.

Resolve a non-class hinted primitive dependency.

Resolve a class based dependency from the container.

Resolve a class based variadic dependency from the container.

Resolve a dependency based on an attribute.

Throw an exception that the concrete is not instantiable.

Throw an exception for an unresolvable primitive.

Register a new before resolving callback for all types.

The callback persists on the worker-lifetime container and runs before every matching future resolution.

Register a new resolving callback.

The callback persists on the worker-lifetime container and runs during every matching future resolution.

Register a new after resolving callback for all types.

The callback persists on the worker-lifetime container and runs after every matching future resolution.

Register a new after resolving attribute callback for all types.

The callback persists on the worker-lifetime container and runs after every future resolution with the matching attribute.

Fire all of the before resolving callbacks.

Fire an array of callbacks with an object.

Fire all of the resolving callbacks.

Fire all of the after resolving callbacks.

Fire all of the after resolving attribute callbacks.

Fire all callbacks that match the given abstract or object type.

Fire an array of callbacks with an object.

Get the class name or closure object ID the container is currently resolving.

Get the container's bindings.

Get the alias for an abstract if available.

Get the extender callbacks for a given type.

Remove all of the extender callbacks for a given type.

Clears worker-lifetime extender callbacks; concurrent resolutions may diverge depending on whether they resolved before or after the removal.

Drop all of the stale instances and aliases.

Forget every cached instance for an abstract without changing its lifecycle.

Remove a resolved instance from the instance cache.

Clears a worker-lifetime shared instance and current coroutine scoped instance; concurrent coroutines may still hold references that next resolution will not share.

Clear all of the instances from the container.

Clears worker-lifetime shared instances and all scoped context entries known to this container; concurrent coroutines may still hold references that next resolution will not share.

Clear all of the scoped instances from the container.

Clears this container's scoped instances in the current coroutine; runtime use can invalidate scoped services while the request is still using them.

Set the callback which determines the current container environment.

The resolver persists on the worker-lifetime container and is used by every currentEnvironmentIs() call.

Determine the environment for the container.

Flush the container of all bindings and resolved instances.

Clears the worker-lifetime container registry; runtime use breaks every concurrent resolution in the worker.

Give the cloned container its own coroutine context entries.

Like its shared instances, the clone starts with the scoped instances resolved in the current coroutine, but forgetting or replacing them on one container leaves the other's untouched.

Get the globally available instance of the container.

Set the shared instance of the container.

Replaces the process-wide container singleton; runtime use races across coroutines and breaks every facade/global container lookup.

Flush all static state.