Struct ServiceBindings 

pub struct ServiceBindings { /* private fields */ }

Collection of service bindings

Implementations

impl ServiceBindings

pub fn new() -> Self

Create a new service bindings collection

pub fn add_descriptor(&mut self, descriptor: ServiceDescriptor)

Add a service descriptor

pub fn descriptors(&self) -> &[ServiceDescriptor]

Get all service descriptors

pub fn get_descriptor( &self, service_id: &ServiceId, ) -> Option<&ServiceDescriptor>

Get service descriptors by service ID

pub fn get_descriptor_named<T: 'static + ?Sized>( &self, name: &str, ) -> Option<&ServiceDescriptor>

Get service descriptor by type and name without allocation

pub fn service_ids(&self) -> Vec<ServiceId>

Get all service IDs

pub fn contains(&self, service_id: &ServiceId) -> bool

Check if a service is registered

pub fn contains_named<T: 'static + ?Sized>(&self, name: &str) -> bool

Check if a named service is registered without allocation

pub fn count(&self) -> usize

Get the number of registered services

pub fn into_descriptors(self) -> Vec<ServiceDescriptor>

Consume self and return all descriptors

Trait Implementations

impl Debug for ServiceBindings

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ServiceBindings

fn default() -> Self

Returns the “default value” for a type.

impl ServiceBinder for ServiceBindings

fn add_service_descriptor( &mut self, descriptor: ServiceDescriptor, ) -> Result<&mut Self, CoreError>

Add a pre-built service descriptor

fn bind<TInterface: ?Sized + 'static, TImpl: Send + Sync + Default + 'static>( &mut self, ) -> &mut Self

Bind an interface to an implementation

fn bind_singleton<TInterface: ?Sized + 'static, TImpl: Send + Sync + Default + 'static>( &mut self, ) -> &mut Self

Bind an interface to an implementation with singleton lifetime

fn bind_transient<TInterface: ?Sized + 'static, TImpl: Send + Sync + Default + 'static>( &mut self, ) -> &mut Self

Bind an interface to an implementation with transient lifetime

fn bind_factory<TInterface: ?Sized + 'static, F, T>( &mut self, factory: F, ) -> &mut Self

where F: Fn() -> Result<T, CoreError> + Send + Sync + 'static, T: Send + Sync + 'static,

Bind a service using a factory function

fn bind_instance<TInterface: ?Sized + 'static, TImpl: Send + Sync + Clone + 'static>( &mut self, instance: TImpl, ) -> &mut Self

Bind a pre-created instance

fn bind_named<TInterface: ?Sized + 'static, TImpl: Send + Sync + Default + 'static>( &mut self, name: &str, ) -> &mut Self

Bind a named service

fn bind_injectable<T: Injectable>(&mut self) -> &mut Self

Bind an Injectable service with auto-wiring

fn bind_injectable_singleton<T: Injectable>(&mut self) -> &mut Self

Bind an Injectable service as singleton with auto-wiring

fn bind_with<TInterface: ?Sized + 'static, TImpl: Send + Sync + Default + 'static>( &mut self, ) -> AdvancedBindingBuilder<TInterface>

Advanced bind with fluent configuration - returns builder for chaining

fn with_implementation<TInterface: ?Sized + 'static, TImpl: Send + Sync + Default + 'static>( &mut self, config: BindingConfig, ) -> &mut Self

Complete advanced binding with implementation

fn bind_lazy<TInterface: ?Sized + 'static, F, T>( &mut self, factory: F, ) -> &mut Self

where F: Fn() -> T + Send + Sync + 'static, T: Send + Sync + 'static,

Bind a lazy service using factory that gets called only when needed

fn bind_parameterized_factory<TInterface: ?Sized + 'static, P, F, T>( &mut self, _factory: F, ) -> &mut Self

where F: Fn(P) -> Result<T, CoreError> + Send + Sync + 'static, T: Send + Sync + 'static, P: Send + Sync + 'static,

Bind with parameterized factory

fn bind_collection<TInterface: ?Sized + 'static, F>( &mut self, configure: F, ) -> &mut Self

where F: FnOnce(&mut CollectionBindingBuilder<TInterface>),

Bind a collection of services using a closure-based configuration