TwitterModule

Binds a type converter. The injector will use the given converter to convert string constants to matching types as needed.

Returns a new com.google.inject.Binder of type T with no com.google.inject.Scope that is bound with a binding annotation.

Returns a new com.google.inject.Binder of type T with no com.google.inject.Scope that is bound with a binding annotation A.

Returns a new com.google.inject.Binder of type T with no com.google.inject.Scope that is bound with no binding annotation.

Provides for installing and building a factory that combines the caller's arguments with injector-supplied values to construct objects. This is preferable to calling install on the TwitterModule which provides the factory as install is not supported for TwitterModule types.

Returns a new com.google.inject.multibindings.Multibinder that collects instances of type T in a scala.collection.immutable.Set that is itself bound with a binding annotation.

An API to bind multiple values separately, only to later inject them as a complete collection. "Multibinding" is intended for use in your application's module:

class SnacksModule extends TwitterModule {
  override protected def configure(): Unit = {
    bindMultiple[Snack].addBinding.toInstance(new Twix())
    bindMultiple[Snack].addBinding.toProvider[SnickersProvider]
    bindMultiple[Snack].addBinding.to[Skittles]
  }
}

With this binding, a Set[Snack] can now be injected:

class SnackMachine @Inject()(Set[Snack] snacks)

Contributing multibindings from different modules is also supported. For example, it is okay for both CandyModule and ChipsModule to create their own Multibinder[Snack], and to each contribute bindings to the set of snacks. When that set is injected, it will contain elements from both modules.

The set's iteration order is consistent with the binding order. This is convenient when multiple elements are contributed by the same module because that module can order its bindings appropriately. Avoid relying on the iteration order of elements contributed by different modules, since there is no equivalent mechanism to order modules.

The set is unmodifiable. Elements can only be added to the set by configuring the multibinder. Elements can never be removed from the set.

Elements are resolved at set injection time. If an element is bound to a provider, that provider's get method will be called each time the set is injected (unless the binding is also scoped).

Annotations can be used to create different sets of the same element type. Each distinct annotation gets its own independent collection of elements.

Elements MUST be distinct. If multiple bound elements have the same value, set injection will fail.

Elements MUST be non-null. If any set element is null, set injection will fail.

Returns a new com.google.inject.multibindings.Multibinder that collects instances of type T in a scala.collection.immutable.Set that is itself bound with a binding annotation A.

An API to bind multiple values separately, only to later inject them as a complete collection. "Multibinding" is intended for use in your application's module:

class SnacksModule extends TwitterModule {
  override protected def configure(): Unit = {
    bindMultiple[Snack].addBinding.toInstance(new Twix())
    bindMultiple[Snack].addBinding.toProvider[SnickersProvider]
    bindMultiple[Snack].addBinding.to[Skittles]
  }
}

With this binding, a Set[Snack] can now be injected:

class SnackMachine @Inject()(Set[Snack] snacks)

Contributing multibindings from different modules is also supported. For example, it is okay for both CandyModule and ChipsModule to create their own Multibinder[Snack], and to each contribute bindings to the set of snacks. When that set is injected, it will contain elements from both modules.

The set's iteration order is consistent with the binding order. This is convenient when multiple elements are contributed by the same module because that module can order its bindings appropriately. Avoid relying on the iteration order of elements contributed by different modules, since there is no equivalent mechanism to order modules.

The set is unmodifiable. Elements can only be added to the set by configuring the multibinder. Elements can never be removed from the set.

Elements are resolved at set injection time. If an element is bound to a provider, that provider's get method will be called each time the set is injected (unless the binding is also scoped).

Annotations can be used to create different sets of the same element type. Each distinct annotation gets its own independent collection of elements.

Elements MUST be distinct. If multiple bound elements have the same value, set injection will fail.

Elements MUST be non-null. If any set element is null, set injection will fail.

Returns a new com.google.inject.multibindings.Multibinder that collects instances of type T in a scala.collection.immutable.Set that is itself bound with no binding annotation.

An API to bind multiple values separately, only to later inject them as a complete collection. "Multibinding" is intended for use in your application's module:

