microsite
API
Generated with
microsite/izumi/izumi.distage/izumi.distage.model/Injector

Injector

izumi.distage.model.Injector
See theInjector companion object
trait Injector[F[_]] extends Planner, Producer

Injector creates object graphs (izumi.distage.model.Locators) from a izumi.distage.model.definition.ModuleDef or from an izumi.distage.model.plan.Plan

Attributes

See also
Companion
object
Graph
Supertypes
trait Producer
trait Planner
class Object
trait Matchable
class Any
Known subtypes

Members list

Value members

Abstract methods

def providedKeys: Set[DIKey]

Keys that will be available to the module interpreted by this Injector, includes parent Locator keys, izumi.distage.modules.DefaultModule & Injector's self-reference keys

Keys that will be available to the module interpreted by this Injector, includes parent Locator keys, izumi.distage.modules.DefaultModule & Injector's self-reference keys

Attributes

Concrete methods

final def assert(bindings: ModuleBase, roots: Roots, excludedActivations: Set[NESet[AxisChoice]] = ...): Unit

Efficiently check all possible paths for the given module to the given roots,

Efficiently check all possible paths for the given module to the given roots,

This is a "raw" version of izumi.distage.framework.PlanCheck API, please use PlanCheck for all non-exotic needs.

This method executes at runtime, to check correctness at compile-time use PlanCheck API from distage-framework module.

Attributes

Returns

Unit

Throws
PlanCheckException

on found issues

See also
final def produce(input: PlannerInput): Lifecycle[F, Locator]

Create an effectful izumi.distage.model.definition.Lifecycle value that encapsulates the allocation and cleanup of an object graph described by input

Create an effectful izumi.distage.model.definition.Lifecycle value that encapsulates the allocation and cleanup of an object graph described by input

 class HelloWorld {
   def hello() = println("hello world")
 }

 Injector()
   .produce(PlannerInput(
     bindings = new ModuleDef {
       make[HelloWorld]
     },
     activation = Activation.empty,
     roots = Roots.target[HelloWorld],
   ))
   .use(_.get[HelloWorld].hello())

Value parameters

input

Bindings created by izumi.distage.model.definition.ModuleDef DSL and garbage collection roots. Garbage collector will remove all bindings that aren't direct or indirect dependencies of the chosen root DIKeys from the plan - they will never be instantiated. If left empty, garbage collection will not be performed – that would be equivalent to designating all DIKeys as roots.

Attributes

Returns

A Resource value that encapsulates allocation and cleanup of the object graph described by input

final def produce(bindings: ModuleBase, roots: Roots, activation: Activation = ..., locatorPrivacy: LocatorPrivacy = ...): Lifecycle[F, Locator]
final def produce(plan: Plan): Lifecycle[F, Locator]

Create an effectful izumi.distage.model.definition.Lifecycle value that encapsulates the allocation and cleanup of an object graph described by an existing plan

Create an effectful izumi.distage.model.definition.Lifecycle value that encapsulates the allocation and cleanup of an object graph described by an existing plan

 class HelloWorld {
   def hello() = println("hello world")
 }

 val injector = Injector()

 val plan = injector.plan(PlannerInput(
     bindings = new ModuleDef {
       make[HelloWorld]
     },
     activation = Activation.empty,
     roots = Roots.target[HelloWorld],
   )).getOrThrow()

 injector
   .produce(plan)
   .use(_.get[HelloWorld].hello())

Value parameters

plan

Computed wiring plan, may be produced by calling the plan method

Attributes

Returns

A Resource value that encapsulates allocation and cleanup of the object graph described by input

final def produceCustomF[G[_]](input: PlannerInput)(implicit evidence$1: Tag[G], G: QuasiIO[G]): Lifecycle[G, Locator]

Produce izumi.distage.model.Locator interpreting effect and resource bindings into the provided effect type

Produce izumi.distage.model.Locator interpreting effect and resource bindings into the provided effect type

Attributes

final def produceCustomIdentity(input: PlannerInput): Lifecycle[Identity, Locator]

Produce izumi.distage.model.Locator, supporting only effect and resource bindings in Identity

Produce izumi.distage.model.Locator, supporting only effect and resource bindings in Identity

Attributes

final def produceDetailedCustomF[G[_]](input: PlannerInput)(implicit evidence$1: Tag[G], G: QuasiIO[G]): Lifecycle[G, Either[FailedProvision, Locator]]
final def produceEval[A](bindings: ModuleBase, activation: Activation = ...)(function: Functoid[F[A]]): Lifecycle[F, A]

Create an effectful izumi.distage.model.definition.Lifecycle value that encapsulates the allocation and cleanup of an object graph described by the input module, designate all arguments of the provided function as roots of the graph and run the function.

Create an effectful izumi.distage.model.definition.Lifecycle value that encapsulates the allocation and cleanup of an object graph described by the input module, designate all arguments of the provided function as roots of the graph and run the function.

 class Hello { def hello() = println("hello") }
 class World { def world() = println("world") }

 Injector()
   .produceEval(new ModuleDef {
     make[Hello]
     make[World]
   }) {
     (hello: Hello, world: World) =>
       hello.hello()
       world
   }
   .use {
     world =>
       world.world()
   }

This is useful for the common case when you want to run an effect using the produced objects from the object graph, without finalizing the object graph yet

Injector[F]().produceEval[A](moduleDef)(fn) is a short-hand for:

 Injector[F]()
   .produce(moduleDef, Roots(fn.get.diKeys.toSet))
   .evalMap(_.run(fn)): Lifecycle[F, A]

