teo_runtime/interface/
builder.rs

1use std::collections::BTreeMap;
2use std::sync::{Arc, Mutex};
3use std::sync::atomic::AtomicBool;
4use indexmap::{IndexMap};
5use maplit::btreemap;
6use teo_parser::r#type::synthesized_shape::SynthesizedShape;
7use teo_parser::r#type::Type;
8use crate::comment::Comment;
9use crate::interface::{Field, Interface, interface};
10use crate::Value;
11
12#[derive(Debug, Clone)]
13pub struct Builder {
14    inner: Arc<Inner>,
15}
16
17#[derive(Debug)]
18struct Inner {
19    path: Vec<String>,
20    parser_path: Vec<usize>,
21    comment: Option<Comment>,
22    fields: IndexMap<String, Field>,
23    generic_names: Vec<String>,
24    extends: Vec<Type>,
25    shape: SynthesizedShape,
26    generate_client: AtomicBool,
27    generate_entity: AtomicBool,
28    data: Arc<Mutex<BTreeMap<String, Value>>>
29}
30
31impl Builder {
32    pub fn new(path: Vec<String>, parser_path: Vec<usize>, comment: Option<Comment>, fields: IndexMap<String, Field>, generic_names: Vec<String>, extends: Vec<Type>, shape: SynthesizedShape) -> Self {
33        Self {
34            inner: Arc::new(Inner {
35                path,
36                parser_path,
37                comment,
38                fields,
39                generic_names,
40                extends,
41                shape,
42                generate_client: AtomicBool::new(true),
43                generate_entity: AtomicBool::new(true),
44                data: Arc::new(Mutex::new(btreemap! {})),
45            })
46        }
47    }
48
49    pub fn path(&self) -> &Vec<String> {
50        &self.inner.path
51    }
52
53    pub fn parser_path(&self) -> &Vec<usize> {
54        &self.inner.parser_path
55    }
56
57    pub fn comment(&self) -> Option<&Comment> {
58        self.inner.comment.as_ref()
59    }
60
61    pub fn fields(&self) -> &IndexMap<String, Field> {
62        &self.inner.fields
63    }
64
65    pub fn generic_names(&self) -> &Vec<String> {
66        &self.inner.generic_names
67    }
68
69    pub fn extends(&self) -> &Vec<Type> {
70        &self.inner.extends
71    }
72
73    pub fn shape(&self) -> &SynthesizedShape {
74        &self.inner.shape
75    }
76
77    pub fn generate_client(&self) -> bool {
78        self.inner.generate_client.load(std::sync::atomic::Ordering::Relaxed)
79    }
80
81    pub fn set_generate_client(&self, generate_client: bool) {
82        self.inner.generate_client.store(generate_client, std::sync::atomic::Ordering::Relaxed);
83    }
84
85    pub fn generate_entity(&self) -> bool {
86        self.inner.generate_entity.load(std::sync::atomic::Ordering::Relaxed)
87    }
88
89    pub fn set_generate_entity(&self, generate_entity: bool) {
90        self.inner.generate_entity.store(generate_entity, std::sync::atomic::Ordering::Relaxed);
91    }
92
93    pub fn data(&self) -> BTreeMap<String, Value> {
94        self.inner.data.lock().unwrap().clone()
95    }
96
97    pub fn set_data(&self, data: BTreeMap<String, Value>) {
98        *self.inner.data.lock().unwrap() = data;
99    }
100
101    pub fn insert_data_entry(&self, key: String, value: Value) {
102        self.inner.data.lock().unwrap().insert(key, value);
103    }
104
105    pub fn remove_data_entry(&self, key: &str) {
106        self.inner.data.lock().unwrap().remove(key);
107    }
108
109    pub fn data_entry(&self, key: &str) -> Option<Value> {
110        self.inner.data.lock().unwrap().get(key).cloned()
111    }
112
113    pub(crate) fn build(self) -> Interface {
114        Interface {
115            inner: Arc::new(interface::Inner {
116                path: self.inner.path.clone(),
117                parser_path: self.inner.parser_path.clone(),
118                comment: self.inner.comment.clone(),
119                fields: self.inner.fields.clone(),
120                generic_names: self.inner.generic_names.clone(),
121                extends: self.inner.extends.clone(),
122                shape: self.inner.shape.clone(),
123                generate_client: self.inner.generate_client.load(std::sync::atomic::Ordering::Relaxed),
124                generate_entity: self.inner.generate_entity.load(std::sync::atomic::Ordering::Relaxed),
125                data: self.inner.data.lock().unwrap().clone(),
126            })
127        }
128    }
129}