cyfs_lib/rmeta/
stub.rs

1use super::def::*;
2use super::output_request::*;
3use super::processor::*;
4use super::request::*;
5use cyfs_base::*;
6
7pub struct GlobalStateMetaStub {
8    target: Option<ObjectId>,
9    target_dec_id: Option<ObjectId>,
10    processor: GlobalStateMetaOutputProcessorRef,
11}
12
13impl GlobalStateMetaStub {
14    pub fn new(
15        processor: GlobalStateMetaOutputProcessorRef,
16        target: Option<ObjectId>,
17        target_dec_id: Option<ObjectId>,
18    ) -> Self {
19        Self {
20            processor,
21            target,
22            target_dec_id,
23        }
24    }
25
26    // path access
27    pub async fn add_access(&self, item: GlobalStatePathAccessItem) -> BuckyResult<bool> {
28        let req = GlobalStateMetaAddAccessRequest {
29            common: MetaOutputRequestCommon {
30                dec_id: None,
31                target_dec_id: self.target_dec_id.clone(),
32                target: self.target.clone(),
33                flags: 0,
34            },
35            item,
36        };
37
38        let resp = self.processor.add_access(req).await?;
39        Ok(resp.updated)
40    }
41
42    pub async fn remove_access(
43        &self,
44        item: GlobalStatePathAccessItem,
45    ) -> BuckyResult<Option<GlobalStatePathAccessItem>> {
46        let req = GlobalStateMetaRemoveAccessRequest {
47            common: MetaOutputRequestCommon {
48                dec_id: None,
49                target_dec_id: self.target_dec_id.clone(),
50                target: self.target.clone(),
51                flags: 0,
52            },
53            item,
54        };
55
56        let resp = self.processor.remove_access(req).await?;
57        Ok(resp.item)
58    }
59
60    pub async fn clear_access(&self) -> BuckyResult<u32> {
61        let req = GlobalStateMetaClearAccessRequest {
62            common: MetaOutputRequestCommon {
63                dec_id: None,
64                target_dec_id: self.target_dec_id.clone(),
65                target: self.target.clone(),
66                flags: 0,
67            },
68        };
69
70        let resp = self.processor.clear_access(req).await?;
71        Ok(resp.count)
72    }
73
74    // path link
75    pub async fn add_link(
76        &self,
77        source: impl Into<String>,
78        target: impl Into<String>,
79    ) -> BuckyResult<bool> {
80        let req = GlobalStateMetaAddLinkRequest {
81            common: MetaOutputRequestCommon {
82                dec_id: None,
83                target_dec_id: self.target_dec_id.clone(),
84                target: self.target.clone(),
85                flags: 0,
86            },
87            source: source.into(),
88            target: target.into(),
89        };
90
91        let resp = self.processor.add_link(req).await?;
92        Ok(resp.updated)
93    }
94
95    pub async fn remove_link(
96        &self,
97        source: impl Into<String>,
98    ) -> BuckyResult<Option<GlobalStatePathLinkItem>> {
99        let req = GlobalStateMetaRemoveLinkRequest {
100            common: MetaOutputRequestCommon {
101                dec_id: None,
102                target_dec_id: self.target_dec_id.clone(),
103                target: self.target.clone(),
104                flags: 0,
105            },
106            source: source.into(),
107        };
108
109        let resp = self.processor.remove_link(req).await?;
110        Ok(resp.item)
111    }
112
113    pub async fn clear_link(&self) -> BuckyResult<u32> {
114        let req = GlobalStateMetaClearLinkRequest {
115            common: MetaOutputRequestCommon {
116                dec_id: None,
117                target_dec_id: self.target_dec_id.clone(),
118                target: self.target.clone(),
119                flags: 0,
120            },
121        };
122
123        let resp = self.processor.clear_link(req).await?;
124        Ok(resp.count)
125    }
126
127    // object meta
128    pub async fn add_object_meta(&self, item: GlobalStateObjectMetaItem) -> BuckyResult<bool> {
129        let req = GlobalStateMetaAddObjectMetaRequest {
130            common: MetaOutputRequestCommon {
131                dec_id: None,
132                target_dec_id: self.target_dec_id.clone(),
133                target: self.target.clone(),
134                flags: 0,
135            },
136            item,
137        };
138
139        let resp = self.processor.add_object_meta(req).await?;
140        Ok(resp.updated)
141    }
142
143    pub async fn remove_object_meta(
144        &self,
145        item: GlobalStateObjectMetaItem,
146    ) -> BuckyResult<Option<GlobalStateObjectMetaItem>> {
147        let req = GlobalStateMetaRemoveObjectMetaRequest {
148            common: MetaOutputRequestCommon {
149                dec_id: None,
150                target_dec_id: self.target_dec_id.clone(),
151                target: self.target.clone(),
152                flags: 0,
153            },
154            item,
155        };
156
157        let resp = self.processor.remove_object_meta(req).await?;
158        Ok(resp.item)
159    }
160
161    pub async fn clear_object_meta(&self) -> BuckyResult<u32> {
162        let req = GlobalStateMetaClearObjectMetaRequest {
163            common: MetaOutputRequestCommon {
164                dec_id: None,
165                target_dec_id: self.target_dec_id.clone(),
166                target: self.target.clone(),
167                flags: 0,
168            },
169        };
170
171        let resp = self.processor.clear_object_meta(req).await?;
172        Ok(resp.count)
173    }
174
175    // path config
176    pub async fn add_path_config(&self, item: GlobalStatePathConfigItem) -> BuckyResult<bool> {
177        let req = GlobalStateMetaAddPathConfigRequest {
178            common: MetaOutputRequestCommon {
179                dec_id: None,
180                target_dec_id: self.target_dec_id.clone(),
181                target: self.target.clone(),
182                flags: 0,
183            },
184            item,
185        };
186
187        let resp = self.processor.add_path_config(req).await?;
188        Ok(resp.updated)
189    }
190
191    pub async fn remove_path_config(
192        &self,
193        item: GlobalStatePathConfigItem,
194    ) -> BuckyResult<Option<GlobalStatePathConfigItem>> {
195        let req = GlobalStateMetaRemovePathConfigRequest {
196            common: MetaOutputRequestCommon {
197                dec_id: None,
198                target_dec_id: self.target_dec_id.clone(),
199                target: self.target.clone(),
200                flags: 0,
201            },
202            item,
203        };
204
205        let resp = self.processor.remove_path_config(req).await?;
206        Ok(resp.item)
207    }
208
209    pub async fn clear_path_config(&self) -> BuckyResult<u32> {
210        let req = GlobalStateMetaClearPathConfigRequest {
211            common: MetaOutputRequestCommon {
212                dec_id: None,
213                target_dec_id: self.target_dec_id.clone(),
214                target: self.target.clone(),
215                flags: 0,
216            },
217        };
218
219        let resp = self.processor.clear_path_config(req).await?;
220        Ok(resp.count)
221    }
222}
cyfs_lib/rmeta/stub.rs

cyfs_lib/rmeta/
stub.rs
