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

use crate::ast::Depunctuated;
use crate::composer::{SourceComposable, Linkable, ComposerLink, AccessorMethodComposer, DtorMethodComposer, ArgKindPair, OwnerAspectSequenceSpecComposer};
use crate::context::ScopeContext;
use crate::lang::Specification;
use crate::presentable::BindingPresentableContext;
use crate::shared::SharedAccess;

pub type FFIBindingsComposerLink<SPEC, T, Iter> = FFIBindingsComposer<SPEC, ComposerLink<T>, Iter>;
pub type MaybeFFIBindingsComposerLink<SPEC, T, Iter> = Option<FFIBindingsComposerLink<SPEC, T, Iter>>;
pub struct FFIBindingsComposer<SPEC, Link, Iter>
    where Link: SharedAccess,
          SPEC: Specification,
          Iter: FromIterator<Iter::Item> + IntoIterator<Item=ArgKindPair<SPEC>> {
    pub parent: Option<Link>,
    pub ctor: OwnerAspectSequenceSpecComposer<SPEC, Link, Iter, BindingPresentableContext<SPEC>>,
    pub dtor: DtorMethodComposer<SPEC, Link>,
    pub getter: AccessorMethodComposer<SPEC, Link>,
    pub setter: AccessorMethodComposer<SPEC, Link>,
    pub get_set: bool
}
impl<SPEC, Link, Iter> FFIBindingsComposer<SPEC, Link, Iter>
    where Link: SharedAccess,
          SPEC: Specification,
          Iter: FromIterator<Iter::Item> + IntoIterator<Item=ArgKindPair<SPEC>> {
    pub const fn new(
        ctor: OwnerAspectSequenceSpecComposer<SPEC, Link, Iter, BindingPresentableContext<SPEC>>,
        dtor: DtorMethodComposer<SPEC, Link>,
        getter: AccessorMethodComposer<SPEC, Link>,
        setter: AccessorMethodComposer<SPEC, Link>,
        get_set: bool,
    ) -> Self {
        Self { parent: None, ctor, dtor, getter, setter, get_set }
    }

    pub fn compose_ctor(&self) -> BindingPresentableContext<SPEC> {
        self.ctor.compose(&())
    }
}

impl<SPEC, Link, Iter> Linkable<Link> for FFIBindingsComposer<SPEC, Link, Iter>
    where SPEC: Specification,
          Link: SharedAccess,
          Iter: FromIterator<Iter::Item> + IntoIterator<Item=ArgKindPair<SPEC>> {
    fn link(&mut self, parent: &Link) {
        self.getter.link(parent);
        self.setter.link(parent);
        self.ctor.link(parent);
        self.dtor.link(parent);
        self.parent = Some(parent.clone_container());
    }
}

impl<SPEC, Link, Iter> SourceComposable for FFIBindingsComposer<SPEC, Link, Iter>
    where SPEC: Specification + 'static,
          Link: SharedAccess,
          Iter: FromIterator<Iter::Item> + IntoIterator<Item=ArgKindPair<SPEC>> {
    type Source = ScopeContext;
    type Output = Depunctuated<BindingPresentableContext<SPEC>>;

    fn compose(&self, source: &Self::Source) -> Self::Output {
        let mut bindings = Depunctuated::new();
        bindings.push(self.ctor.compose(&()));
        bindings.push(self.dtor.compose(source));
        if self.get_set {
            bindings.extend(self.getter.compose(source));
            bindings.extend(self.setter.compose(source));
        }
        bindings
    }
}