class SnacksModule extends TwitterModule {
  override protected def configure(): Unit = {
    bindMultiple[Snack].addBinding.toInstance(new Twix())
    bindMultiple[Snack].addBinding.toProvider[SnickersProvider]
    bindMultiple[Snack].addBinding.to[Skittles]
  }
}

With this binding, a Set[Snack] can now be injected:

class SnackMachine @Inject()(Set[Snack] snacks)

Contributing multibindings from different modules is also supported. For example, it is okay for both CandyModule and ChipsModule to create their own Multibinder[Snack], and to each contribute bindings to the set of snacks. When that set is injected, it will contain elements from both modules.

The set's iteration order is consistent with the binding order. This is convenient when multiple elements are contributed by the same module because that module can order its bindings appropriately. Avoid relying on the iteration order of elements contributed by different modules, since there is no equivalent mechanism to order modules.

The set is unmodifiable. Elements can only be added to the set by configuring the multibinder. Elements can never be removed from the set.

Elements are resolved at set injection time. If an element is bound to a provider, that provider's get method will be called each time the set is injected (unless the binding is also scoped).

Annotations can be used to create different sets of the same element type. Each distinct annotation gets its own independent collection of elements.

Elements MUST be distinct. If multiple bound elements have the same value, set injection will fail.

Elements MUST be non-null. If any set element is null, set injection will fail.

Returns a new com.google.inject.multibindings.OptionalBinder that binds an instance of T in a scala.Option that is itself bound with a binding annotation.

Calling this method will always supply the bindings: Option[T] and Option[Provider[T]]. If setBinding or setDefault are called, it will also bind T.

setDefault is intended for use by frameworks that need a default value. User code can call setBinding to override the default.

Warning: even if setBinding is called, the default binding will still exist in the object graph. If it is a singleton, it will be instantiated in Stage.PRODUCTION.

If setDefault or setBinding are linked to Providers, the Provider may return null. If it does, the Option bindings will be a None. Binding setBinding to a Provider that returns null will not cause OptionalBinder to fall back to the setDefault binding.

If neither setDefault nor setBinding are called, it will try to link to a user-supplied binding of the same type. If no binding exists, the options will be absent. Otherwise, if a user-supplied binding of that type exists, or if setBinding or setDefault are called, the options will return Some(T) if they are bound to a non-null value, otherwise None.

Values are resolved at injection time. If a value is bound to a provider, that provider's get method will be called each time the option is injected (unless the binding is also scoped, or an option of provider is injected).

Annotations are used to create different options of the same key/value type. Each distinct annotation gets its own independent binding. For example:

class FrameworkModule extends TwitterModule {
  override protected def configure(): Unit = {
    bindOption[Renamer]
  }
}

With this module, an Option[Renamer] can now be injected. With no other bindings, the option will be None. Users can specify bindings in one of two ways:

Option 1:

class UserRenamerModule extends TwitterModule {
  override protected def configure(): Unit = {
    bind[Renamer].to[ReplacingRenamer]
  }
}

or Option 2:

class UserRenamerModule extends TwitterModule {
  override protected def configure(): Unit = {
    bindOption[Renamer].setBinding.to[ReplacingRenamer]
  }
}

With both options, the Option[Renamer] will be present and supply the ReplacingRenamer.

Default values can be supplied using:

 class FrameworkModule extends TwitterModule {
  override protected def configure(): Unit = {
    bindOption[String, LookupUrl].setDefault.toInstance(DefaultLookupUrl)
  }
}

With the above module, code can inject an @LookupUrl-annotated String and it will supply the DefaultLookupUrl. A user can change this value by binding:

class UserLookupModule extends TwitterModule {
  override protected def configure(): Unit = {
    bindOption[String, LookupUrl].setBinding.toInstance(CustomLookupUrl)
  }
}

which will override the default value.

If one module uses setDefault the only way to override the default is to use setBinding. It is an error for a user to specify the binding without using com.google.inject.multibindings.OptionalBinder if setDefault or setBinding are called. For example:

 class FrameworkModule extends TwitterModule {
  override protected def configure(): Unit = {
    bindOption[String, LookupUrl].setDefault.toInstance(DefaultLookupUrl)
  }
}
class UserLookupModule extends TwitterModule {
  override protected def configure(): Unit = {
    bind[String, LookupUrl].toInstance(CustomLookupUrl);
  }
}

