"dependencies"

"add_dependency"

  $service->add_dependency(name=>$dep);

Adds a new dependency.

"get_dependency"

  my $dep = $service->get_dependency('name');

Gets a dependency by name.

"has_dependency"

  if ($service->has_dependency('name')) { ... }

Returns true if this service has a dependency with the given name.

"has_dependencies"

  if ($service->has_dependencies) { ... }

Returns true if this service has any dependency.

"get_all_dependencies"

  my %deps = $service->get_all_dependencies;

Returns all the dependencies for this service, as a key-value list.

"init_params"

"get"

"resolve_dependencies"

  my %name_object_map = $self->resolve_dependencies;

For each element of "dependencies", calls its "service" method to retrieve the service we're dependent on, then tries to instantiate the value of the service. This can happen in a few different ways:

the service is not locked, and does not require any parameter

just call "get" on it

the service is not locked, requires parameters, but the dependency has values for them

call "$service->get(%{$dependency->service_params})"

the service is not locked, requires parameters, and we don't have values for them

we can't instantiate anything at this point, so we use a Bread::Board::Service::Deferred::Thunk instance, on which you can call the "inflate" method, passing it all the needed parameters, to get the actual instance

the service is locked

we return a Bread::Board::Service::Deferred that will proxy to the instance that the service will eventually return; yes, this means that in many cases circular dependencies can be resolved, at the cost of a proxy object