rustenium_cdp_definitions/browser_protocol/bluetooth_emulation/
command_builders.rs

1use super::commands::*;
2impl Enable {
3    pub fn builder() -> EnableBuilder {
4        <EnableBuilder as Default>::default()
5    }
6}
7#[derive(Default, Clone)]
8pub struct EnableBuilder {
9    state: Option<super::types::CentralState>,
10    le_supported: Option<bool>,
11}
12impl EnableBuilder {
13    pub fn state(mut self, state: impl Into<super::types::CentralState>) -> Self {
14        self.state = Some(state.into());
15        self
16    }
17    pub fn le_supported(mut self, le_supported: impl Into<bool>) -> Self {
18        self.le_supported = Some(le_supported.into());
19        self
20    }
21    pub fn build(self) -> Result<Enable, String> {
22        Ok(Enable {
23            method: EnableMethod::Enable,
24            params: EnableParams {
25                state: self
26                    .state
27                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(state)))?,
28                le_supported: self.le_supported.ok_or_else(|| {
29                    format!("Field `{}` is mandatory.", std::stringify!(le_supported))
30                })?,
31            },
32        })
33    }
34}
35impl SetSimulatedCentralState {
36    pub fn builder() -> SetSimulatedCentralStateBuilder {
37        <SetSimulatedCentralStateBuilder as Default>::default()
38    }
39}
40#[derive(Default, Clone)]
41pub struct SetSimulatedCentralStateBuilder {
42    state: Option<super::types::CentralState>,
43}
44impl SetSimulatedCentralStateBuilder {
45    pub fn state(mut self, state: impl Into<super::types::CentralState>) -> Self {
46        self.state = Some(state.into());
47        self
48    }
49    pub fn build(self) -> Result<SetSimulatedCentralState, String> {
50        Ok(SetSimulatedCentralState {
51            method: SetSimulatedCentralStateMethod::SetSimulatedCentralState,
52            params: SetSimulatedCentralStateParams {
53                state: self
54                    .state
55                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(state)))?,
56            },
57        })
58    }
59}
60#[derive(Debug, Clone, Default)]
61pub struct DisableBuilder;
62impl DisableBuilder {
63    pub fn new() -> Self {
64        Self
65    }
66    pub fn build(self) -> Disable {
67        Disable {
68            method: DisableMethod::Disable,
69            params: DisableParams {},
70        }
71    }
72}
73impl Disable {
74    pub fn builder() -> DisableBuilder {
75        DisableBuilder
76    }
77}
78impl SimulatePreconnectedPeripheral {
79    pub fn builder() -> SimulatePreconnectedPeripheralBuilder {
80        <SimulatePreconnectedPeripheralBuilder as Default>::default()
81    }
82}
83#[derive(Default, Clone)]
84pub struct SimulatePreconnectedPeripheralBuilder {
85    address: Option<String>,
86    name: Option<String>,
87    manufacturer_data: Option<Vec<super::types::ManufacturerData>>,
88    known_service_uuids: Option<Vec<String>>,
89}
90impl SimulatePreconnectedPeripheralBuilder {
91    pub fn address(mut self, address: impl Into<String>) -> Self {
92        self.address = Some(address.into());
93        self
94    }
95    pub fn name(mut self, name: impl Into<String>) -> Self {
96        self.name = Some(name.into());
97        self
98    }
99    pub fn manufacturer_data(
100        mut self,
101        manufacturer_data: impl Into<super::types::ManufacturerData>,
102    ) -> Self {
103        let v = self.manufacturer_data.get_or_insert(Vec::new());
104        v.push(manufacturer_data.into());
105        self
106    }
107    pub fn manufacturer_datas<I, S>(mut self, manufacturer_datas: I) -> Self
108    where
109        I: IntoIterator<Item = S>,
110        S: Into<super::types::ManufacturerData>,
111    {
112        let v = self.manufacturer_data.get_or_insert(Vec::new());
113        for val in manufacturer_datas {
114            v.push(val.into());
115        }
116        self
117    }
118    pub fn known_service_uuid(mut self, known_service_uuid: impl Into<String>) -> Self {
119        let v = self.known_service_uuids.get_or_insert(Vec::new());
120        v.push(known_service_uuid.into());
121        self
122    }
123    pub fn known_service_uuids<I, S>(mut self, known_service_uuids: I) -> Self
124    where
125        I: IntoIterator<Item = S>,
126        S: Into<String>,
127    {
128        let v = self.known_service_uuids.get_or_insert(Vec::new());
129        for val in known_service_uuids {
130            v.push(val.into());
131        }
132        self
133    }
134    pub fn build(self) -> Result<SimulatePreconnectedPeripheral, String> {
135        Ok(SimulatePreconnectedPeripheral {
136            method: SimulatePreconnectedPeripheralMethod::SimulatePreconnectedPeripheral,
137            params: SimulatePreconnectedPeripheralParams {
138                address: self
139                    .address
140                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(address)))?,
141                name: self
142                    .name
143                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(name)))?,
144                manufacturer_data: self.manufacturer_data.ok_or_else(|| {
145                    format!(
146                        "Field `{}` is mandatory.",
147                        std::stringify!(manufacturer_data)
148                    )
149                })?,
150                known_service_uuids: self.known_service_uuids.ok_or_else(|| {
151                    format!(
152                        "Field `{}` is mandatory.",
153                        std::stringify!(known_service_uuids)
154                    )
155                })?,
156            },
157        })
158    }
159}
160impl SimulateAdvertisement {
161    pub fn builder() -> SimulateAdvertisementBuilder {
162        <SimulateAdvertisementBuilder as Default>::default()
163    }
164}
165#[derive(Default, Clone)]
166pub struct SimulateAdvertisementBuilder {
167    entry: Option<super::types::ScanEntry>,
168}
169impl SimulateAdvertisementBuilder {
170    pub fn entry(mut self, entry: impl Into<super::types::ScanEntry>) -> Self {
171        self.entry = Some(entry.into());
172        self
173    }
174    pub fn build(self) -> Result<SimulateAdvertisement, String> {
175        Ok(SimulateAdvertisement {
176            method: SimulateAdvertisementMethod::SimulateAdvertisement,
177            params: SimulateAdvertisementParams {
178                entry: self
179                    .entry
180                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(entry)))?,
181            },
182        })
183    }
184}
185impl SimulateGattOperationResponse {
186    pub fn builder() -> SimulateGattOperationResponseBuilder {
187        <SimulateGattOperationResponseBuilder as Default>::default()
188    }
189}
190#[derive(Default, Clone)]
191pub struct SimulateGattOperationResponseBuilder {
192    address: Option<String>,
193    r#type: Option<super::types::GattOperationType>,
194    code: Option<i64>,
195}
196impl SimulateGattOperationResponseBuilder {
197    pub fn address(mut self, address: impl Into<String>) -> Self {
198        self.address = Some(address.into());
199        self
200    }
201    pub fn r#type(mut self, r#type: impl Into<super::types::GattOperationType>) -> Self {
202        self.r#type = Some(r#type.into());
203        self
204    }
205    pub fn code(mut self, code: impl Into<i64>) -> Self {
206        self.code = Some(code.into());
207        self
208    }
209    pub fn build(self) -> Result<SimulateGattOperationResponse, String> {
210        Ok(SimulateGattOperationResponse {
211            method: SimulateGattOperationResponseMethod::SimulateGattOperationResponse,
212            params: SimulateGattOperationResponseParams {
213                address: self
214                    .address
215                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(address)))?,
216                r#type: self
217                    .r#type
218                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(r#type)))?,
219                code: self
220                    .code
221                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(code)))?,
222            },
223        })
224    }
225}
226impl SimulateCharacteristicOperationResponse {
227    pub fn builder() -> SimulateCharacteristicOperationResponseBuilder {
228        <SimulateCharacteristicOperationResponseBuilder as Default>::default()
229    }
230}
231#[derive(Default, Clone)]
232pub struct SimulateCharacteristicOperationResponseBuilder {
233    characteristic_id: Option<String>,
234    r#type: Option<super::types::CharacteristicOperationType>,
235    code: Option<i64>,
236    data: Option<crate::Binary>,
237}
238impl SimulateCharacteristicOperationResponseBuilder {
239    pub fn characteristic_id(mut self, characteristic_id: impl Into<String>) -> Self {
240        self.characteristic_id = Some(characteristic_id.into());
241        self
242    }
243    pub fn r#type(mut self, r#type: impl Into<super::types::CharacteristicOperationType>) -> Self {
244        self.r#type = Some(r#type.into());
245        self
246    }
247    pub fn code(mut self, code: impl Into<i64>) -> Self {
248        self.code = Some(code.into());
249        self
250    }
251    pub fn data(mut self, data: impl Into<crate::Binary>) -> Self {
252        self.data = Some(data.into());
253        self
254    }
255    pub fn build(self) -> Result<SimulateCharacteristicOperationResponse, String> {
256        Ok (SimulateCharacteristicOperationResponse { method : SimulateCharacteristicOperationResponseMethod :: SimulateCharacteristicOperationResponse , params : SimulateCharacteristicOperationResponseParams { characteristic_id : self . characteristic_id . ok_or_else (|| format ! ("Field `{}` is mandatory." , std :: stringify ! (characteristic_id))) ? , r#type : self . r#type . ok_or_else (|| format ! ("Field `{}` is mandatory." , std :: stringify ! (r#type))) ? , code : self . code . ok_or_else (|| format ! ("Field `{}` is mandatory." , std :: stringify ! (code))) ? , data : self . data , } , })
257    }
258}
259impl SimulateDescriptorOperationResponse {
260    pub fn builder() -> SimulateDescriptorOperationResponseBuilder {
261        <SimulateDescriptorOperationResponseBuilder as Default>::default()
262    }
263}
264#[derive(Default, Clone)]
265pub struct SimulateDescriptorOperationResponseBuilder {
266    descriptor_id: Option<String>,
267    r#type: Option<super::types::DescriptorOperationType>,
268    code: Option<i64>,
269    data: Option<crate::Binary>,
270}
271impl SimulateDescriptorOperationResponseBuilder {
272    pub fn descriptor_id(mut self, descriptor_id: impl Into<String>) -> Self {
273        self.descriptor_id = Some(descriptor_id.into());
274        self
275    }
276    pub fn r#type(mut self, r#type: impl Into<super::types::DescriptorOperationType>) -> Self {
277        self.r#type = Some(r#type.into());
278        self
279    }
280    pub fn code(mut self, code: impl Into<i64>) -> Self {
281        self.code = Some(code.into());
282        self
283    }
284    pub fn data(mut self, data: impl Into<crate::Binary>) -> Self {
285        self.data = Some(data.into());
286        self
287    }
288    pub fn build(self) -> Result<SimulateDescriptorOperationResponse, String> {
289        Ok(SimulateDescriptorOperationResponse {
290            method: SimulateDescriptorOperationResponseMethod::SimulateDescriptorOperationResponse,
291            params: SimulateDescriptorOperationResponseParams {
292                descriptor_id: self.descriptor_id.ok_or_else(|| {
293                    format!("Field `{}` is mandatory.", std::stringify!(descriptor_id))
294                })?,
295                r#type: self
296                    .r#type
297                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(r#type)))?,
298                code: self
299                    .code
300                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(code)))?,
301                data: self.data,
302            },
303        })
304    }
305}
306impl AddService {
307    pub fn builder() -> AddServiceBuilder {
308        <AddServiceBuilder as Default>::default()
309    }
310}
311#[derive(Default, Clone)]
312pub struct AddServiceBuilder {
313    address: Option<String>,
314    service_uuid: Option<String>,
315}
316impl AddServiceBuilder {
317    pub fn address(mut self, address: impl Into<String>) -> Self {
318        self.address = Some(address.into());
319        self
320    }
321    pub fn service_uuid(mut self, service_uuid: impl Into<String>) -> Self {
322        self.service_uuid = Some(service_uuid.into());
323        self
324    }
325    pub fn build(self) -> Result<AddService, String> {
326        Ok(AddService {
327            method: AddServiceMethod::AddService,
328            params: AddServiceParams {
329                address: self
330                    .address
331                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(address)))?,
332                service_uuid: self.service_uuid.ok_or_else(|| {
333                    format!("Field `{}` is mandatory.", std::stringify!(service_uuid))
334                })?,
335            },
336        })
337    }
338}
339impl RemoveService {
340    pub fn builder() -> RemoveServiceBuilder {
341        <RemoveServiceBuilder as Default>::default()
342    }
343}
344#[derive(Default, Clone)]
345pub struct RemoveServiceBuilder {
346    service_id: Option<String>,
347}
348impl RemoveServiceBuilder {
349    pub fn service_id(mut self, service_id: impl Into<String>) -> Self {
350        self.service_id = Some(service_id.into());
351        self
352    }
353    pub fn build(self) -> Result<RemoveService, String> {
354        Ok(RemoveService {
355            method: RemoveServiceMethod::RemoveService,
356            params: RemoveServiceParams {
357                service_id: self.service_id.ok_or_else(|| {
358                    format!("Field `{}` is mandatory.", std::stringify!(service_id))
359                })?,
360            },
361        })
362    }
363}
364impl AddCharacteristic {
365    pub fn builder() -> AddCharacteristicBuilder {
366        <AddCharacteristicBuilder as Default>::default()
367    }
368}
369#[derive(Default, Clone)]
370pub struct AddCharacteristicBuilder {
371    service_id: Option<String>,
372    characteristic_uuid: Option<String>,
373    properties: Option<super::types::CharacteristicProperties>,
374}
375impl AddCharacteristicBuilder {
376    pub fn service_id(mut self, service_id: impl Into<String>) -> Self {
377        self.service_id = Some(service_id.into());
378        self
379    }
380    pub fn characteristic_uuid(mut self, characteristic_uuid: impl Into<String>) -> Self {
381        self.characteristic_uuid = Some(characteristic_uuid.into());
382        self
383    }
384    pub fn properties(
385        mut self,
386        properties: impl Into<super::types::CharacteristicProperties>,
387    ) -> Self {
388        self.properties = Some(properties.into());
389        self
390    }
391    pub fn build(self) -> Result<AddCharacteristic, String> {
392        Ok(AddCharacteristic {
393            method: AddCharacteristicMethod::AddCharacteristic,
394            params: AddCharacteristicParams {
395                service_id: self.service_id.ok_or_else(|| {
396                    format!("Field `{}` is mandatory.", std::stringify!(service_id))
397                })?,
398                characteristic_uuid: self.characteristic_uuid.ok_or_else(|| {
399                    format!(
400                        "Field `{}` is mandatory.",
401                        std::stringify!(characteristic_uuid)
402                    )
403                })?,
404                properties: self.properties.ok_or_else(|| {
405                    format!("Field `{}` is mandatory.", std::stringify!(properties))
406                })?,
407            },
408        })
409    }
410}
411impl RemoveCharacteristic {
412    pub fn builder() -> RemoveCharacteristicBuilder {
413        <RemoveCharacteristicBuilder as Default>::default()
414    }
415}
416#[derive(Default, Clone)]
417pub struct RemoveCharacteristicBuilder {
418    characteristic_id: Option<String>,
419}
420impl RemoveCharacteristicBuilder {
421    pub fn characteristic_id(mut self, characteristic_id: impl Into<String>) -> Self {
422        self.characteristic_id = Some(characteristic_id.into());
423        self
424    }
425    pub fn build(self) -> Result<RemoveCharacteristic, String> {
426        Ok(RemoveCharacteristic {
427            method: RemoveCharacteristicMethod::RemoveCharacteristic,
428            params: RemoveCharacteristicParams {
429                characteristic_id: self.characteristic_id.ok_or_else(|| {
430                    format!(
431                        "Field `{}` is mandatory.",
432                        std::stringify!(characteristic_id)
433                    )
434                })?,
435            },
436        })
437    }
438}
439impl AddDescriptor {
440    pub fn builder() -> AddDescriptorBuilder {
441        <AddDescriptorBuilder as Default>::default()
442    }
443}
444#[derive(Default, Clone)]
445pub struct AddDescriptorBuilder {
446    characteristic_id: Option<String>,
447    descriptor_uuid: Option<String>,
448}
449impl AddDescriptorBuilder {
450    pub fn characteristic_id(mut self, characteristic_id: impl Into<String>) -> Self {
451        self.characteristic_id = Some(characteristic_id.into());
452        self
453    }
454    pub fn descriptor_uuid(mut self, descriptor_uuid: impl Into<String>) -> Self {
455        self.descriptor_uuid = Some(descriptor_uuid.into());
456        self
457    }
458    pub fn build(self) -> Result<AddDescriptor, String> {
459        Ok(AddDescriptor {
460            method: AddDescriptorMethod::AddDescriptor,
461            params: AddDescriptorParams {
462                characteristic_id: self.characteristic_id.ok_or_else(|| {
463                    format!(
464                        "Field `{}` is mandatory.",
465                        std::stringify!(characteristic_id)
466                    )
467                })?,
468                descriptor_uuid: self.descriptor_uuid.ok_or_else(|| {
469                    format!("Field `{}` is mandatory.", std::stringify!(descriptor_uuid))
470                })?,
471            },
472        })
473    }
474}
475impl RemoveDescriptor {
476    pub fn builder() -> RemoveDescriptorBuilder {
477        <RemoveDescriptorBuilder as Default>::default()
478    }
479}
480#[derive(Default, Clone)]
481pub struct RemoveDescriptorBuilder {
482    descriptor_id: Option<String>,
483}
484impl RemoveDescriptorBuilder {
485    pub fn descriptor_id(mut self, descriptor_id: impl Into<String>) -> Self {
486        self.descriptor_id = Some(descriptor_id.into());
487        self
488    }
489    pub fn build(self) -> Result<RemoveDescriptor, String> {
490        Ok(RemoveDescriptor {
491            method: RemoveDescriptorMethod::RemoveDescriptor,
492            params: RemoveDescriptorParams {
493                descriptor_id: self.descriptor_id.ok_or_else(|| {
494                    format!("Field `{}` is mandatory.", std::stringify!(descriptor_id))
495                })?,
496            },
497        })
498    }
499}
500impl SimulateGattDisconnection {
501    pub fn builder() -> SimulateGattDisconnectionBuilder {
502        <SimulateGattDisconnectionBuilder as Default>::default()
503    }
504}
505#[derive(Default, Clone)]
506pub struct SimulateGattDisconnectionBuilder {
507    address: Option<String>,
508}
509impl SimulateGattDisconnectionBuilder {
510    pub fn address(mut self, address: impl Into<String>) -> Self {
511        self.address = Some(address.into());
512        self
513    }
514    pub fn build(self) -> Result<SimulateGattDisconnection, String> {
515        Ok(SimulateGattDisconnection {
516            method: SimulateGattDisconnectionMethod::SimulateGattDisconnection,
517            params: SimulateGattDisconnectionParams {
518                address: self
519                    .address
520                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(address)))?,
521            },
522        })
523    }
524}
rustenium_cdp_definitions/browser_protocol/bluetooth_emulation/command_builders.rs

rustenium_cdp_definitions/browser_protocol/bluetooth_emulation/
command_builders.rs
