const mixinafIoc::Scope

Autobuilds an instance of the given type. Autobuilding performs the following:

• creates an instance via the ctor marked with @Inject or the best fitting ctor with the most parameters
• inject dependencies into fields (of all visibilities)
• calls any method on the class annotated with @PostInjection

ctorArgs (if provided) will be passed as arguments to the constructor. Constructor parameters should be defined in the following order:

new make(<config>, <ctorArgs>, <dependencies>, <it-block>) { ... }

Note that fieldVals are set by an it-block function, should the ctor define one.

Calls the given func. Any func arguments not given are resolved as dependencies. Func parameters should be defined in the following order:

|<args>, <dependencies>, <default params>| { ... }

Note that nullable and default parameters are treated as optional dependencies.

Returns the result of calling the func.

Calls the given method. Any method arguments not given are resolved as dependencies. instance may be null if calling a static method. Method parameters should be defined in the following order:

Void myMethod(<args>, <dependencies>, <default params>) { ... }

Note that nullable and default parameters are treated as optional dependencies.

Returns the result of calling the method.

Creates a nested child scope and makes it available to the given function, which is called straight away. The child scope also becomes the active scope for the duration of the function.

scope.createChild("childScopeId") |Scope childScope| {
    ...
}

If a function is passed in then null is returned because the scope is not valid outside of the function.

Advanced users may create non-active scopes by not passing in a function and using the returned scope. Non-active scopes must be manually destroyed.

myScope := scope.createChild("myScope")

... use myScope ...

myScope.destroy

Destroys this scope and releases references to any services created. Calls any scope destroy hooks.

Returns the unique id of this Scope.

Injects services and dependencies into fields of all visibilities and calls any method on the class annotated with @PostInjection.

Returns the object passed in for method chaining.

Returns true if this scope is threaded and may hold non-const services.

Jail breaks an active scope so it may be used from outside its closure.

childScope := (Scope?) null

scope.createChild("childScopeId") |childScopeInClosure| {
    childScope = childScopeInClosure.jailbreak
}

... use childScope here ...
childScope.serviceByType(...)

childScope.destroy

Once jailbroken, you are responsible for calling destroy().

Returns the parent scope.

Returns the registry instance this scope belongs to.

Resolves a service by its ID. Throws IocErr if the service is not found, unless checked is false.

Resolves a service by its Type. Throws IocErr if the service is not found, unless checked is false.