rustenium_cdp_definitions/browser_protocol/indexed_db/
command_builders.rs

1use super::commands::*;
2impl ClearObjectStore {
3    pub fn builder() -> ClearObjectStoreBuilder {
4        <ClearObjectStoreBuilder as Default>::default()
5    }
6}
7#[derive(Default, Clone)]
8pub struct ClearObjectStoreBuilder {
9    security_origin: Option<String>,
10    storage_key: Option<String>,
11    storage_bucket: Option<crate::browser_protocol::storage::types::StorageBucket>,
12    database_name: Option<String>,
13    object_store_name: Option<String>,
14}
15impl ClearObjectStoreBuilder {
16    pub fn security_origin(mut self, security_origin: impl Into<String>) -> Self {
17        self.security_origin = Some(security_origin.into());
18        self
19    }
20    pub fn storage_key(mut self, storage_key: impl Into<String>) -> Self {
21        self.storage_key = Some(storage_key.into());
22        self
23    }
24    pub fn storage_bucket(
25        mut self,
26        storage_bucket: impl Into<crate::browser_protocol::storage::types::StorageBucket>,
27    ) -> Self {
28        self.storage_bucket = Some(storage_bucket.into());
29        self
30    }
31    pub fn database_name(mut self, database_name: impl Into<String>) -> Self {
32        self.database_name = Some(database_name.into());
33        self
34    }
35    pub fn object_store_name(mut self, object_store_name: impl Into<String>) -> Self {
36        self.object_store_name = Some(object_store_name.into());
37        self
38    }
39    pub fn build(self) -> Result<ClearObjectStore, String> {
40        Ok(ClearObjectStore {
41            method: ClearObjectStoreMethod::ClearObjectStore,
42            params: ClearObjectStoreParams {
43                security_origin: self.security_origin,
44                storage_key: self.storage_key,
45                storage_bucket: self.storage_bucket,
46                database_name: self.database_name.ok_or_else(|| {
47                    format!("Field `{}` is mandatory.", std::stringify!(database_name))
48                })?,
49                object_store_name: self.object_store_name.ok_or_else(|| {
50                    format!(
51                        "Field `{}` is mandatory.",
52                        std::stringify!(object_store_name)
53                    )
54                })?,
55            },
56        })
57    }
58}
59impl DeleteDatabase {
60    pub fn builder() -> DeleteDatabaseBuilder {
61        <DeleteDatabaseBuilder as Default>::default()
62    }
63}
64#[derive(Default, Clone)]
65pub struct DeleteDatabaseBuilder {
66    security_origin: Option<String>,
67    storage_key: Option<String>,
68    storage_bucket: Option<crate::browser_protocol::storage::types::StorageBucket>,
69    database_name: Option<String>,
70}
71impl DeleteDatabaseBuilder {
72    pub fn security_origin(mut self, security_origin: impl Into<String>) -> Self {
73        self.security_origin = Some(security_origin.into());
74        self
75    }
76    pub fn storage_key(mut self, storage_key: impl Into<String>) -> Self {
77        self.storage_key = Some(storage_key.into());
78        self
79    }
80    pub fn storage_bucket(
81        mut self,
82        storage_bucket: impl Into<crate::browser_protocol::storage::types::StorageBucket>,
83    ) -> Self {
84        self.storage_bucket = Some(storage_bucket.into());
85        self
86    }
87    pub fn database_name(mut self, database_name: impl Into<String>) -> Self {
88        self.database_name = Some(database_name.into());
89        self
90    }
91    pub fn build(self) -> Result<DeleteDatabase, String> {
92        Ok(DeleteDatabase {
93            method: DeleteDatabaseMethod::DeleteDatabase,
94            params: DeleteDatabaseParams {
95                security_origin: self.security_origin,
96                storage_key: self.storage_key,
97                storage_bucket: self.storage_bucket,
98                database_name: self.database_name.ok_or_else(|| {
99                    format!("Field `{}` is mandatory.", std::stringify!(database_name))
100                })?,
101            },
102        })
103    }
104}
105impl DeleteObjectStoreEntries {
106    pub fn builder() -> DeleteObjectStoreEntriesBuilder {
107        <DeleteObjectStoreEntriesBuilder as Default>::default()
108    }
109}
110#[derive(Default, Clone)]
111pub struct DeleteObjectStoreEntriesBuilder {
112    security_origin: Option<String>,
113    storage_key: Option<String>,
114    storage_bucket: Option<crate::browser_protocol::storage::types::StorageBucket>,
115    database_name: Option<String>,
116    object_store_name: Option<String>,
117    key_range: Option<super::types::KeyRange>,
118}
119impl DeleteObjectStoreEntriesBuilder {
120    pub fn security_origin(mut self, security_origin: impl Into<String>) -> Self {
121        self.security_origin = Some(security_origin.into());
122        self
123    }
124    pub fn storage_key(mut self, storage_key: impl Into<String>) -> Self {
125        self.storage_key = Some(storage_key.into());
126        self
127    }
128    pub fn storage_bucket(
129        mut self,
130        storage_bucket: impl Into<crate::browser_protocol::storage::types::StorageBucket>,
131    ) -> Self {
132        self.storage_bucket = Some(storage_bucket.into());
133        self
134    }
135    pub fn database_name(mut self, database_name: impl Into<String>) -> Self {
136        self.database_name = Some(database_name.into());
137        self
138    }
139    pub fn object_store_name(mut self, object_store_name: impl Into<String>) -> Self {
140        self.object_store_name = Some(object_store_name.into());
141        self
142    }
143    pub fn key_range(mut self, key_range: impl Into<super::types::KeyRange>) -> Self {
144        self.key_range = Some(key_range.into());
145        self
146    }
147    pub fn build(self) -> Result<DeleteObjectStoreEntries, String> {
148        Ok(DeleteObjectStoreEntries {
149            method: DeleteObjectStoreEntriesMethod::DeleteObjectStoreEntries,
150            params: DeleteObjectStoreEntriesParams {
151                security_origin: self.security_origin,
152                storage_key: self.storage_key,
153                storage_bucket: self.storage_bucket,
154                database_name: self.database_name.ok_or_else(|| {
155                    format!("Field `{}` is mandatory.", std::stringify!(database_name))
156                })?,
157                object_store_name: self.object_store_name.ok_or_else(|| {
158                    format!(
159                        "Field `{}` is mandatory.",
160                        std::stringify!(object_store_name)
161                    )
162                })?,
163                key_range: self.key_range.ok_or_else(|| {
164                    format!("Field `{}` is mandatory.", std::stringify!(key_range))
165                })?,
166            },
167        })
168    }
169}
170#[derive(Debug, Clone, Default)]
171pub struct DisableBuilder;
172impl DisableBuilder {
173    pub fn new() -> Self {
174        Self
175    }
176    pub fn build(self) -> Disable {
177        Disable {
178            method: DisableMethod::Disable,
179            params: DisableParams {},
180        }
181    }
182}
183impl Disable {
184    pub fn builder() -> DisableBuilder {
185        DisableBuilder
186    }
187}
188#[derive(Debug, Clone, Default)]
189pub struct EnableBuilder;
190impl EnableBuilder {
191    pub fn new() -> Self {
192        Self
193    }
194    pub fn build(self) -> Enable {
195        Enable {
196            method: EnableMethod::Enable,
197            params: EnableParams {},
198        }
199    }
200}
201impl Enable {
202    pub fn builder() -> EnableBuilder {
203        EnableBuilder
204    }
205}
206impl RequestData {
207    pub fn builder() -> RequestDataBuilder {
208        <RequestDataBuilder as Default>::default()
209    }
210}
211#[derive(Default, Clone)]
212pub struct RequestDataBuilder {
213    security_origin: Option<String>,
214    storage_key: Option<String>,
215    storage_bucket: Option<crate::browser_protocol::storage::types::StorageBucket>,
216    database_name: Option<String>,
217    object_store_name: Option<String>,
218    index_name: Option<String>,
219    skip_count: Option<i64>,
220    page_size: Option<i64>,
221    key_range: Option<super::types::KeyRange>,
222}
223impl RequestDataBuilder {
224    pub fn security_origin(mut self, security_origin: impl Into<String>) -> Self {
225        self.security_origin = Some(security_origin.into());
226        self
227    }
228    pub fn storage_key(mut self, storage_key: impl Into<String>) -> Self {
229        self.storage_key = Some(storage_key.into());
230        self
231    }
232    pub fn storage_bucket(
233        mut self,
234        storage_bucket: impl Into<crate::browser_protocol::storage::types::StorageBucket>,
235    ) -> Self {
236        self.storage_bucket = Some(storage_bucket.into());
237        self
238    }
239    pub fn database_name(mut self, database_name: impl Into<String>) -> Self {
240        self.database_name = Some(database_name.into());
241        self
242    }
243    pub fn object_store_name(mut self, object_store_name: impl Into<String>) -> Self {
244        self.object_store_name = Some(object_store_name.into());
245        self
246    }
247    pub fn index_name(mut self, index_name: impl Into<String>) -> Self {
248        self.index_name = Some(index_name.into());
249        self
250    }
251    pub fn skip_count(mut self, skip_count: impl Into<i64>) -> Self {
252        self.skip_count = Some(skip_count.into());
253        self
254    }
255    pub fn page_size(mut self, page_size: impl Into<i64>) -> Self {
256        self.page_size = Some(page_size.into());
257        self
258    }
259    pub fn key_range(mut self, key_range: impl Into<super::types::KeyRange>) -> Self {
260        self.key_range = Some(key_range.into());
261        self
262    }
263    pub fn build(self) -> Result<RequestData, String> {
264        Ok(RequestData {
265            method: RequestDataMethod::RequestData,
266            params: RequestDataParams {
267                security_origin: self.security_origin,
268                storage_key: self.storage_key,
269                storage_bucket: self.storage_bucket,
270                database_name: self.database_name.ok_or_else(|| {
271                    format!("Field `{}` is mandatory.", std::stringify!(database_name))
272                })?,
273                object_store_name: self.object_store_name.ok_or_else(|| {
274                    format!(
275                        "Field `{}` is mandatory.",
276                        std::stringify!(object_store_name)
277                    )
278                })?,
279                index_name: self.index_name,
280                skip_count: self.skip_count.ok_or_else(|| {
281                    format!("Field `{}` is mandatory.", std::stringify!(skip_count))
282                })?,
283                page_size: self.page_size.ok_or_else(|| {
284                    format!("Field `{}` is mandatory.", std::stringify!(page_size))
285                })?,
286                key_range: self.key_range,
287            },
288        })
289    }
290}
291impl GetMetadata {
292    pub fn builder() -> GetMetadataBuilder {
293        <GetMetadataBuilder as Default>::default()
294    }
295}
296#[derive(Default, Clone)]
297pub struct GetMetadataBuilder {
298    security_origin: Option<String>,
299    storage_key: Option<String>,
300    storage_bucket: Option<crate::browser_protocol::storage::types::StorageBucket>,
301    database_name: Option<String>,
302    object_store_name: Option<String>,
303}
304impl GetMetadataBuilder {
305    pub fn security_origin(mut self, security_origin: impl Into<String>) -> Self {
306        self.security_origin = Some(security_origin.into());
307        self
308    }
309    pub fn storage_key(mut self, storage_key: impl Into<String>) -> Self {
310        self.storage_key = Some(storage_key.into());
311        self
312    }
313    pub fn storage_bucket(
314        mut self,
315        storage_bucket: impl Into<crate::browser_protocol::storage::types::StorageBucket>,
316    ) -> Self {
317        self.storage_bucket = Some(storage_bucket.into());
318        self
319    }
320    pub fn database_name(mut self, database_name: impl Into<String>) -> Self {
321        self.database_name = Some(database_name.into());
322        self
323    }
324    pub fn object_store_name(mut self, object_store_name: impl Into<String>) -> Self {
325        self.object_store_name = Some(object_store_name.into());
326        self
327    }
328    pub fn build(self) -> Result<GetMetadata, String> {
329        Ok(GetMetadata {
330            method: GetMetadataMethod::GetMetadata,
331            params: GetMetadataParams {
332                security_origin: self.security_origin,
333                storage_key: self.storage_key,
334                storage_bucket: self.storage_bucket,
335                database_name: self.database_name.ok_or_else(|| {
336                    format!("Field `{}` is mandatory.", std::stringify!(database_name))
337                })?,
338                object_store_name: self.object_store_name.ok_or_else(|| {
339                    format!(
340                        "Field `{}` is mandatory.",
341                        std::stringify!(object_store_name)
342                    )
343                })?,
344            },
345        })
346    }
347}
348impl RequestDatabase {
349    pub fn builder() -> RequestDatabaseBuilder {
350        <RequestDatabaseBuilder as Default>::default()
351    }
352}
353#[derive(Default, Clone)]
354pub struct RequestDatabaseBuilder {
355    security_origin: Option<String>,
356    storage_key: Option<String>,
357    storage_bucket: Option<crate::browser_protocol::storage::types::StorageBucket>,
358    database_name: Option<String>,
359}
360impl RequestDatabaseBuilder {
361    pub fn security_origin(mut self, security_origin: impl Into<String>) -> Self {
362        self.security_origin = Some(security_origin.into());
363        self
364    }
365    pub fn storage_key(mut self, storage_key: impl Into<String>) -> Self {
366        self.storage_key = Some(storage_key.into());
367        self
368    }
369    pub fn storage_bucket(
370        mut self,
371        storage_bucket: impl Into<crate::browser_protocol::storage::types::StorageBucket>,
372    ) -> Self {
373        self.storage_bucket = Some(storage_bucket.into());
374        self
375    }
376    pub fn database_name(mut self, database_name: impl Into<String>) -> Self {
377        self.database_name = Some(database_name.into());
378        self
379    }
380    pub fn build(self) -> Result<RequestDatabase, String> {
381        Ok(RequestDatabase {
382            method: RequestDatabaseMethod::RequestDatabase,
383            params: RequestDatabaseParams {
384                security_origin: self.security_origin,
385                storage_key: self.storage_key,
386                storage_bucket: self.storage_bucket,
387                database_name: self.database_name.ok_or_else(|| {
388                    format!("Field `{}` is mandatory.", std::stringify!(database_name))
389                })?,
390            },
391        })
392    }
393}
394impl RequestDatabaseNames {
395    pub fn builder() -> RequestDatabaseNamesBuilder {
396        <RequestDatabaseNamesBuilder as Default>::default()
397    }
398}
399#[derive(Default, Clone)]
400pub struct RequestDatabaseNamesBuilder {
401    security_origin: Option<String>,
402    storage_key: Option<String>,
403    storage_bucket: Option<crate::browser_protocol::storage::types::StorageBucket>,
404}
405impl RequestDatabaseNamesBuilder {
406    pub fn security_origin(mut self, security_origin: impl Into<String>) -> Self {
407        self.security_origin = Some(security_origin.into());
408        self
409    }
410    pub fn storage_key(mut self, storage_key: impl Into<String>) -> Self {
411        self.storage_key = Some(storage_key.into());
412        self
413    }
414    pub fn storage_bucket(
415        mut self,
416        storage_bucket: impl Into<crate::browser_protocol::storage::types::StorageBucket>,
417    ) -> Self {
418        self.storage_bucket = Some(storage_bucket.into());
419        self
420    }
421    pub fn build(self) -> RequestDatabaseNames {
422        RequestDatabaseNames {
423            method: RequestDatabaseNamesMethod::RequestDatabaseNames,
424            params: RequestDatabaseNamesParams {
425                security_origin: self.security_origin,
426                storage_key: self.storage_key,
427                storage_bucket: self.storage_bucket,
428            },
429        }
430    }
431}
rustenium_cdp_definitions/browser_protocol/indexed_db/command_builders.rs

rustenium_cdp_definitions/browser_protocol/indexed_db/
command_builders.rs