would generate an error, because both the framework and the user are trying to bind @LookupUrl String.

Returns a new com.google.inject.multibindings.OptionalBinder that binds an instance of T in a scala.Option that is itself bound with a binding annotation A.

Calling this method will always supply the bindings: Option[T] and Option[Provider[T]]. If setBinding or setDefault are called, it will also bind T.

setDefault is intended for use by frameworks that need a default value. User code can call setBinding to override the default.

Warning: even if setBinding is called, the default binding will still exist in the object graph. If it is a singleton, it will be instantiated in Stage.PRODUCTION.

If setDefault or setBinding are linked to Providers, the Provider may return null. If it does, the Option bindings will be a None. Binding setBinding to a Provider that returns null will not cause OptionalBinder to fall back to the setDefault binding.

If neither setDefault nor setBinding are called, it will try to link to a user-supplied binding of the same type. If no binding exists, the options will be absent. Otherwise, if a user-supplied binding of that type exists, or if setBinding or setDefault are called, the options will return Some(T) if they are bound to a non-null value, otherwise None.

Values are resolved at injection time. If a value is bound to a provider, that provider's get method will be called each time the option is injected (unless the binding is also scoped, or an option of provider is injected).

Annotations are used to create different options of the same key/value type. Each distinct annotation gets its own independent binding. For example:

class FrameworkModule extends TwitterModule {
  override protected def configure(): Unit = {
    bindOption[Renamer]
  }
}

With this module, an Option[Renamer] can now be injected. With no other bindings, the option will be None. Users can specify bindings in one of two ways:

Option 1:

class UserRenamerModule extends TwitterModule {
  override protected def configure(): Unit = {
    bind[Renamer].to[ReplacingRenamer]
  }
}

or Option 2:

class UserRenamerModule extends TwitterModule {
  override protected def configure(): Unit = {
    bindOption[Renamer].setBinding.to[ReplacingRenamer]
  }
}

With both options, the Option[Renamer] will be present and supply the ReplacingRenamer.

Default values can be supplied using:

 class FrameworkModule extends TwitterModule {
  override protected def configure(): Unit = {
    bindOption[String, LookupUrl].setDefault.toInstance(DefaultLookupUrl)
  }
}

With the above module, code can inject an @LookupUrl-annotated String and it will supply the DefaultLookupUrl. A user can change this value by binding:

class UserLookupModule extends TwitterModule {
  override protected def configure(): Unit = {
    bindOption[String, LookupUrl].setBinding.toInstance(CustomLookupUrl)
  }
}

which will override the default value.

If one module uses setDefault the only way to override the default is to use setBinding. It is an error for a user to specify the binding without using com.google.inject.multibindings.OptionalBinder if setDefault or setBinding are called. For example:

 class FrameworkModule extends TwitterModule {
  override protected def configure(): Unit = {
    bindOption[String, LookupUrl].setDefault.toInstance(DefaultLookupUrl)
  }
}
class UserLookupModule extends TwitterModule {
  override protected def configure(): Unit = {
    bind[String, LookupUrl].toInstance(CustomLookupUrl);
  }
}

would generate an error, because both the framework and the user are trying to bind @LookupUrl String.

Returns a new com.google.inject.multibindings.OptionalBinder that binds an instance of T in a scala.Option.

Calling this method will always supply the bindings: Option[T] and Option[Provider[T]]. If setBinding or setDefault are called, it will also bind T.

setDefault is intended for use by frameworks that need a default value. User code can call setBinding to override the default.

Warning: even if setBinding is called, the default binding will still exist in the object graph. If it is a singleton, it will be instantiated in Stage.PRODUCTION.

If setDefault or setBinding are linked to Providers, the Provider may return null. If it does, the Option bindings will be a None. Binding setBinding to a Provider that returns null will not cause OptionalBinder to fall back to the setDefault binding.

If neither setDefault nor setBinding are called, it will try to link to a user-supplied binding of the same type. If no binding exists, the options will be absent. Otherwise, if a user-supplied binding of that type exists, or if setBinding or setDefault are called, the options will return Some(T) if they are bound to a non-null value, otherwise None.

