1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
#![cfg_attr(feature = "factory", feature(unboxed_closures, fn_traits))]
#![deny(clippy::all)]
#![deny(clippy::pedantic)]
#![deny(missing_docs)]
//! Syrette
//!
//! Syrette is a collection of utilities useful for performing dependency injection.
pub mod di_container;
pub mod errors;
pub mod interfaces;
pub mod ptr;
pub use di_container::DIContainer;
pub use syrette_macros::*;
#[cfg(feature = "factory")]
#[doc(hidden)]
pub mod castable_factory;
#[doc(hidden)]
pub mod dependency_trace;
#[doc(hidden)]
pub mod libs;
// Private
mod di_container_binding_map;
mod provider;
/// Shortcut for creating a DI container binding for a injectable without a declared
/// interface.
///
/// This will declare a interface for the implementation.
///
/// Useful for when the implementation or the interface is generic.
///
/// # Arguments
/// {interface} => {implementation}, {DI container variable name}
///
/// # Examples
/// ```
/// # use syrette::{di_container_bind, DIContainer, injectable};
/// #
/// # trait INinja {}
/// #
/// # struct Ninja {}
/// #
/// # #[injectable]
/// # impl Ninja
/// # {
/// # fn new() -> Self
/// # {
/// # Self {}
/// # }
/// # }
/// #
/// # impl INinja for Ninja {}
/// #
/// let mut di_container = DIContainer::new();
///
/// di_container_bind!(INinja => Ninja, di_container);
/// ```
#[macro_export]
macro_rules! di_container_bind {
($interface: path => $implementation: ty, $di_container: ident) => {
$di_container.bind::<dyn $interface>().to::<$implementation>().unwrap();
syrette::declare_interface!($implementation -> $interface);
};
}
/// Shortcut for declaring a default factory.
///
/// A default factory is a factory that doesn't take any arguments.
///
/// More tedious ways to accomplish what this macro does would either be by using
/// the [`factory`] macro or by manually declaring the interfaces
/// with the [`declare_interface`] macro.
///
/// *This macro is only available if Syrette is built with the "factory" feature.*
///
/// # Arguments
/// - Interface trait
///
/// # Examples
/// ```
/// # use syrette::declare_default_factory;
/// #
/// trait IParser
/// {
/// // Methods and etc here...
/// }
///
/// declare_default_factory!(dyn IParser);
/// ```
///
/// The expanded equivelent of this would be
///
/// ```
/// # use syrette::declare_default_factory;
/// #
/// trait IParser {
/// // Methods and etc here...
/// }
///
/// syrette::declare_interface!(
/// syrette::castable_factory::CastableFactory<
/// (),
/// dyn IParser,
/// > -> syrette::interfaces::factory::IFactory<(), dyn IParser>
/// );
///
/// syrette::declare_interface!(
/// syrette::castable_factory::CastableFactory<
/// (),
/// dyn IParser,
/// > -> syrette::interfaces::any_factory::AnyFactory
/// );
/// ```
#[macro_export]
#[cfg(feature = "factory")]
macro_rules! declare_default_factory {
($interface: ty) => {
syrette::declare_interface!(
syrette::castable_factory::CastableFactory<
(),
$interface,
> -> syrette::interfaces::factory::IFactory<(), $interface>
);
syrette::declare_interface!(
syrette::castable_factory::CastableFactory<
(),
$interface,
> -> syrette::interfaces::any_factory::AnyFactory
);
}
}
|
