ferment-sys 0.2.14

Syntax tree morphing of FFI-compatible stuff
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

use quote::ToTokens;
use crate::composer::{SourceComposable, Composer, ComposerByRef, IterativeComposer, Linkable, SharedComposer, SourceContextComposerByRef, FFIInterfaceMethodSpec, FieldSpec, ItemComposerSpec, SharedAspectArgComposer, FieldsOwnedSequenceComposer, InterfaceMethodSequenceComposer};
use crate::lang::Specification;
use crate::shared::SharedAccess;
//pub const fn mix<A, B, C, F1: Fn(A, B) -> C, F2: Fn(A, B) -> C>() -> F1 { |context, presenter: F1<A, C>| presenter(context) }

pub struct SequenceComposer<L, LC, SeqCtx, SeqMap, SeqOut, Out>
    where L: SharedAccess {
    parent: Option<L>,
    set_output: Composer<SeqOut, Out>,
    get_context: SharedComposer<L, LC>,
    iterator: IterativeComposer<LC, SeqCtx, SeqMap, SeqOut>,
}

impl<L, LC, SeqCtx, SeqMap, SeqOut, Out> SequenceComposer<L, LC, SeqCtx, SeqMap, SeqOut, Out>
    where L: SharedAccess {
    #[allow(unused)]
    pub const fn with_iterator_setup(
        set_output: Composer<SeqOut, Out>,
        get_context: SharedComposer<L, LC>,
        iterator_post_processor: SourceContextComposerByRef<LC, SeqCtx, SeqMap, SeqOut>,
        iterator_item: ComposerByRef<SeqCtx, SeqMap>,
    ) -> Self {
        Self {
            set_output,
            get_context,
            parent: None,
            iterator: IterativeComposer::new(
                iterator_post_processor,
                iterator_item
            )
        }
    }
    #[allow(unused)]
    pub const fn new(
        set_output: Composer<SeqOut, Out>,
        get_context: SharedComposer<L, LC>,
        iterator: IterativeComposer<LC, SeqCtx, SeqMap, SeqOut>,
    ) -> Self {
        Self { set_output, get_context, iterator, parent: None }
    }
}

impl<L, LC, SeqCtx, SeqMap, SeqOut, Out> Linkable<L> for SequenceComposer<L, LC, SeqCtx, SeqMap, SeqOut, Out>
    where L: SharedAccess {
    fn link(&mut self, parent: &L) {
        self.parent = Some(parent.clone_container());
    }
}

impl<L, LC, SeqCtx, SeqMap, SeqOut, Out> SourceComposable for SequenceComposer<L, LC, SeqCtx, SeqMap, SeqOut, Out>
    where L: SharedAccess {
    type Source = ();
    type Output = Out;
    fn compose(&self, _: &Self::Source) -> Self::Output {
        let source = self.parent
            .as_ref()
            .expect("no parent")
            .access(self.get_context);
        let sequence_composition = self.iterator.compose(&source);
        (self.set_output)(sequence_composition)
    }
}

// Particular Sequences
impl<SPEC, SEP, Link> InterfaceMethodSequenceComposer<SPEC, Link, SEP>
where SPEC: Specification,
      SEP: ToTokens + Default,
      Link: SharedAccess {
    #[allow(unused)]
    pub const fn interface_method_spec<C>(get_context: SharedAspectArgComposer<SPEC, Link>) -> Self
    where C: FFIInterfaceMethodSpec<SPEC, SEP> {
        Self::new(C::SEQ, get_context, C::ITER)
    }
}
impl<SPEC, Link> FieldsOwnedSequenceComposer<SPEC, Link>
where SPEC: Specification,
      Link: SharedAccess {
    pub const fn item_field_from_spec<C>(aspect: SharedAspectArgComposer<SPEC, Link>) -> Self
    where C: FieldSpec<SPEC> + ItemComposerSpec<SPEC> {
        Self::new(C::FROM_ROOT_PRESENTER, aspect, C::PRODUCIBLE_FIELDS)
    }
    pub const fn item_field_to_spec<C>(aspect: SharedAspectArgComposer<SPEC, Link>) -> Self
    where C: FieldSpec<SPEC> + ItemComposerSpec<SPEC> {
        Self::new(C::TO_ROOT_PRESENTER, aspect, C::PRODUCIBLE_FIELDS)
    }
}