flams_ontology/content/
modules.rs

1use super::{
2    checking::ModuleChecker,
3    declarations::{Declaration, DeclarationTrait, OpenDeclaration},
4    ModuleLike, ModuleTrait,
5};
6use crate::{
7    languages::Language,
8    uris::{ContentURIRef, ModuleURI, SymbolURI},
9    Checked, CheckingState, MaybeResolved, Resolvable, Unchecked,
10};
11use triomphe::Arc;
12
13#[derive(Debug)]
14pub struct OpenModule<State: CheckingState> {
15    pub uri: ModuleURI,
16    pub meta: Option<State::Module>,
17    pub signature: Option<State::Sig>,
18    pub elements: State::Seq<OpenDeclaration<State>>,
19}
20crate::serde_impl! {mod serde_module =
21    struct OpenModule[uri,meta,signature,elements]
22}
23
24#[derive(Debug, Clone)]
25pub struct Signature(pub Module);
26impl Resolvable for Signature {
27    type From = Language;
28    fn id(&self) -> std::borrow::Cow<'_, Self::From> {
29        std::borrow::Cow::Owned(Language::default())
30    }
31}
32
33impl ModuleTrait for OpenModule<Checked> {
34    #[inline]
35    fn declarations(&self) -> &[Declaration] {
36        &self.elements
37    }
38    #[inline]
39    fn content_uri(&self) -> ContentURIRef {
40        ContentURIRef::Module(&self.uri)
41    }
42}
43
44#[derive(Debug, Clone)]
45pub struct Module(pub(super) Arc<OpenModule<Checked>>);
46impl Resolvable for Module {
47    type From = ModuleURI;
48    fn id(&self) -> std::borrow::Cow<'_, Self::From> {
49        std::borrow::Cow::Borrowed(&self.0.uri)
50    }
51}
52impl Module {
53    #[inline]
54    #[must_use]
55    pub fn strong_count(&self) -> usize {
56        Arc::strong_count(&self.0)
57    }
58
59    #[inline]
60    #[must_use]
61    pub fn uri(&self) -> &ModuleURI {
62        &self.0.uri
63    }
64
65    #[inline]
66    #[must_use]
67    pub fn meta(&self) -> Option<&MaybeResolved<Self>> {
68        self.0.meta.as_ref()
69    }
70
71    #[inline]
72    #[must_use]
73    pub fn signature(&self) -> Option<&MaybeResolved<Signature>> {
74        self.0.signature.as_ref()
75    }
76}
77
78impl ModuleTrait for Module {
79    #[inline]
80    fn declarations(&self) -> &[Declaration] {
81        &self.0.elements
82    }
83    #[inline]
84    fn content_uri(&self) -> ContentURIRef {
85        ContentURIRef::Module(self.uri())
86    }
87}
88
89#[cfg(feature = "serde")]
90mod serde_impl {
91    use crate::languages::Language;
92    impl serde::Serialize for super::Module {
93        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
94        where
95            S: serde::Serializer,
96        {
97            self.0.serialize(serializer)
98        }
99    }
100    impl serde::Serialize for super::Signature {
101        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
102        where
103            S: serde::Serializer,
104        {
105            Language::default().serialize(serializer)
106        }
107    }
108}
109
110#[derive(Debug)]
111pub struct NestedModule<State: CheckingState> {
112    pub uri: SymbolURI,
113    pub elements: State::Seq<OpenDeclaration<State>>,
114}
115impl super::declarations::private::Sealed for NestedModule<Checked> {}
116impl DeclarationTrait for NestedModule<Checked> {
117    #[inline]
118    fn from_declaration(decl: &Declaration) -> Option<&Self> {
119        match decl {
120            Declaration::NestedModule(m) => Some(m),
121            _ => None,
122        }
123    }
124}
125crate::serde_impl! {mod serde_nested_module =
126    struct NestedModule[uri,elements]
127}
128impl ModuleTrait for NestedModule<Checked> {
129    #[inline]
130    fn declarations(&self) -> &[Declaration] {
131        &self.elements
132    }
133
134    #[inline]
135    fn content_uri(&self) -> ContentURIRef {
136        ContentURIRef::Symbol(&self.uri)
137    }
138}
139
140impl OpenModule<Unchecked> {
141    pub fn check(self, checker: &mut impl ModuleChecker) -> Module {
142        let meta = self.meta.map(|uri| {
143            MaybeResolved::resolve(uri, |m| {
144                checker.get_module(m).and_then(|m| {
145                    if let ModuleLike::Module(m) = m {
146                        Some(m)
147                    } else {
148                        None
149                    }
150                })
151            })
152        });
153        /*
154        let signature = self.signature.map(|language| {
155            let uri = self.uri.clone() % language;
156            //println!("Require signature {uri}");
157            checker.get_module(&uri).map_or_else(
158                || MaybeResolved::unresolved(language),
159                |m| match m {
160                    ModuleLike::Module(m) => MaybeResolved::resolved(Signature(m)),
161                    _ => MaybeResolved::unresolved(language),
162                },
163            )
164        });
165         */
166        let elements = super::checking::ModuleCheckIter::go(self.elements, checker, &self.uri);
167        Module(Arc::new(OpenModule {
168            uri: self.uri,
169            meta,
170            signature: None,
171            elements: elements.into_boxed_slice(),
172        }))
173    }
174
175    /*
176    /// #### Errors
177    pub fn from_byte_stream(bytes: &mut impl BinaryReader) -> Result<Self, DecodeError> {
178        todo!()
179    }
180     */
181}
182
183/*
184impl<State:CheckingState> OpenModule<State> {
185    /// #### Errors
186    pub fn into_byte_stream(&self,bytes:&mut impl BinaryWriter) -> Result<(),std::io::Error> {
187        todo!()
188    }
189}
190 */
flams_ontology/content/modules.rs

flams_ontology/content/
modules.rs
