modrun 1.0.0

Modular application composer for Tokio: domain modules, typed wiring, lifecycle
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

use std::any::{TypeId, type_name};

/// Maximum constructor / invoker arity. Matches the `ProviderFn` / `InvokeFn` impls.
pub(crate) const MAX_DEPS: usize = 8;

/// One constructor / invoker parameter.
#[derive(Clone, Copy)]
pub(crate) struct Dep {
    pub id: TypeId,
    pub name: &'static str,
}

/// Stack-allocated dependency list. Arity is known at compile time (0–8).
#[derive(Clone, Copy)]
pub(crate) struct DepList {
    items: [(TypeId, &'static str); MAX_DEPS],
    len: u8,
}

impl DepList {
    pub(crate) fn empty() -> Self {
        Self {
            items: [(TypeId::of::<()>(), ""); MAX_DEPS],
            len: 0,
        }
    }

    pub(crate) fn from_array<const N: usize>(arr: [Dep; N]) -> Self {
        const { assert!(N <= MAX_DEPS, "constructors accept at most 8 parameters") };
        let mut items = [(TypeId::of::<()>(), ""); MAX_DEPS];
        for (i, dep) in arr.into_iter().enumerate() {
            items[i] = (dep.id, dep.name);
        }
        Self {
            items,
            len: N as u8,
        }
    }

    pub(crate) fn as_slice(&self) -> &[(TypeId, &'static str)] {
        &self.items[..self.len as usize]
    }
}

/// Compile-time `(TypeId, type_name)` pair for a dependency parameter.
#[inline]
pub(crate) fn dep<T: 'static>() -> Dep {
    Dep {
        id: TypeId::of::<T>(),
        name: type_name::<T>(),
    }
}