container

type AutoGroupType ¶

type AutoGroupType interface {
	// IsAutoGroupType is a marker function which just indicates that this is a auto-group type.
	IsAutoGroupType()
}

AutoGroupType marks a type which automatically gets grouped together. For an AutoGroupType T, T and []T can be declared as output parameters for providers as many times within the container as desired. All of the provided values for T can be retrieved by declaring an []T input parameter.

type DebugOption ¶

type DebugOption interface {
	// contains filtered or unexported methods
}

DebugOption is a functional option for running a container that controls debug logging and visualization output.

func Debug() DebugOption

func DebugOptions(options ...DebugOption) DebugOption

func FileVisualizer(filename, format string) DebugOption

func LogVisualizer() DebugOption

func Logger(logger func(string)) DebugOption

func StdoutLogger() DebugOption

func Visualizer(visualizer func(dotGraph string)) DebugOption

type In ¶

type In struct{}

In can be embedded in another struct to inform the container that the fields of the struct should be treated as dependency inputs. This allows a struct to be used to specify dependencies rather than positional parameters.

Fields of the struct may support the following tags:

optional	if set to true, the dependency is optional and will
			be set to its default value if not found, rather than causing
			an error

type Location ¶

type Location interface {
	Name() string
	fmt.Stringer
	fmt.Formatter
	// contains filtered or unexported methods
}

func LocationFromCaller(skip int) Location

func LocationFromPC(pc uintptr) Location

type ModuleKey ¶

type ModuleKey struct {
	// contains filtered or unexported fields
}

ModuleKey is a special type used to scope a provider to a "module".

Special module-scoped providers can be used with Provide by declaring a provider with an input parameter of type ModuleKey. These providers may construct a unique value of a dependency for each module and will be called at most once per module.

Providers passed to ProvideInModule can also declare an input parameter of type ModuleKey to retrieve their module key but these providers will be called at most once.

func (k ModuleKey) Name() string

type OnePerModuleType ¶

type OnePerModuleType interface {
	// IsOnePerModuleType is a marker function just indicates that this is a one-per-module type.
	IsOnePerModuleType()
}

OnePerModuleType marks a type which can have up to one value per module. All of the values for a one-per-module type T and their respective modules, can be retrieved by declaring an input parameter map[string]T.

type Option ¶

type Option interface {
	// contains filtered or unexported methods
}

Option is a functional option for a container.

func Error(err error) Option

func Options(opts ...Option) Option

func Provide(providers ...interface{}) Option

func ProvideInModule(moduleName string, providers ...interface{}) Option

func Supply(values ...interface{}) Option

type Out ¶

type Out struct{}

Out can be embedded in another struct to inform the container that the fields of the struct should be treated as dependency outputs. This allows a struct to be used to specify outputs rather than positional return values.

type ProviderDescriptor ¶

type ProviderDescriptor struct {
	// Inputs defines the in parameter types to Fn.
	Inputs []ProviderInput

	// Outputs defines the out parameter types to Fn.
	Outputs []ProviderOutput

	// Fn defines the provider function.
	Fn func([]reflect.Value) ([]reflect.Value, error)

	// Location defines the source code location to be used for this provider
	// in error messages.
	Location Location
}

ProviderDescriptor defines a special provider type that is defined by reflection. It should be passed as a value to the Provide function. Ex:

option.Provide(ProviderDescriptor{ ... })

func ExtractProviderDescriptor(provider interface{}) (ProviderDescriptor, error)

type ProviderInput ¶

type ProviderInput struct {
	Type     reflect.Type
	Optional bool
}

type ProviderOutput ¶

type ProviderOutput struct {
	Type reflect.Type
}