noema 0.4.0

Noema IOC and DI framework for Rust
Documentation 
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

/// Register request handlers and optional per-input pipeline behaviors (compile-time).
///
/// Optionally call [`global_pipeline!`](crate::global_pipeline) and
/// [`enable_global_pipeline`](crate::mediator::global::enable_global_pipeline) to prepend global behaviors.
///
/// # Syntax
///
/// ```ignore
/// request!(MyInput: MyInputHandler);
/// request!(CreateOrder: CreateOrderHandler => [ValidateOrder, LogRequest]);
/// ```
///
/// Handler and each behavior MUST implement [`Injectable`](crate::core::Injectable).
#[macro_export]
macro_rules! request {
    ($($input:path: $handler:ty $(=> [$($behavior:ty),* $(,)?])?),* $(,)?) => {
        $(
            $crate::__request_one!($input, $handler, [$($($behavior),*)*]);
        )*
    };
}

#[doc(hidden)]
#[macro_export]
macro_rules! __request_one {
    ($input:path, $handler:ty, []) => {
        const _: () = {
            use std::sync::Arc;

            use $crate::core::{Container, Injectable};
            use $crate::mediator::global::GLOBAL;
            use ::std::sync::atomic::Ordering;
            use $crate::mediator::pipeline::run_pipeline;
            use $crate::mediator::{InputHandler, Mediator};

            #[async_trait::async_trait]
            impl Mediator<$input> for Container {
                async fn send(
                    input: $input,
                ) -> $crate::mediator::NoemaResult<<$input as $crate::mediator::Input>::Output> {
                    let input = Arc::new(input);
                    let handler: $crate::arc_dyn!(InputHandler<$input>) =
                        Arc::new(<$handler as Injectable<Container>>::inject(&Container));

                    let mut behaviors = Vec::new();
                    if GLOBAL.load(Ordering::Acquire) {
                        __noema_emit_globals!($input, behaviors);
                    }
                    let behaviors = Arc::<[_]>::from(behaviors);

                    run_pipeline(input, handler, behaviors).await
                }
            }
        };
    };

    ($input:path, $handler:ty, [$($behavior:ty),* $(,)?]) => {
        const _: () = {
            use std::sync::Arc;

            use $crate::core::{Container, Injectable};
            use $crate::mediator::global::GLOBAL;
            use ::std::sync::atomic::Ordering;
            use $crate::mediator::pipeline::run_pipeline;
            use $crate::mediator::{InputHandler, Mediator};

            #[async_trait::async_trait]
            impl Mediator<$input> for Container {
                async fn send(
                    input: $input,
                ) -> $crate::mediator::NoemaResult<<$input as $crate::mediator::Input>::Output> {
                    let input = Arc::new(input);
                    let handler: $crate::arc_dyn!(InputHandler<$input>) =
                        Arc::new(<$handler as Injectable<Container>>::inject(&Container));

                    let mut behaviors = Vec::new();
                    if GLOBAL.load(Ordering::Acquire) {
                        __noema_emit_globals!($input, behaviors);
                    }
                    $(
                        behaviors.push(
                            Arc::new(
                                <$behavior as Injectable<Container>>::inject(&Container),
                            ) as ::std::sync::Arc<
                                dyn $crate::mediator::PipelineBehavior<$input> + Send + Sync,
                            >,
                        );
                    )*
                    let behaviors = Arc::<[_]>::from(behaviors);

                    run_pipeline(input, handler, behaviors).await
                }
            }
        };
    };
}