Coverage Report

Created: 2025-06-23 13:53

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/build/cargo-vendor-dir/serde-1.0.219/src/private/doc.rs
Line
Count
Source
1
// Used only by Serde doc tests. Not public API.
2
3
use crate::lib::*;
4
5
use crate::ser;
6
7
#[doc(hidden)]
8
#[derive(Debug)]
9
pub struct Error;
10
11
impl ser::Error for Error {
12
0
    fn custom<T>(_: T) -> Self
13
0
    where
14
0
        T: Display,
15
0
    {
16
0
        unimplemented!()
17
    }
18
}
19
20
#[cfg(feature = "std")]
21
impl error::Error for Error {
22
0
    fn description(&self) -> &str {
23
0
        unimplemented!()
24
    }
25
}
26
27
impl Display for Error {
28
0
    fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
29
0
        unimplemented!()
30
    }
31
}
32
33
#[doc(hidden)]
34
#[macro_export]
35
macro_rules! __private_serialize {
36
    () => {
37
        trait Serialize {
38
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
39
            where
40
                S: $crate::Serializer;
41
        }
42
    };
43
}
44
45
#[doc(hidden)]
46
#[macro_export(local_inner_macros)]
47
macro_rules! __serialize_unimplemented {
48
    ($($func:ident)*) => {
49
        $(
50
            __serialize_unimplemented_helper!($func);
51
        )*
52
    };
53
}
54
55
#[doc(hidden)]
56
#[macro_export]
57
macro_rules! __serialize_unimplemented_method {
58
    ($func:ident $(<$t:ident>)* ($($arg:ty),*) -> $ret:ident) => {
59
        fn $func $(<$t>)* (self $(, _: $arg)*) -> $crate::__private::Result<Self::$ret, Self::Error>
60
        where
61
            $($t: ?Sized + $crate::Serialize,)*
62
        {
63
            unimplemented!()
64
        }
65
    };
66
}
67
68
#[doc(hidden)]
69
#[macro_export(local_inner_macros)]
70
macro_rules! __serialize_unimplemented_helper {
71
    (bool) => {
72
        __serialize_unimplemented_method!(serialize_bool(bool) -> Ok);
73
    };
74
    (i8) => {
75
        __serialize_unimplemented_method!(serialize_i8(i8) -> Ok);
76
    };
77
    (i16) => {
78
        __serialize_unimplemented_method!(serialize_i16(i16) -> Ok);
79
    };
80
    (i32) => {
81
        __serialize_unimplemented_method!(serialize_i32(i32) -> Ok);
82
    };
83
    (i64) => {
84
        __serialize_unimplemented_method!(serialize_i64(i64) -> Ok);
85
    };
86
    (u8) => {
87
        __serialize_unimplemented_method!(serialize_u8(u8) -> Ok);
88
    };
89
    (u16) => {
90
        __serialize_unimplemented_method!(serialize_u16(u16) -> Ok);
91
    };
92
    (u32) => {
93
        __serialize_unimplemented_method!(serialize_u32(u32) -> Ok);
94
    };
95
    (u64) => {
96
        __serialize_unimplemented_method!(serialize_u64(u64) -> Ok);
97
    };
98
    (f32) => {
99
        __serialize_unimplemented_method!(serialize_f32(f32) -> Ok);
100
    };
101
    (f64) => {
102
        __serialize_unimplemented_method!(serialize_f64(f64) -> Ok);
103
    };
104
    (char) => {
105
        __serialize_unimplemented_method!(serialize_char(char) -> Ok);
106
    };
107
    (str) => {
108
        __serialize_unimplemented_method!(serialize_str(&str) -> Ok);
109
    };
110
    (bytes) => {
111
        __serialize_unimplemented_method!(serialize_bytes(&[u8]) -> Ok);
112
    };
113
    (none) => {
114
        __serialize_unimplemented_method!(serialize_none() -> Ok);
115
    };
116
    (some) => {
117
        __serialize_unimplemented_method!(serialize_some<T>(&T) -> Ok);
118
    };
119
    (unit) => {
120
        __serialize_unimplemented_method!(serialize_unit() -> Ok);
121
    };
122
    (unit_struct) => {
123
        __serialize_unimplemented_method!(serialize_unit_struct(&str) -> Ok);
124
    };
125
    (unit_variant) => {
126
        __serialize_unimplemented_method!(serialize_unit_variant(&str, u32, &str) -> Ok);
127
    };
128
    (newtype_struct) => {
129
        __serialize_unimplemented_method!(serialize_newtype_struct<T>(&str, &T) -> Ok);
130
    };
131
    (newtype_variant) => {
132
        __serialize_unimplemented_method!(serialize_newtype_variant<T>(&str, u32, &str, &T) -> Ok);
133
    };
134
    (seq) => {
135
        type SerializeSeq = $crate::ser::Impossible<Self::Ok, Self::Error>;
136
        __serialize_unimplemented_method!(serialize_seq(Option<usize>) -> SerializeSeq);
137
    };
138
    (tuple) => {
139
        type SerializeTuple = $crate::ser::Impossible<Self::Ok, Self::Error>;
140
        __serialize_unimplemented_method!(serialize_tuple(usize) -> SerializeTuple);
141
    };
142
    (tuple_struct) => {
143
        type SerializeTupleStruct = $crate::ser::Impossible<Self::Ok, Self::Error>;
144
        __serialize_unimplemented_method!(serialize_tuple_struct(&str, usize) -> SerializeTupleStruct);
145
    };
146
    (tuple_variant) => {
147
        type SerializeTupleVariant = $crate::ser::Impossible<Self::Ok, Self::Error>;
148
        __serialize_unimplemented_method!(serialize_tuple_variant(&str, u32, &str, usize) -> SerializeTupleVariant);
149
    };
150
    (map) => {
151
        type SerializeMap = $crate::ser::Impossible<Self::Ok, Self::Error>;
152
        __serialize_unimplemented_method!(serialize_map(Option<usize>) -> SerializeMap);
153
    };
154
    (struct) => {
155
        type SerializeStruct = $crate::ser::Impossible<Self::Ok, Self::Error>;
156
        __serialize_unimplemented_method!(serialize_struct(&str, usize) -> SerializeStruct);
157
    };
158
    (struct_variant) => {
159
        type SerializeStructVariant = $crate::ser::Impossible<Self::Ok, Self::Error>;
160
        __serialize_unimplemented_method!(serialize_struct_variant(&str, u32, &str, usize) -> SerializeStructVariant);
161
    };
162
}