Crate syrette

Syrette

Syrette is a framework for utilizing inversion of control & dependency injection.

Example

use std::error::Error;

use syrette::ptr::TransientPtr;
use syrette::{injectable, DIContainer};

trait IWeapon
{
    fn deal_damage(&self, damage: i32);
}

struct Sword {}

#[injectable(IWeapon)] // Makes Sword injectable with a interface of IWeapon
impl Sword
{
    fn new() -> Self
    {
        Self {}
    }
}

impl IWeapon for Sword
{
    fn deal_damage(&self, damage: i32)
    {
        println!("Sword dealt {} damage!", damage);
    }
}

trait IWarrior
{
    fn fight(&self);
}

struct Warrior
{
    weapon: TransientPtr<dyn IWeapon>,
}

#[injectable(IWarrior)] // Makes Warrior injectable with a interface of IWarrior
impl Warrior
{
    fn new(weapon: TransientPtr<dyn IWeapon>) -> Self
    {
        Self { weapon }
    }
}

impl IWarrior for Warrior
{
    fn fight(&self)
    {
        self.weapon.deal_damage(30);
    }
}

fn main() -> Result<(), Box<dyn Error>>
{
    let mut di_container = DIContainer::new();

    // Creates a binding of the interface IWeapon to the concrete type Sword
    di_container.bind::<dyn IWeapon>().to::<Sword>()?;

    // Creates a binding of the interface IWarrior to the concrete type Warrior
    di_container.bind::<dyn IWarrior>().to::<Warrior>()?;

    // Create a transient IWarrior with all of its dependencies automatically injected
    let warrior = di_container.get::<dyn IWarrior>()?.transient()?;

    warrior.fight();

    println!("Warrior has fighted");

    Ok(())
}

Re-exports

• pub use di_container::asynchronous::AsyncDIContainer;
• pub use di_container::blocking::DIContainer;

Modules

• dependency_history
  Dependency history.
• di_container
  Dependency injection container types.
• errors
  Error types for various components of the library.
• futureasync
  Future related utilities.
• interfaces
  Various useful interfaces.
• ptr
  Smart pointer type aliases.

Macros

• declare_default_factoryfactory
  Shortcut for declaring a default factory.
• declare_interface
  Declares the interface trait of a implementation.
• di_container_bind
  Shortcut for creating a DI container binding for a injectable without a declared interface.

Attribute Macros

• factoryfactory
  Makes a type alias usable as a factory interface.
• injectable
  Makes a type injectable.
• named
  Used to declare the name of a dependency in the constructor of a impl block decorated with injectable.