Values are resolved at injection time. If a value is bound to a provider, that provider's get method will be called each time the option is injected (unless the binding is also scoped, or an option of provider is injected).

Annotations are used to create different options of the same key/value type. Each distinct annotation gets its own independent binding. For example:

class FrameworkModule extends TwitterModule {
  override protected def configure(): Unit = {
    bindOption[Renamer]
  }
}

With this module, an Option[Renamer] can now be injected. With no other bindings, the option will be None. Users can specify bindings in one of two ways:

Option 1:

class UserRenamerModule extends TwitterModule {
  override protected def configure(): Unit = {
    bind[Renamer].to[ReplacingRenamer]
  }
}

or Option 2:

class UserRenamerModule extends TwitterModule {
  override protected def configure(): Unit = {
    bindOption[Renamer].setBinding.to[ReplacingRenamer]
  }
}

With both options, the Option[Renamer] will be present and supply the ReplacingRenamer.

Default values can be supplied using:

 class FrameworkModule extends TwitterModule {
  override protected def configure(): Unit = {
    bindOption[String, LookupUrl].setDefault.toInstance(DefaultLookupUrl)
  }
}

With the above module, code can inject an @LookupUrl-annotated String and it will supply the DefaultLookupUrl. A user can change this value by binding:

class UserLookupModule extends TwitterModule {
  override protected def configure(): Unit = {
    bindOption[String, LookupUrl].setBinding.toInstance(CustomLookupUrl)
  }
}

which will override the default value.

If one module uses setDefault the only way to override the default is to use setBinding. It is an error for a user to specify the binding without using com.google.inject.multibindings.OptionalBinder if setDefault or setBinding are called. For example:

 class FrameworkModule extends TwitterModule {
  override protected def configure(): Unit = {
    bindOption[String, LookupUrl].setDefault.toInstance(DefaultLookupUrl)
  }
}
class UserLookupModule extends TwitterModule {
  override protected def configure(): Unit = {
    bind[String, LookupUrl].toInstance(CustomLookupUrl);
  }
}

would generate an error, because both the framework and the user are trying to bind @LookupUrl String.

Binds a com.google.inject.Scope to an annotation.

Returns a new com.google.inject.Binder of type T singleton-scoped that is bound with a binding annotation.

Returns a new com.google.inject.Binder of type T singleton-scoped that is bound with a binding annotation A.

Returns a new com.google.inject.Binder of type T singleton-scoped that is bound with no binding annotation.

Collects functions over a com.twitter.util.Closables. These functions will be passed to the application onExit function to be executed on graceful shutdown of the application.

Configures a com.google.inject.Binder via the exposed methods. A default implementation is provided such that extensions using only @Provides-annotated methods do not need to implement an empty TwitterModule.configure() method.

A Java-friendly method for creating a named Flag.

A Java-friendly way to create a "mandatory" Flag. "Mandatory" flags MUST have a value provided as an application argument (as they have no default value to be used).

Create a "mandatory" flag and add it to this Module's flags list."Mandatory" flags MUST have a value provided as an application argument (as they have no default value to be used).

Create a Flag and add it to this Module's flags list.

Additional framework modules to be composed into this module.

Returns the members injector used to inject dependencies into methods and fields on instances of the given type T. The returned members injector will not be valid until the main Injector has been created. The members injector will throw an IllegalStateException if you try to use it beforehand.

Returns the provider used to obtain instances for the given injection type T. The returned provider will not be valid until the Injector has been created. The provider will throw an IllegalStateException if you try to use it beforehand.

Uses the given com.google.inject.Module to configure more bindings. This is not supported for instances of type TwitterModule and will throw an UnsupportedOperationException if attempted on an instance of TwitterModule. This is to properly support the TwitterModuleLifecycle for TwitterModule instances.

Additional modules to be composed into this module from Java

Additional modules to be composed into this module. This list of modules is generally used instead of the TwitterModule.install method to properly support the TwitterModuleLifecycle for TwitterModule instances.

Upon successful creation, the Injector will inject static fields and methods in the given classes.

Invoke after external ports are bound and any clients are resolved

This method should only get singleton instances from the injector.

Invoked on graceful shutdown of the application.

This method should only get singleton instances from the injector.

Invoked after the injector is started.

This method should only get singleton instances from the injector.