const mixinafIoc::Scope

(Advanced Use Only)

Runs the given function with this Scope as the active one. Note this method does not destroy the scope.

Under normal usage, consider using createChild(...) instead.

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| {
    ...
}

When a function is passed in then null is returned because the scope would not be 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

To create an active scope that remains active outside of the closure, use jailBreak().

(Advanced Use Only)

Destroys this scope and releases references to any services created. Calls any scope destroy hooks. Pops this scope off the active stack.

destroy() does nothing if called more than once.

Returns the unique id of this Scope.

Returns a recursive list of all the Scopes this Scope inherits from. The result list always starts with this Scope itself.

syntax: fantom scope.inheritance() // --> ui, root, builtIn

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 has been destroyed.

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

(Advanced Use Only)

Jail breaks an active scope so it remains active outside its closure. Jail broken scopes are not destroyed so you are responsible for calling destroy() yourself.

childScope := (Scope?) null

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

// --> "childScopeId" is still active!
echo(scope.registry.activeScope)

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

childScope.destroy

Note that jail broken scopes are only active in the current thread, but will remain the active scope even if the thread is re-entered.

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.