Value parameters

activation

A map of axes of configuration to choices along these axes

bindings

Bindings created by izumi.distage.model.definition.ModuleDef DSL

function

N-ary izumi.distage.model.providers.Functoid function for which arguments will be designated as roots and provided from the object graph

Attributes

final def produceGet[A : Tag](bindings: ModuleBase, activation: Activation): Lifecycle[F, A]

Create an effectful izumi.distage.model.definition.Lifecycle value that encapsulates the allocation and cleanup of an object graph described by the input module, designate A as the root of the graph and retrieve A from the result.

Create an effectful izumi.distage.model.definition.Lifecycle value that encapsulates the allocation and cleanup of an object graph described by the input module, designate A as the root of the graph and retrieve A from the result.

 class HelloWorld {
   def hello() = println("hello world")
 }

 Injector()
   .produceGet[HelloWorld](new ModuleDef {
     make[HelloWorld]
   })
   .use(_.hello())

This is useful for the common case when your main logic class is the root of your graph AND the object you want to use immediately.

Injector[F]().produceGet[A](moduleDef) is a short-hand for:

 Injector[F]()
   .produce(moduleDef, Roots(DIKey.get[A]))
   .map(_.get[A]): Lifecycle[F, A]

Value parameters

activation

A map of axes of configuration to choices along these axes

bindings

Bindings created by izumi.distage.model.definition.ModuleDef DSL

Attributes

final def produceGet[A : Tag](bindings: ModuleBase): Lifecycle[F, A]
final def produceGet[A : Tag](name: Identifier)(bindings: ModuleBase, activation: Activation = ...): Lifecycle[F, A]
final def produceRun[A](bindings: ModuleBase, activation: Activation = ...)(function: Functoid[F[A]]): F[A]

Create an object graph described by the input module, designate all arguments of the provided function as roots of the graph, and run the function, deallocating the object graph when the function exits.

Create an object graph described by the input module, designate all arguments of the provided function as roots of the graph, and run the function, deallocating the object graph when the function exits.

 class Hello { def hello() = println("hello") }
 class World { def world() = println("world") }

 Injector()
   .produceRun(new ModuleDef {
     make[Hello]
     make[World]
   }) {
     (hello: Hello, world: World) =>
       hello.hello()
       world.world()
   }

This is useful for the common case when you want to run an effect using the produced objects from the object graph and deallocate the object graph once the effect is finished

Injector[F]().produceRun[A](moduleDef)(fn) is a short-hand for:

 Injector[F]()
   .produce(moduleDef, Roots(fn.get.diKeys.toSet))
   .use(_.run(fn)): F[A]

Value parameters

activation

A map of axes of configuration to choices along these axes

bindings

Bindings created by izumi.distage.model.definition.ModuleDef DSL

function

N-ary izumi.distage.model.providers.Functoid function for which arguments will be designated as roots and provided from the object graph

Attributes

final def verify(bindings: ModuleBase, roots: Roots, excludedActivations: Set[NESet[AxisChoice]] = ...): PlanVerifierResult

Efficiently check all possible paths for the given module to the given roots,

Efficiently check all possible paths for the given module to the given roots,

This is a "raw" version of izumi.distage.framework.PlanCheck API, please use PlanCheck for all non-exotic needs.

This method executes at runtime, to check correctness at compile-time use PlanCheck API from distage-framework module.

Attributes

Returns

Set of issues if any.

Throws
Nothing

Does not throw.

See also

Inherited methods

final def plan(bindings: ModuleBase, roots: Roots, activation: Activation = ..., locatorPrivacy: LocatorPrivacy = ...): Either[NEList[DIError], Plan]

Attributes

Inherited from:
Planner
final def planUnsafe(input: PlannerInput): Plan

Attributes

Inherited from:
Planner
final def produceCustomF[F[_] : TagK : QuasiIO](plan: Plan): Lifecycle[F, Locator]

Produce izumi.distage.model.Locator interpreting effect- and resource-bindings into the provided F

Produce izumi.distage.model.Locator interpreting effect- and resource-bindings into the provided F

Attributes

Inherited from:
Producer
final def produceCustomIdentity(plan: Plan): Lifecycle[Identity, Locator]

Produce izumi.distage.model.Locator, supporting only effect- and resource-bindings in Identity

Produce izumi.distage.model.Locator, supporting only effect- and resource-bindings in Identity

Attributes

Inherited from:
Producer
final def produceDetailedCustomF[F[_] : TagK : QuasiIO](plan: Plan): Lifecycle[F, Either[FailedProvision, Locator]]

Attributes

Inherited from:
Producer
final def produceDetailedIdentity(plan: Plan): Lifecycle[Identity, Either[FailedProvision, Locator]]

Attributes

Inherited from:
Producer

Inherited and Abstract methods

def plan(input: PlannerInput): Either[NEList[DIError], Plan]

Attributes

Inherited from:
Planner
def planNoRewrite(input: PlannerInput): Either[NEList[DIError], Plan]

Does the same job as plan() but does not apply any binding rewrites (autocloseables, resources, etc) Most likely you won't need to call this method directly.

Does the same job as plan() but does not apply any binding rewrites (autocloseables, resources, etc) Most likely you won't need to call this method directly.

Attributes

Inherited from:
Planner
def rewrite(bindings: ModuleBase): ModuleBase

Attributes

Inherited from:
Planner
Generated with