minfac 0.1.4

Lightweight Inversion Of Control
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
110
111

use core::any::type_name;

use crate::ffi::FfiResult::{FfiErr, FfiOk};

use crate::{
    ffi::FfiUsizeIterator,
    resolvable::SealedResolvable,
    strategy::{Identifyable, Strategy},
    untyped::{AutoFreePointer, UntypedFn},
    AliasBuilder, AnyPtr, GenericServiceCollection, InternalBuildResult, Resolvable,
    ServiceProducer, ServiceProvider, UntypedFnFactory, UntypedFnFactoryContext,
};

/// Implemented for fn(), fn(T), fn(T, T) etc. to allow using the same method on ServiceProvider
pub trait Registrar<TS: Strategy> {
    type Item;
    fn register(
        self,
        collection: &mut GenericServiceCollection<TS>,
    ) -> AliasBuilder<'_, Self::Item, TS>;
}

impl<TS: Strategy, T: Identifyable<TS::Id>> Registrar<TS> for fn() -> T {
    type Item = T;

    fn register(
        self,
        collection: &mut GenericServiceCollection<TS>,
    ) -> AliasBuilder<'_, Self::Item, TS> {
        extern "C" fn factory<T: Identifyable<TS::Id>, TS: Strategy + 'static>(
            stage_1_data: AutoFreePointer,
            _ctx: &mut UntypedFnFactoryContext<TS>,
        ) -> InternalBuildResult<TS> {
            extern "C" fn func<T: Identifyable<TS::Id>, TS: Strategy + 'static>(
                _: *const ServiceProvider<TS>,
                stage_2_data: *const AutoFreePointer,
            ) -> T {
                let stage_2_data = unsafe { &*stage_2_data as &AutoFreePointer };
                let ptr = stage_2_data.get_pointer();
                let creator: fn() -> T = unsafe { core::mem::transmute(ptr) };
                creator()
            }
            FfiOk(UntypedFn::create(func::<T, TS>, stage_1_data))
        }

        let factory = UntypedFnFactory::no_alloc(self as AnyPtr, factory::<T, TS>);
        collection
            .producer_factories
            .push(ServiceProducer::<TS>::new::<T>(factory));

        AliasBuilder::new(collection)
    }
}

impl<TS: Strategy + 'static, T: Identifyable<TS::Id>, TDep: Resolvable<TS> + 'static> Registrar<TS>
    for fn(TDep) -> T
{
    type Item = T;

    fn register(
        self,
        collection: &mut GenericServiceCollection<TS>,
    ) -> AliasBuilder<'_, Self::Item, TS> {
        type InnerContext<TDep, TS> = (<TDep as SealedResolvable<TS>>::PrecheckResult, AnyPtr);
        extern "C" fn factory<
            T: Identifyable<TS::Id>,
            TDep: Resolvable<TS> + 'static,
            TS: Strategy + 'static,
        >(
            outer_ctx: AutoFreePointer, // No-Alloc
            ctx: &mut UntypedFnFactoryContext<TS>,
        ) -> InternalBuildResult<TS> {
            let key = match TDep::precheck(ctx.final_ordered_types) {
                Ok(x) => x,
                Err(x) => return FfiErr(x.with_dependee::<T>()),
            };
            let data = TDep::iter_positions(ctx.final_ordered_types);
            ctx.cyclic_reference_candidates.insert(
                type_name::<TDep::ItemPreChecked>().into(),
                FfiUsizeIterator::from_iter(data),
            );
            extern "C" fn func<
                T: Identifyable<TS::Id>,
                TDep: Resolvable<TS> + 'static,
                TS: Strategy + 'static,
            >(
                provider: *const ServiceProvider<TS>,
                outer_ctx: *const AutoFreePointer,
            ) -> T {
                let provider = unsafe { &*provider as &ServiceProvider<TS> };
                let outer_ctx = unsafe { &*outer_ctx as &AutoFreePointer };
                let (key, c): &InnerContext<TDep, TS> =
                    unsafe { &*(outer_ctx.get_pointer() as *const InnerContext<TDep, TS>) };
                let creator: fn(TDep) -> T = unsafe { core::mem::transmute(*c) };
                let arg = TDep::resolve_prechecked_self(provider, key);
                creator(arg)
            }
            let inner: InnerContext<TDep, TS> = (key, outer_ctx.get_pointer());
            FfiOk(UntypedFn::create(
                func::<T, TDep, TS>,
                AutoFreePointer::boxed(inner),
            ))
        }
        let factory = UntypedFnFactory::no_alloc(self as AnyPtr, factory::<T, TDep, TS>);
        collection
            .producer_factories
            .push(ServiceProducer::<TS>::new::<T>(factory));

        AliasBuilder::new(collection)
    }
}