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 { custom<T>(_: T) -> Self where T: Display,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 { description(&self) -> &str22 fn description(&self) -> &str { 23 unimplemented!() 24 } 25 } 26 27 impl Display for Error { fmt(&self, _: &mut fmt::Formatter) -> fmt::Result28 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: ?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 } 160