rustenium_cdp_definitions/browser_protocol/dom_debugger/
command_builders.rs

1use super::commands::*;
2impl GetEventListeners {
3    pub fn builder() -> GetEventListenersBuilder {
4        <GetEventListenersBuilder as Default>::default()
5    }
6}
7#[derive(Default, Clone)]
8pub struct GetEventListenersBuilder {
9    object_id: Option<crate::js_protocol::runtime::types::RemoteObjectId>,
10    depth: Option<i64>,
11    pierce: Option<bool>,
12}
13impl GetEventListenersBuilder {
14    pub fn object_id(
15        mut self,
16        object_id: impl Into<crate::js_protocol::runtime::types::RemoteObjectId>,
17    ) -> Self {
18        self.object_id = Some(object_id.into());
19        self
20    }
21    pub fn depth(mut self, depth: impl Into<i64>) -> Self {
22        self.depth = Some(depth.into());
23        self
24    }
25    pub fn pierce(mut self, pierce: impl Into<bool>) -> Self {
26        self.pierce = Some(pierce.into());
27        self
28    }
29    pub fn build(self) -> Result<GetEventListeners, String> {
30        Ok(GetEventListeners {
31            method: GetEventListenersMethod::GetEventListeners,
32            params: GetEventListenersParams {
33                object_id: self.object_id.ok_or_else(|| {
34                    format!("Field `{}` is mandatory.", std::stringify!(object_id))
35                })?,
36                depth: self.depth,
37                pierce: self.pierce,
38            },
39        })
40    }
41}
42impl RemoveDomBreakpoint {
43    pub fn builder() -> RemoveDomBreakpointBuilder {
44        <RemoveDomBreakpointBuilder as Default>::default()
45    }
46}
47#[derive(Default, Clone)]
48pub struct RemoveDomBreakpointBuilder {
49    node_id: Option<crate::browser_protocol::dom::types::NodeId>,
50    r#type: Option<super::types::DomBreakpointType>,
51}
52impl RemoveDomBreakpointBuilder {
53    pub fn node_id(
54        mut self,
55        node_id: impl Into<crate::browser_protocol::dom::types::NodeId>,
56    ) -> Self {
57        self.node_id = Some(node_id.into());
58        self
59    }
60    pub fn r#type(mut self, r#type: impl Into<super::types::DomBreakpointType>) -> Self {
61        self.r#type = Some(r#type.into());
62        self
63    }
64    pub fn build(self) -> Result<RemoveDomBreakpoint, String> {
65        Ok(RemoveDomBreakpoint {
66            method: RemoveDomBreakpointMethod::RemoveDomBreakpoint,
67            params: RemoveDomBreakpointParams {
68                node_id: self
69                    .node_id
70                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(node_id)))?,
71                r#type: self
72                    .r#type
73                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(r#type)))?,
74            },
75        })
76    }
77}
78impl RemoveEventListenerBreakpoint {
79    pub fn builder() -> RemoveEventListenerBreakpointBuilder {
80        <RemoveEventListenerBreakpointBuilder as Default>::default()
81    }
82}
83#[derive(Default, Clone)]
84pub struct RemoveEventListenerBreakpointBuilder {
85    event_name: Option<String>,
86    target_name: Option<String>,
87}
88impl RemoveEventListenerBreakpointBuilder {
89    pub fn event_name(mut self, event_name: impl Into<String>) -> Self {
90        self.event_name = Some(event_name.into());
91        self
92    }
93    pub fn target_name(mut self, target_name: impl Into<String>) -> Self {
94        self.target_name = Some(target_name.into());
95        self
96    }
97    pub fn build(self) -> Result<RemoveEventListenerBreakpoint, String> {
98        Ok(RemoveEventListenerBreakpoint {
99            method: RemoveEventListenerBreakpointMethod::RemoveEventListenerBreakpoint,
100            params: RemoveEventListenerBreakpointParams {
101                event_name: self.event_name.ok_or_else(|| {
102                    format!("Field `{}` is mandatory.", std::stringify!(event_name))
103                })?,
104                target_name: self.target_name,
105            },
106        })
107    }
108}
109impl RemoveXhrBreakpoint {
110    pub fn builder() -> RemoveXhrBreakpointBuilder {
111        <RemoveXhrBreakpointBuilder as Default>::default()
112    }
113}
114#[derive(Default, Clone)]
115pub struct RemoveXhrBreakpointBuilder {
116    url: Option<String>,
117}
118impl RemoveXhrBreakpointBuilder {
119    pub fn url(mut self, url: impl Into<String>) -> Self {
120        self.url = Some(url.into());
121        self
122    }
123    pub fn build(self) -> Result<RemoveXhrBreakpoint, String> {
124        Ok(RemoveXhrBreakpoint {
125            method: RemoveXhrBreakpointMethod::RemoveXhrBreakpoint,
126            params: RemoveXhrBreakpointParams {
127                url: self
128                    .url
129                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
130            },
131        })
132    }
133}
134impl SetBreakOnCspViolation {
135    pub fn builder() -> SetBreakOnCspViolationBuilder {
136        <SetBreakOnCspViolationBuilder as Default>::default()
137    }
138}
139#[derive(Default, Clone)]
140pub struct SetBreakOnCspViolationBuilder {
141    violation_types: Option<Vec<super::types::CspViolationType>>,
142}
143impl SetBreakOnCspViolationBuilder {
144    pub fn violation_type(
145        mut self,
146        violation_type: impl Into<super::types::CspViolationType>,
147    ) -> Self {
148        let v = self.violation_types.get_or_insert(Vec::new());
149        v.push(violation_type.into());
150        self
151    }
152    pub fn violation_types<I, S>(mut self, violation_types: I) -> Self
153    where
154        I: IntoIterator<Item = S>,
155        S: Into<super::types::CspViolationType>,
156    {
157        let v = self.violation_types.get_or_insert(Vec::new());
158        for val in violation_types {
159            v.push(val.into());
160        }
161        self
162    }
163    pub fn build(self) -> Result<SetBreakOnCspViolation, String> {
164        Ok(SetBreakOnCspViolation {
165            method: SetBreakOnCspViolationMethod::SetBreakOnCspViolation,
166            params: SetBreakOnCspViolationParams {
167                violation_types: self.violation_types.ok_or_else(|| {
168                    format!("Field `{}` is mandatory.", std::stringify!(violation_types))
169                })?,
170            },
171        })
172    }
173}
174impl SetDomBreakpoint {
175    pub fn builder() -> SetDomBreakpointBuilder {
176        <SetDomBreakpointBuilder as Default>::default()
177    }
178}
179#[derive(Default, Clone)]
180pub struct SetDomBreakpointBuilder {
181    node_id: Option<crate::browser_protocol::dom::types::NodeId>,
182    r#type: Option<super::types::DomBreakpointType>,
183}
184impl SetDomBreakpointBuilder {
185    pub fn node_id(
186        mut self,
187        node_id: impl Into<crate::browser_protocol::dom::types::NodeId>,
188    ) -> Self {
189        self.node_id = Some(node_id.into());
190        self
191    }
192    pub fn r#type(mut self, r#type: impl Into<super::types::DomBreakpointType>) -> Self {
193        self.r#type = Some(r#type.into());
194        self
195    }
196    pub fn build(self) -> Result<SetDomBreakpoint, String> {
197        Ok(SetDomBreakpoint {
198            method: SetDomBreakpointMethod::SetDomBreakpoint,
199            params: SetDomBreakpointParams {
200                node_id: self
201                    .node_id
202                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(node_id)))?,
203                r#type: self
204                    .r#type
205                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(r#type)))?,
206            },
207        })
208    }
209}
210impl SetEventListenerBreakpoint {
211    pub fn builder() -> SetEventListenerBreakpointBuilder {
212        <SetEventListenerBreakpointBuilder as Default>::default()
213    }
214}
215#[derive(Default, Clone)]
216pub struct SetEventListenerBreakpointBuilder {
217    event_name: Option<String>,
218    target_name: Option<String>,
219}
220impl SetEventListenerBreakpointBuilder {
221    pub fn event_name(mut self, event_name: impl Into<String>) -> Self {
222        self.event_name = Some(event_name.into());
223        self
224    }
225    pub fn target_name(mut self, target_name: impl Into<String>) -> Self {
226        self.target_name = Some(target_name.into());
227        self
228    }
229    pub fn build(self) -> Result<SetEventListenerBreakpoint, String> {
230        Ok(SetEventListenerBreakpoint {
231            method: SetEventListenerBreakpointMethod::SetEventListenerBreakpoint,
232            params: SetEventListenerBreakpointParams {
233                event_name: self.event_name.ok_or_else(|| {
234                    format!("Field `{}` is mandatory.", std::stringify!(event_name))
235                })?,
236                target_name: self.target_name,
237            },
238        })
239    }
240}
241impl SetXhrBreakpoint {
242    pub fn builder() -> SetXhrBreakpointBuilder {
243        <SetXhrBreakpointBuilder as Default>::default()
244    }
245}
246#[derive(Default, Clone)]
247pub struct SetXhrBreakpointBuilder {
248    url: Option<String>,
249}
250impl SetXhrBreakpointBuilder {
251    pub fn url(mut self, url: impl Into<String>) -> Self {
252        self.url = Some(url.into());
253        self
254    }
255    pub fn build(self) -> Result<SetXhrBreakpoint, String> {
256        Ok(SetXhrBreakpoint {
257            method: SetXhrBreakpointMethod::SetXhrBreakpoint,
258            params: SetXhrBreakpointParams {
259                url: self
260                    .url
261                    .ok_or_else(|| format!("Field `{}` is mandatory.", std::stringify!(url)))?,
262            },
263        })
264    }
265}
rustenium_cdp_definitions/browser_protocol/dom_debugger/command_builders.rs

rustenium_cdp_definitions/browser_protocol/dom_debugger/
command_builders.rs
