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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

use crate::composable::{AttrsModel, GenModel, LifetimesModel};
use crate::composer::{AttrComposable, AttrsComposer, ComposerLink, DocComposer, DocsComposable, GenericsComposable, GenericsComposer, LifetimesComposer, Linkable, SourceAccessible, SourceComposable, TypeAspect, TypeComposer, LifetimesComposable};
use crate::context::ScopeContextLink;
use crate::lang::Specification;
use crate::presentation::DocPresentation;
use crate::shared::SharedAccess;

pub type BasicComposerLink<SPEC, T> = BasicComposer<SPEC, ComposerLink<T>>;
pub struct BasicComposer<SPEC, Link>
    where Link: SharedAccess,
          SPEC: Specification {
    pub context: ScopeContextLink,
    pub attr: AttrsComposer<SPEC, Link>,
    pub doc: DocComposer<SPEC, Link>,
    pub ty: TypeComposer<Link, SPEC::TYC>,
    pub generics: GenericsComposer<SPEC, Link>,
    pub lifetimes: LifetimesComposer<SPEC, Link>,
}
impl<SPEC, Link> BasicComposer<SPEC, Link>
    where Link: SharedAccess,
          SPEC: Specification {
    fn new(
        attr: AttrsComposer<SPEC, Link>,
        doc: DocComposer<SPEC, Link>,
        ty: TypeComposer<Link, SPEC::TYC>,
        generics: GenericsComposer<SPEC, Link>,
        lifetimes: LifetimesComposer<SPEC, Link>,
        context: ScopeContextLink
    ) -> Self {
        Self { context, attr, doc, ty, generics, lifetimes }
    }

    pub fn from(
        doc: DocComposer<SPEC, Link>,
        attrs: AttrsModel,
        ty_context: SPEC::TYC,
        generics: GenModel,
        lifetimes: LifetimesModel,
        context: ScopeContextLink
    ) -> Self {
        Self::new(
            AttrsComposer::new(attrs),
            doc,
            TypeComposer::new(ty_context),
            GenericsComposer::<SPEC, Link>::new(generics),
            LifetimesComposer::<SPEC, Link>::new(lifetimes),
            context
        )
    }
}

impl<SPEC, Link> Linkable<Link> for BasicComposer<SPEC, Link>
    where Link: SharedAccess,
          SPEC: Specification {
    fn link(&mut self, parent: &Link) {
        self.attr.link(parent);
        self.generics.link(parent);
        self.lifetimes.link(parent);
        self.ty.link(parent);
        self.doc.link(parent);
    }
}

impl<SPEC, Link> DocsComposable for BasicComposer<SPEC, Link>
    where Link: SharedAccess,
          SPEC: Specification {
    fn compose_docs(&self) -> DocPresentation {
        DocPresentation::Direct(self.doc.compose(self.context()))
    }
}

impl<SPEC, Link> AttrComposable<SPEC::Attr> for BasicComposer<SPEC, Link>
    where Link: SharedAccess,
          SPEC: Specification {
    fn compose_attributes(&self) -> SPEC::Attr {
        self.attr.compose(self.context())
    }
}

impl<SPEC, Link> GenericsComposable<SPEC::Gen> for BasicComposer<SPEC, Link>
    where Link: SharedAccess,
          SPEC: Specification {
    fn compose_generics(&self) -> SPEC::Gen {
        self.generics.compose(self.context())
    }
}
impl<SPEC, Link> LifetimesComposable<SPEC::Lt> for BasicComposer<SPEC, Link>
    where Link: SharedAccess,
          SPEC: Specification {
    fn compose_lifetimes(&self) -> SPEC::Lt {
        self.lifetimes.compose(self.context())
    }
}
impl<SPEC, Link> TypeAspect<SPEC::TYC> for BasicComposer<SPEC, Link>
    where Link: SharedAccess,
          SPEC: Specification {
    fn type_context_ref(&self) -> &SPEC::TYC {
        &self.ty.context
    }
}

impl<SPEC, Link> SourceAccessible for BasicComposer<SPEC, Link>
    where Link: SharedAccess,
          SPEC: Specification {
    fn context(&self) -> &ScopeContextLink {
        &self.context
    }
}