froodi 1.0.0-alpha.1

An ergonomic Rust IoC container
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
97
98
99
100
101
102
103
104
105
106
107
108
109

use crate::{any::TypeInfo, macros_utils::types::RegistryOrEntry, registry::InstantiatorData, utils::hlist, Registry};

pub trait Merge<T> {
    #[must_use]
    fn merge(self, other: T) -> Self;
}

impl Merge<Registry> for Registry {
    #[inline]
    fn merge(mut self, other: Self) -> Self {
        self.entries.extend(other.entries);
        self
    }
}

impl Merge<(TypeInfo, InstantiatorData)> for Registry {
    #[inline]
    fn merge(mut self, (key, value): (TypeInfo, InstantiatorData)) -> Self {
        self.entries.insert(key, value);
        self
    }
}

impl Merge<RegistryOrEntry> for Registry {
    #[inline]
    fn merge(self, registry_or_entry: RegistryOrEntry) -> Self {
        match registry_or_entry {
            RegistryOrEntry::Registry(registry) => self.merge(registry),
            RegistryOrEntry::Entry(entry) => self.merge(entry),
        }
    }
}

impl<H> Merge<H> for Registry
where
    H: hlist::IntoIterator<RegistryOrEntry>,
{
    #[inline]
    fn merge(mut self, hlist: H) -> Self {
        for registry_or_entry in hlist.into_iter() {
            self = self.merge(registry_or_entry);
        }
        self
    }
}

#[cfg(feature = "async")]
mod async_impl {
    use super::{hlist, Merge, Registry, TypeInfo};
    use crate::{
        async_impl::{self, registry::InstantiatorData, RegistryWithSync},
        macros_utils::types::{RegistryKind, RegistryKindOrEntry},
    };

    impl Merge<RegistryWithSync> for RegistryWithSync {
        #[inline]
        fn merge(mut self, other: Self) -> Self {
            self.registry.entries.extend(other.registry.entries);
            self.sync = self.sync.merge(other.sync);
            self
        }
    }

    impl Merge<async_impl::Registry> for RegistryWithSync {
        #[inline]
        fn merge(mut self, other: async_impl::Registry) -> Self {
            self.registry.entries.extend(other.entries);
            self
        }
    }

    impl Merge<Registry> for RegistryWithSync {
        #[inline]
        fn merge(mut self, other: Registry) -> Self {
            self.sync = self.sync.merge(other);
            self
        }
    }

    impl Merge<(TypeInfo, InstantiatorData)> for RegistryWithSync {
        #[inline]
        fn merge(mut self, (key, value): (TypeInfo, InstantiatorData)) -> Self {
            self.registry.entries.insert(key, value);
            self
        }
    }

    impl Merge<RegistryKindOrEntry> for RegistryWithSync {
        #[inline]
        fn merge(self, registry_kind_or_entry: RegistryKindOrEntry) -> Self {
            match registry_kind_or_entry {
                RegistryKindOrEntry::Kind(RegistryKind::Sync(registry)) => self.merge(registry),
                RegistryKindOrEntry::Kind(RegistryKind::Async(registry)) => self.merge(registry),
                RegistryKindOrEntry::Kind(RegistryKind::AsyncWithSync(registry)) => self.merge(registry),
                RegistryKindOrEntry::Entry(entry) => self.merge(entry),
            }
        }
    }

    impl<H> Merge<H> for RegistryWithSync
    where
        H: hlist::IntoIterator<RegistryKindOrEntry>,
    {
        #[inline]
        fn merge(self, other: H) -> Self {
            other.into_iter().fold(self, RegistryWithSync::merge)
        }
    }
}