rustenium-bidi-definitions 0.1.1

Generated WebDriver BiDi protocol type definitions for Rustenium
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106

macro_rules! group_enum {
    ($name:ident { $( $variant:ident($ty:ty) ),* $(,)? } + other) => {
        #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
        #[serde(untagged)]
        pub enum $name {
            $( $variant($ty), )*
            Other(serde_json::Value),
        }

        $(
            impl From<$ty> for $name {
                fn from(v: $ty) -> Self {
                    $name::$variant(v)
                }
            }

            impl TryFrom<$name> for $ty {
                type Error = $name;

                #[allow(unreachable_patterns)]
                fn try_from(e: $name) -> Result<Self, <$ty as TryFrom<$name>>::Error> {
                    match e {
                        $name::$variant(inner) => Ok(inner),
                        other => Err(other),
                    }
                }
            }
        )*
    };

    ($name:ident { $( $variant:ident($ty:ty) ),* $(,)? } + identifiable) => {
        group_enum!($name { $( $variant($ty) ),* });

        impl $name {
            pub fn identifier(&self) -> &'static str {
                match self {
                    $( $name::$variant(inner) => inner.identifier(), )*
                }
            }
        }
    };

    ($name:ident { $( $variant:ident($ty:ty) ),* $(,)? } + other + identifiable) => {
        group_enum!($name { $( $variant($ty) ),* } + other);

        impl $name {
            pub fn identifier(&self) -> &'static str {
                match self {
                    $( $name::$variant(inner) => inner.identifier(), )*
                    $name::Other(_) => "unknown",
                }
            }
        }
    };

    ($name:ident { $( $variant:ident($ty:ty) ),* $(,)? }) => {
        #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
        #[serde(untagged)]
        pub enum $name {
            $( $variant($ty), )*
        }

        $(
            impl From<$ty> for $name {
                fn from(v: $ty) -> Self {
                    $name::$variant(v)
                }
            }

            impl TryFrom<$name> for $ty {
                type Error = $name;

                #[allow(unreachable_patterns)]
                fn try_from(e: $name) -> Result<Self, <$ty as TryFrom<$name>>::Error> {
                    match e {
                        $name::$variant(inner) => Ok(inner),
                        other => Err(other),
                    }
                }
            }
        )*
    };
}

/// Generates transitive `From` and `TryFrom` impls.
/// `impl_from!(LeafType => IntermediateEnum => TargetEnum, ...);`
macro_rules! impl_from {
    ($( $from:ty => $via:ty => $to:ty ),* $(,)?) => {
        $(
            impl From<$from> for $to {
                fn from(v: $from) -> Self {
                    Self::from(<$via>::from(v))
                }
            }

            impl TryFrom<$to> for $from {
                type Error = $to;

                fn try_from(e: $to) -> Result<Self, <$from as TryFrom<$to>>::Error> {
                    let inner = <$via>::try_from(e)?;
                    Self::try_from(inner).map_err(<$to>::from)
                }
            }
        )*
    };
}