js-protocol 0.1.4

Generated Rust types and commands for the Chrome DevTools Protocol (js-protocol)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

//! This domain is deprecated.


use serde::{Serialize, Deserialize};
use serde_json::Value as JsonValue;
use std::borrow::Cow;

/// Description of the protocol domain.

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
#[serde(rename_all = "camelCase")]
pub struct Domain<'a> {
    /// Domain name.
    name: Cow<'a, str>,
    /// Domain version.
    version: Cow<'a, str>,
}

impl<'a> Domain<'a> {
    /// Creates a builder for this type with the required parameters:
    /// * `name`: Domain name.
    /// * `version`: Domain version.
    pub fn builder(name: impl Into<Cow<'a, str>>, version: impl Into<Cow<'a, str>>) -> DomainBuilder<'a> {
        DomainBuilder {
            name: name.into(),
            version: version.into(),
        }
    }
    /// Domain name.
    pub fn name(&self) -> &str { self.name.as_ref() }
    /// Domain version.
    pub fn version(&self) -> &str { self.version.as_ref() }
}


pub struct DomainBuilder<'a> {
    name: Cow<'a, str>,
    version: Cow<'a, str>,
}

impl<'a> DomainBuilder<'a> {
    pub fn build(self) -> Domain<'a> {
        Domain {
            name: self.name,
            version: self.version,
        }
    }
}

/// Returns supported domains.

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
#[serde(rename_all = "camelCase")]
pub struct GetDomainsReturns<'a> {
    /// List of supported domains.
    domains: Vec<Domain<'a>>,
}

impl<'a> GetDomainsReturns<'a> {
    /// Creates a builder for this type with the required parameters:
    /// * `domains`: List of supported domains.
    pub fn builder(domains: Vec<Domain<'a>>) -> GetDomainsReturnsBuilder<'a> {
        GetDomainsReturnsBuilder {
            domains: domains,
        }
    }
    /// List of supported domains.
    pub fn domains(&self) -> &[Domain<'a>] { &self.domains }
}


pub struct GetDomainsReturnsBuilder<'a> {
    domains: Vec<Domain<'a>>,
}

impl<'a> GetDomainsReturnsBuilder<'a> {
    pub fn build(self) -> GetDomainsReturns<'a> {
        GetDomainsReturns {
            domains: self.domains,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct GetDomainsParams {}

impl GetDomainsParams { pub const METHOD: &'static str = "Schema.getDomains"; }

impl<'a> crate::CdpCommand<'a> for GetDomainsParams {
    const METHOD: &'static str = "Schema.getDomains";
    type Response = GetDomainsReturns<'a>;
}