| 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 |
fn custom<T>(_: T) -> Self |
| 13 |
where |
| 14 |
T: Display, |
| 15 |
{ |
| 16 |
unimplemented!() |
| 17 |
} |
| 18 |
} |
| 19 |
|
| 20 |
#[cfg(feature = "std")] |
| 21 |
impl error::Error for Error { |
| 22 |
fn description(&self) -> &str { |
| 23 |
unimplemented!() |
| 24 |
} |
| 25 |
} |
| 26 |
|
| 27 |
impl Display for Error { |
| 28 |
fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result { |
| 29 |
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 |
} |