Coverage Report

Created: 2025-10-28 07:00

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/rust/registry/src/index.crates.io-1949cf8c6b5b557f/serde-1.0.136/src/private/doc.rs
Line
Count
Source
1
// Used only by Serde doc tests. Not public API.
2
3
use lib::*;
4
5
use 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: ?Sized + $crate::Serialize>)* (self $(, _: $arg)*) -> $crate::__private::Result<Self::$ret, Self::Error> {
60
            unimplemented!()
61
        }
62
    };
63
}
64
65
#[doc(hidden)]
66
#[macro_export(local_inner_macros)]
67
macro_rules! __serialize_unimplemented_helper {
68
    (bool) => {
69
        __serialize_unimplemented_method!(serialize_bool(bool) -> Ok);
70
    };
71
    (i8) => {
72
        __serialize_unimplemented_method!(serialize_i8(i8) -> Ok);
73
    };
74
    (i16) => {
75
        __serialize_unimplemented_method!(serialize_i16(i16) -> Ok);
76
    };
77
    (i32) => {
78
        __serialize_unimplemented_method!(serialize_i32(i32) -> Ok);
79
    };
80
    (i64) => {
81
        __serialize_unimplemented_method!(serialize_i64(i64) -> Ok);
82
    };
83
    (u8) => {
84
        __serialize_unimplemented_method!(serialize_u8(u8) -> Ok);
85
    };
86
    (u16) => {
87
        __serialize_unimplemented_method!(serialize_u16(u16) -> Ok);
88
    };
89
    (u32) => {
90
        __serialize_unimplemented_method!(serialize_u32(u32) -> Ok);
91
    };
92
    (u64) => {
93
        __serialize_unimplemented_method!(serialize_u64(u64) -> Ok);
94
    };
95
    (f32) => {
96
        __serialize_unimplemented_method!(serialize_f32(f32) -> Ok);
97
    };
98
    (f64) => {
99
        __serialize_unimplemented_method!(serialize_f64(f64) -> Ok);
100
    };
101
    (char) => {
102
        __serialize_unimplemented_method!(serialize_char(char) -> Ok);
103
    };
104
    (str) => {
105
        __serialize_unimplemented_method!(serialize_str(&str) -> Ok);
106
    };
107
    (bytes) => {
108
        __serialize_unimplemented_method!(serialize_bytes(&[u8]) -> Ok);
109
    };
110
    (none) => {
111
        __serialize_unimplemented_method!(serialize_none() -> Ok);
112
    };
113
    (some) => {
114
        __serialize_unimplemented_method!(serialize_some<T>(&T) -> Ok);
115
    };
116
    (unit) => {
117
        __serialize_unimplemented_method!(serialize_unit() -> Ok);
118
    };
119
    (unit_struct) => {
120
        __serialize_unimplemented_method!(serialize_unit_struct(&str) -> Ok);
121
    };
122
    (unit_variant) => {
123
        __serialize_unimplemented_method!(serialize_unit_variant(&str, u32, &str) -> Ok);
124
    };
125
    (newtype_struct) => {
126
        __serialize_unimplemented_method!(serialize_newtype_struct<T>(&str, &T) -> Ok);
127
    };
128
    (newtype_variant) => {
129
        __serialize_unimplemented_method!(serialize_newtype_variant<T>(&str, u32, &str, &T) -> Ok);
130
    };
131
    (seq) => {
132
        type SerializeSeq = $crate::ser::Impossible<Self::Ok, Self::Error>;
133
        __serialize_unimplemented_method!(serialize_seq(Option<usize>) -> SerializeSeq);
134
    };
135
    (tuple) => {
136
        type SerializeTuple = $crate::ser::Impossible<Self::Ok, Self::Error>;
137
        __serialize_unimplemented_method!(serialize_tuple(usize) -> SerializeTuple);
138
    };
139
    (tuple_struct) => {
140
        type SerializeTupleStruct = $crate::ser::Impossible<Self::Ok, Self::Error>;
141
        __serialize_unimplemented_method!(serialize_tuple_struct(&str, usize) -> SerializeTupleStruct);
142
    };
143
    (tuple_variant) => {
144
        type SerializeTupleVariant = $crate::ser::Impossible<Self::Ok, Self::Error>;
145
        __serialize_unimplemented_method!(serialize_tuple_variant(&str, u32, &str, usize) -> SerializeTupleVariant);
146
    };
147
    (map) => {
148
        type SerializeMap = $crate::ser::Impossible<Self::Ok, Self::Error>;
149
        __serialize_unimplemented_method!(serialize_map(Option<usize>) -> SerializeMap);
150
    };
151
    (struct) => {
152
        type SerializeStruct = $crate::ser::Impossible<Self::Ok, Self::Error>;
153
        __serialize_unimplemented_method!(serialize_struct(&str, usize) -> SerializeStruct);
154
    };
155
    (struct_variant) => {
156
        type SerializeStructVariant = $crate::ser::Impossible<Self::Ok, Self::Error>;
157
        __serialize_unimplemented_method!(serialize_struct_variant(&str, u32, &str, usize) -> SerializeStructVariant);
158
    };
159
}