├── .gitignore ├── .travis.yml ├── COPYING ├── Cargo.toml ├── README.md └── src ├── de.rs ├── lib.rs └── ser.rs /.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | /Cargo.lock 3 | /.gitattributes 4 | /.idea/ 5 | *.iml 6 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | language: rust 2 | rust: 3 | - nightly 4 | - beta 5 | - stable 6 | sudo: false 7 | os: linux 8 | cache: 9 | directories: 10 | - $HOME/.cargo 11 | - target 12 | env: 13 | global: 14 | - secure: "RFoJK/j05ZzCrx3zJJjqn8FqL2UwAH0iSTE/pTNsEn4Xl1DFTC/ubb+cu8gFS8wpTY0+zPSmBrHp3R0MNKIpbQqZ2WexEpbzNEdpftcW+eUlEj45HvNWw3LdKn8w0O7txdRxbUVzgDgto+XGsFypMsA5wxjOryYDJWPnpXvt1QL520ro0/IzYToubBj0e6hhlXXvDY0gr4ip/Y/dooWJ0XmPdmHi1atHLBYaH5l0qd5Rc6pfqvj+ctaZQyVV6JEK84ODUeK6IHbthl45/ZwecMZW/egAXX2CCViv2FmCkqoIjGynPd5dVTMMZGYVEYpDMzdkvYze6JoNsj2YZkO3WprpTqUTgwf+7XdRIce0X7rIVm6P5fBiN/8NPcRVgfBR6WthJoRfQYdjkqhrg70wcBrJxRUulPxNxwcCkC9RDEbI8ZlG4ZhNKfAVzV0xMwztcJoz5qqsMSAkWc8HIAZ7CL9zplLe6P7tomaLcWFxkyvGsdOXCHtyBnp8TOwgvG4kGzuZ7myEOrGodWn23F9e5h00Kio9k/j1HDa7+ESQ7UW6MJu4YT+5XTTJi8Dr+kdrUVDwFirab8+A8/tfFmQxZhZdzny48uTjGeDFqmr4hQ+hC3elg+ZDpEl72/A8HMQcpxtpiBkyky0B5sJSCUOeCU8A5DN+UJN/9d6my+10flA=" 15 | - secure: "GNs+Daj2ses715lQWto6a+zFWjBBZ/4Rt/F6j0rpqYjm7NEForoRdDmRWHbN3xGSrxT83G7yuPdGRlAKG1AjM91Dxi2fEw/THvT61QXB5LSW21/2h7WETAJYoBzlFwAPo3RVM0tzkjPQfAm5C3zxbPXjo42D5GQkF50vKixBQZ5QG2FIQHAv80Ed9y2aozf6Z5V6lojjLm2xEfdSNA8Mj8/N3ux2eWESddufk6wdEoRkcpRe2e09TZaeamYQ48yj1paDPKNLFhyRFehtOFGdMQQgbWJ1GsYgtWkHu8f7ohuC4Pdx94f0xTApz+jpeADtDmgX8Cvd2IVCUEB8WLMJv2W+Zp2xrn1Ufr88uCzOUT78c6kiRJfQ9n9IEZSTuie/JtwgjlWuud1raarDDfmRKAGWHRx0WL1TKt4ADuy63pyV78FlLNnMTJ9BwZhUpxQqIbKtw31eIwWxkUiwpvEQ1IYLts4U9rSi8xjnLhA7B97ahIq1pMOWnC4HM2jCggCw2AQtkNNM6vuPli//3i1aF02JrLnlwsXparxnQ70HmyaxX0u38Tgr8zbobtJE8+TsDh2d3uFcI6BNARmsO7I1ifDbPj6aB2JOYK4M8knoP3MG28jO5v3qVXrEmfWm361LMNkmw1cM2MnDBq3uxKWhGZzW4XB72kcSzYgFNzUaaUw=" 16 | before_script: 17 | - curl -L https://github.com/arcnmx/ci/archive/master.tar.gz | tar -xzC $HOME && . $HOME/ci-master/src 18 | 19 | script: 20 | - cargo build 21 | - cargo test 22 | 23 | deploy: 24 | provider: script 25 | script: "true" 26 | on: 27 | tags: true 28 | all_branches: true 29 | condition: "$TRAVIS_RUST_VERSION = stable" 30 | 31 | before_deploy: 32 | - cargo doc 33 | - cargo package 34 | 35 | after_deploy: 36 | - cargo pages-publish 37 | - cargo publish 38 | -------------------------------------------------------------------------------- /COPYING: -------------------------------------------------------------------------------- 1 | Copyright (c) 2016 arcnmx 2 | 3 | Permission is hereby granted, free of charge, to any person obtaining a copy 4 | of this software and associated documentation files (the "Software"), to deal 5 | in the Software without restriction, including without limitation the rights 6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 7 | copies of the Software, and to permit persons to whom the Software is 8 | furnished to do so, subject to the following conditions: 9 | 10 | The above copyright notice and this permission notice shall be included in 11 | all copies or substantial portions of the Software. 12 | 13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 19 | THE SOFTWARE. 20 | -------------------------------------------------------------------------------- /Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "serde-value" 3 | version = "0.7.0" 4 | authors = ["arcnmx"] 5 | edition = "2018" 6 | 7 | description = "Serialization value trees" 8 | documentation = "https://docs.rs/serde-value/*/serde_value/" 9 | repository = "https://github.com/arcnmx/serde-value" 10 | readme = "README.md" 11 | keywords = ["serde"] 12 | license = "MIT" 13 | 14 | [dependencies] 15 | serde = "^1.0.0" 16 | ordered-float = "^2.0.0" 17 | 18 | [dev-dependencies] 19 | serde_derive = "^1.0.0" 20 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # serde-value 2 | 3 | [![travis-badge][]][travis] [![release-badge][]][cargo] [![docs-badge][]][docs] [![license-badge][]][license] 4 | 5 | `serde-value` provides a way to capture serialization value trees for later processing. 6 | 7 | [travis-badge]: https://img.shields.io/travis/arcnmx/serde-value/master.svg?style=flat-square 8 | [travis]: https://travis-ci.org/arcnmx/serde-value 9 | [release-badge]: https://img.shields.io/crates/v/serde-value.svg?style=flat-square 10 | [cargo]: https://crates.io/crates/serde-value 11 | [docs-badge]: https://img.shields.io/badge/API-docs-blue.svg?style=flat-square 12 | [docs]: https://docs.rs/serde-value/*/serde_value/ 13 | [license-badge]: https://img.shields.io/badge/license-MIT-lightgray.svg?style=flat-square 14 | [license]: https://github.com/arcnmx/serde-value/blob/master/COPYING 15 | -------------------------------------------------------------------------------- /src/de.rs: -------------------------------------------------------------------------------- 1 | use serde::{forward_to_deserialize_any, de}; 2 | use std::collections::BTreeMap; 3 | use std::error::Error; 4 | use std::fmt; 5 | use std::marker::PhantomData; 6 | 7 | use crate::Value; 8 | 9 | #[derive(Debug)] 10 | pub enum Unexpected { 11 | Bool(bool), 12 | Unsigned(u64), 13 | Signed(i64), 14 | Float(f64), 15 | Char(char), 16 | Str(String), 17 | Bytes(Vec), 18 | Unit, 19 | Option, 20 | NewtypeStruct, 21 | Seq, 22 | Map, 23 | Enum, 24 | UnitVariant, 25 | NewtypeVariant, 26 | TupleVariant, 27 | StructVariant, 28 | Other(String), 29 | } 30 | 31 | impl<'a> From> for Unexpected { 32 | fn from(unexp: de::Unexpected) -> Unexpected { 33 | match unexp { 34 | de::Unexpected::Bool(v) => Unexpected::Bool(v), 35 | de::Unexpected::Unsigned(v) => Unexpected::Unsigned(v), 36 | de::Unexpected::Signed(v) => Unexpected::Signed(v), 37 | de::Unexpected::Float(v) => Unexpected::Float(v), 38 | de::Unexpected::Char(v) => Unexpected::Char(v), 39 | de::Unexpected::Str(v) => Unexpected::Str(v.to_owned()), 40 | de::Unexpected::Bytes(v) => Unexpected::Bytes(v.to_owned()), 41 | de::Unexpected::Unit => Unexpected::Unit, 42 | de::Unexpected::Option => Unexpected::Option, 43 | de::Unexpected::NewtypeStruct => Unexpected::NewtypeStruct, 44 | de::Unexpected::Seq => Unexpected::Seq, 45 | de::Unexpected::Map => Unexpected::Map, 46 | de::Unexpected::Enum => Unexpected::Enum, 47 | de::Unexpected::UnitVariant => Unexpected::UnitVariant, 48 | de::Unexpected::NewtypeVariant => Unexpected::NewtypeVariant, 49 | de::Unexpected::TupleVariant => Unexpected::TupleVariant, 50 | de::Unexpected::StructVariant => Unexpected::StructVariant, 51 | de::Unexpected::Other(v) => Unexpected::Other(v.to_owned()), 52 | } 53 | } 54 | } 55 | 56 | impl Unexpected { 57 | pub fn to_unexpected<'a>(&'a self) -> de::Unexpected<'a> { 58 | match *self { 59 | Unexpected::Bool(v) => de::Unexpected::Bool(v), 60 | Unexpected::Unsigned(v) => de::Unexpected::Unsigned(v), 61 | Unexpected::Signed(v) => de::Unexpected::Signed(v), 62 | Unexpected::Float(v) => de::Unexpected::Float(v), 63 | Unexpected::Char(v) => de::Unexpected::Char(v), 64 | Unexpected::Str(ref v) => de::Unexpected::Str(v), 65 | Unexpected::Bytes(ref v) => de::Unexpected::Bytes(v), 66 | Unexpected::Unit => de::Unexpected::Unit, 67 | Unexpected::Option => de::Unexpected::Option, 68 | Unexpected::NewtypeStruct => de::Unexpected::NewtypeStruct, 69 | Unexpected::Seq => de::Unexpected::Seq, 70 | Unexpected::Map => de::Unexpected::Map, 71 | Unexpected::Enum => de::Unexpected::Enum, 72 | Unexpected::UnitVariant => de::Unexpected::UnitVariant, 73 | Unexpected::NewtypeVariant => de::Unexpected::NewtypeVariant, 74 | Unexpected::TupleVariant => de::Unexpected::TupleVariant, 75 | Unexpected::StructVariant => de::Unexpected::StructVariant, 76 | Unexpected::Other(ref v) => de::Unexpected::Other(v), 77 | } 78 | } 79 | 80 | } 81 | 82 | #[derive(Debug)] 83 | pub enum DeserializerError { 84 | Custom(String), 85 | InvalidType(Unexpected, String), 86 | InvalidValue(Unexpected, String), 87 | InvalidLength(usize, String), 88 | UnknownVariant(String, &'static [&'static str]), 89 | UnknownField(String, &'static [&'static str]), 90 | MissingField(&'static str), 91 | DuplicateField(&'static str), 92 | } 93 | 94 | impl de::Error for DeserializerError { 95 | fn custom(msg: T) -> Self { 96 | DeserializerError::Custom(msg.to_string()) 97 | } 98 | 99 | fn invalid_type(unexp: de::Unexpected, exp: &dyn de::Expected) -> Self { 100 | DeserializerError::InvalidType(unexp.into(), exp.to_string()) 101 | } 102 | 103 | fn invalid_value(unexp: de::Unexpected, exp: &dyn de::Expected) -> Self { 104 | DeserializerError::InvalidValue(unexp.into(), exp.to_string()) 105 | } 106 | 107 | fn invalid_length(len: usize, exp: &dyn de::Expected) -> Self { 108 | DeserializerError::InvalidLength(len, exp.to_string()) 109 | } 110 | 111 | fn unknown_variant(field: &str, expected: &'static [&'static str]) -> Self { 112 | DeserializerError::UnknownVariant(field.into(), expected) 113 | } 114 | 115 | fn unknown_field(field: &str, expected: &'static [&'static str]) -> Self { 116 | DeserializerError::UnknownField(field.into(), expected) 117 | } 118 | 119 | fn missing_field(field: &'static str) -> Self { 120 | DeserializerError::MissingField(field) 121 | } 122 | 123 | fn duplicate_field(field: &'static str) -> Self { 124 | DeserializerError::DuplicateField(field) 125 | } 126 | } 127 | 128 | impl DeserializerError { 129 | pub fn to_error(&self) -> E { 130 | match *self { 131 | DeserializerError::Custom(ref msg) => E::custom(msg.clone()), 132 | DeserializerError::InvalidType(ref unexp, ref exp) => { 133 | E::invalid_type(unexp.to_unexpected(), &&**exp) 134 | } 135 | DeserializerError::InvalidValue(ref unexp, ref exp) => { 136 | E::invalid_value(unexp.to_unexpected(), &&**exp) 137 | } 138 | DeserializerError::InvalidLength(len, ref exp) => E::invalid_length(len, &&**exp), 139 | DeserializerError::UnknownVariant(ref field, exp) => E::unknown_variant(field, exp), 140 | DeserializerError::UnknownField(ref field, exp) => E::unknown_field(field, exp), 141 | DeserializerError::MissingField(field) => E::missing_field(field), 142 | DeserializerError::DuplicateField(field) => E::missing_field(field), 143 | } 144 | } 145 | 146 | pub fn into_error(self) -> E { 147 | self.to_error() 148 | } 149 | } 150 | 151 | impl Error for DeserializerError { 152 | fn description(&self) -> &str { 153 | "Value deserializer error" 154 | } 155 | } 156 | 157 | impl fmt::Display for DeserializerError { 158 | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 159 | match *self { 160 | DeserializerError::Custom(ref msg) => write!(f, "{}", msg), 161 | DeserializerError::InvalidType(ref unexp, ref exp) => { 162 | write!(f, "Invalid type {}. Expected {}", unexp.to_unexpected(), exp) 163 | } 164 | DeserializerError::InvalidValue(ref unexp, ref exp) => { 165 | write!(f, "Invalid value {}. Expected {}", unexp.to_unexpected(), exp) 166 | } 167 | DeserializerError::InvalidLength(len, ref exp) => { 168 | write!(f, "Invalid length {}. Expected {}", len, exp) 169 | } 170 | DeserializerError::UnknownVariant(ref field, exp) => { 171 | write!(f, "Unknown variant {}. Expected one of {}", field, exp.join(", ")) 172 | }, 173 | DeserializerError::UnknownField(ref field, exp) => { 174 | write!(f, "Unknown field {}. Expected one of {}", field, exp.join(", ")) 175 | } 176 | DeserializerError::MissingField(field) => write!(f, "Missing field {}", field), 177 | DeserializerError::DuplicateField(field) => write!(f, "Duplicate field {}", field), 178 | } 179 | } 180 | } 181 | 182 | impl From for DeserializerError { 183 | fn from(e: de::value::Error) -> DeserializerError { 184 | DeserializerError::Custom(e.to_string()) 185 | } 186 | } 187 | 188 | pub struct ValueVisitor; 189 | 190 | impl<'de> de::Visitor<'de> for ValueVisitor { 191 | type Value = Value; 192 | 193 | fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result { 194 | fmt.write_str("any value") 195 | } 196 | 197 | fn visit_bool(self, value: bool) -> Result { 198 | Ok(Value::Bool(value)) 199 | } 200 | 201 | fn visit_i8(self, value: i8) -> Result { 202 | Ok(Value::I8(value)) 203 | } 204 | 205 | fn visit_i16(self, value: i16) -> Result { 206 | Ok(Value::I16(value)) 207 | } 208 | 209 | fn visit_i32(self, value: i32) -> Result { 210 | Ok(Value::I32(value)) 211 | } 212 | 213 | fn visit_i64(self, value: i64) -> Result { 214 | Ok(Value::I64(value)) 215 | } 216 | 217 | fn visit_u8(self, value: u8) -> Result { 218 | Ok(Value::U8(value)) 219 | } 220 | 221 | fn visit_u16(self, value: u16) -> Result { 222 | Ok(Value::U16(value)) 223 | } 224 | 225 | fn visit_u32(self, value: u32) -> Result { 226 | Ok(Value::U32(value)) 227 | } 228 | 229 | fn visit_u64(self, value: u64) -> Result { 230 | Ok(Value::U64(value)) 231 | } 232 | 233 | fn visit_f32(self, value: f32) -> Result { 234 | Ok(Value::F32(value)) 235 | } 236 | 237 | fn visit_f64(self, value: f64) -> Result { 238 | Ok(Value::F64(value)) 239 | } 240 | 241 | fn visit_char(self, value: char) -> Result { 242 | Ok(Value::Char(value)) 243 | } 244 | 245 | fn visit_str(self, value: &str) -> Result { 246 | Ok(Value::String(value.into())) 247 | } 248 | 249 | fn visit_string(self, value: String) -> Result { 250 | Ok(Value::String(value)) 251 | } 252 | 253 | fn visit_unit(self) -> Result { 254 | Ok(Value::Unit) 255 | } 256 | 257 | fn visit_none(self) -> Result { 258 | Ok(Value::Option(None)) 259 | } 260 | 261 | fn visit_some>(self, d: D) -> Result { 262 | d.deserialize_any(ValueVisitor).map(|v| Value::Option(Some(Box::new(v)))) 263 | } 264 | 265 | fn visit_newtype_struct>(self, d: D) -> Result { 266 | d.deserialize_any(ValueVisitor).map(|v| Value::Newtype(Box::new(v))) 267 | } 268 | 269 | fn visit_seq>(self, mut visitor: V) -> Result { 270 | let mut values = Vec::new(); 271 | while let Some(elem) = visitor.next_element()? { 272 | values.push(elem); 273 | } 274 | Ok(Value::Seq(values)) 275 | } 276 | 277 | fn visit_map>(self, mut visitor: V) -> Result { 278 | let mut values = BTreeMap::new(); 279 | while let Some((key, value)) = visitor.next_entry()? { 280 | values.insert(key, value); 281 | } 282 | Ok(Value::Map(values)) 283 | } 284 | 285 | fn visit_bytes(self, v: &[u8]) -> Result { 286 | Ok(Value::Bytes(v.into())) 287 | } 288 | 289 | fn visit_byte_buf(self, v: Vec) -> Result { 290 | Ok(Value::Bytes(v)) 291 | } 292 | } 293 | 294 | impl<'de> de::Deserialize<'de> for Value { 295 | fn deserialize>(d: D) -> Result { 296 | d.deserialize_any(ValueVisitor) 297 | } 298 | } 299 | 300 | impl<'de> de::IntoDeserializer<'de, DeserializerError> for Value { 301 | type Deserializer = Value; 302 | 303 | fn into_deserializer(self) -> Value { 304 | self 305 | } 306 | } 307 | 308 | pub struct ValueDeserializer { 309 | value: Value, 310 | error: PhantomData E>, 311 | } 312 | 313 | impl ValueDeserializer { 314 | pub fn new(value: Value) -> Self { 315 | ValueDeserializer { 316 | value: value, 317 | error: Default::default(), 318 | } 319 | } 320 | 321 | pub fn into_value(self) -> Value { 322 | self.value 323 | } 324 | } 325 | 326 | impl<'de, E> de::Deserializer<'de> for ValueDeserializer where E: de::Error { 327 | type Error = E; 328 | 329 | fn deserialize_any>(self, visitor: V) -> Result { 330 | match self.value { 331 | Value::Bool(v) => visitor.visit_bool(v), 332 | Value::U8(v) => visitor.visit_u8(v), 333 | Value::U16(v) => visitor.visit_u16(v), 334 | Value::U32(v) => visitor.visit_u32(v), 335 | Value::U64(v) => visitor.visit_u64(v), 336 | Value::I8(v) => visitor.visit_i8(v), 337 | Value::I16(v) => visitor.visit_i16(v), 338 | Value::I32(v) => visitor.visit_i32(v), 339 | Value::I64(v) => visitor.visit_i64(v), 340 | Value::F32(v) => visitor.visit_f32(v), 341 | Value::F64(v) => visitor.visit_f64(v), 342 | Value::Char(v) => visitor.visit_char(v), 343 | Value::String(v) => visitor.visit_string(v), 344 | Value::Unit => visitor.visit_unit(), 345 | Value::Option(None) => visitor.visit_none(), 346 | Value::Option(Some(v)) => visitor.visit_some(ValueDeserializer::new(*v)), 347 | Value::Newtype(v) => visitor.visit_newtype_struct(ValueDeserializer::new(*v)), 348 | Value::Seq(v) => { 349 | visitor.visit_seq(de::value::SeqDeserializer::new(v.into_iter().map(ValueDeserializer::new))) 350 | }, 351 | Value::Map(v) => { 352 | visitor.visit_map(de::value::MapDeserializer::new(v.into_iter().map(|(k, v)| ( 353 | ValueDeserializer::new(k), 354 | ValueDeserializer::new(v), 355 | )))) 356 | }, 357 | Value::Bytes(v) => visitor.visit_byte_buf(v), 358 | } 359 | } 360 | 361 | fn deserialize_option>(self, visitor: V) -> Result { 362 | match self.value { 363 | Value::Option(..) => self.deserialize_any(visitor), 364 | Value::Unit => visitor.visit_unit(), 365 | _ => visitor.visit_some(self) 366 | } 367 | } 368 | 369 | fn deserialize_enum>(self, 370 | _name: &'static str, 371 | _variants: &'static [&'static str], 372 | visitor: V) 373 | -> Result { 374 | let (variant, value) = match self.value { 375 | Value::Map(value) => { 376 | let mut iter = value.into_iter(); 377 | let (variant, value) = match iter.next() { 378 | Some(v) => v, 379 | None => { 380 | return Err(de::Error::invalid_value(de::Unexpected::Map, 381 | &"map with a single key")); 382 | } 383 | }; 384 | // enums are encoded as maps with a single key:value pair 385 | if iter.next().is_some() { 386 | return Err(de::Error::invalid_value(de::Unexpected::Map, 387 | &"map with a single key")); 388 | } 389 | (variant, Some(value)) 390 | } 391 | Value::String(variant) => (Value::String(variant), None), 392 | other => { 393 | return Err(de::Error::invalid_type(other.unexpected(), &"string or map")); 394 | } 395 | }; 396 | 397 | let d = EnumDeserializer { 398 | variant: variant, 399 | value: value, 400 | error: Default::default(), 401 | }; 402 | visitor.visit_enum(d) 403 | } 404 | 405 | fn deserialize_newtype_struct>(self, 406 | _name: &'static str, 407 | visitor: V) 408 | -> Result { 409 | match self.value { 410 | Value::Newtype(v) => visitor.visit_newtype_struct(ValueDeserializer::new(*v)), 411 | _ => visitor.visit_newtype_struct(self), 412 | } 413 | } 414 | 415 | forward_to_deserialize_any! { 416 | bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit 417 | seq bytes byte_buf map unit_struct 418 | tuple_struct struct tuple ignored_any identifier 419 | } 420 | } 421 | 422 | impl<'de, E> de::IntoDeserializer<'de, E> for ValueDeserializer where E: de::Error { 423 | type Deserializer = Self; 424 | 425 | fn into_deserializer(self) -> Self::Deserializer { 426 | self 427 | } 428 | } 429 | 430 | impl<'de> de::Deserializer<'de> for Value { 431 | type Error = DeserializerError; 432 | 433 | fn deserialize_any>(self, visitor: V) -> Result { 434 | ValueDeserializer::new(self).deserialize_any(visitor) 435 | } 436 | 437 | fn deserialize_option>(self, visitor: V) -> Result { 438 | ValueDeserializer::new(self).deserialize_option(visitor) 439 | } 440 | 441 | fn deserialize_enum>(self, 442 | name: &'static str, 443 | variants: &'static [&'static str], 444 | visitor: V) 445 | -> Result { 446 | ValueDeserializer::new(self).deserialize_enum(name, variants, visitor) 447 | } 448 | 449 | fn deserialize_newtype_struct>(self, 450 | name: &'static str, 451 | visitor: V) 452 | -> Result { 453 | ValueDeserializer::new(self).deserialize_newtype_struct(name, visitor) 454 | } 455 | 456 | forward_to_deserialize_any! { 457 | bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit 458 | seq bytes byte_buf map unit_struct 459 | tuple_struct struct tuple ignored_any identifier 460 | } 461 | } 462 | 463 | struct EnumDeserializer { 464 | variant: Value, 465 | value: Option, 466 | error: PhantomData E>, 467 | } 468 | 469 | impl<'de, E> de::EnumAccess<'de> for EnumDeserializer where E: de::Error { 470 | type Error = E; 471 | type Variant = VariantDeserializer; 472 | 473 | fn variant_seed(self, seed: V) -> Result<(V::Value, VariantDeserializer), Self::Error> 474 | where V: de::DeserializeSeed<'de> 475 | { 476 | let visitor = VariantDeserializer { 477 | value: self.value, 478 | error: Default::default(), 479 | }; 480 | seed.deserialize(ValueDeserializer::new(self.variant)).map(|v| (v, visitor)) 481 | } 482 | } 483 | 484 | struct VariantDeserializer { 485 | value: Option, 486 | error: PhantomData E>, 487 | } 488 | 489 | impl<'de, E> de::VariantAccess<'de> for VariantDeserializer where E: de::Error { 490 | type Error = E; 491 | 492 | fn unit_variant(self) -> Result<(), Self::Error> { 493 | match self.value { 494 | Some(value) => de::Deserialize::deserialize(ValueDeserializer::new(value)), 495 | None => Ok(()), 496 | } 497 | } 498 | 499 | fn newtype_variant_seed(self, seed: T) -> Result 500 | where T: de::DeserializeSeed<'de> 501 | { 502 | match self.value { 503 | Some(value) => seed.deserialize(ValueDeserializer::new(value)), 504 | None => Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"newtype variant")), 505 | } 506 | } 507 | 508 | fn tuple_variant(self, _len: usize, visitor: V) -> Result 509 | where V: de::Visitor<'de> 510 | { 511 | match self.value { 512 | Some(Value::Seq(v)) => { 513 | de::Deserializer::deserialize_any( 514 | de::value::SeqDeserializer::new(v.into_iter().map(ValueDeserializer::new)), 515 | visitor) 516 | } 517 | Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"tuple variant")), 518 | None => Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"tuple variant")), 519 | } 520 | } 521 | 522 | fn struct_variant(self, 523 | _fields: &'static [&'static str], 524 | visitor: V) 525 | -> Result 526 | where V: de::Visitor<'de> 527 | { 528 | match self.value { 529 | Some(Value::Map(v)) => { 530 | de::Deserializer::deserialize_any( 531 | de::value::MapDeserializer::new(v.into_iter().map(|(k, v)| ( 532 | ValueDeserializer::new(k), 533 | ValueDeserializer::new(v), 534 | ))), 535 | visitor) 536 | } 537 | Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"struct variant")), 538 | None => Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"struct variant")), 539 | } 540 | } 541 | } 542 | -------------------------------------------------------------------------------- /src/lib.rs: -------------------------------------------------------------------------------- 1 | #![doc(html_root_url="https://docs.rs/serde-value/0.7.0/")] 2 | 3 | use std::collections::BTreeMap; 4 | use std::cmp::Ordering; 5 | use std::hash::{Hash, Hasher}; 6 | use serde::Deserialize; 7 | use ordered_float::OrderedFloat; 8 | 9 | pub use de::*; 10 | pub use ser::*; 11 | 12 | mod de; 13 | mod ser; 14 | 15 | #[derive(Clone, Debug)] 16 | pub enum Value { 17 | Bool(bool), 18 | 19 | U8(u8), 20 | U16(u16), 21 | U32(u32), 22 | U64(u64), 23 | 24 | I8(i8), 25 | I16(i16), 26 | I32(i32), 27 | I64(i64), 28 | 29 | F32(f32), 30 | F64(f64), 31 | 32 | Char(char), 33 | String(String), 34 | 35 | Unit, 36 | Option(Option>), 37 | Newtype(Box), 38 | Seq(Vec), 39 | Map(BTreeMap), 40 | Bytes(Vec), 41 | } 42 | 43 | impl Hash for Value { 44 | fn hash(&self, hasher: &mut H) 45 | where 46 | H: Hasher 47 | { 48 | self.discriminant().hash(hasher); 49 | match *self { 50 | Value::Bool(v) => v.hash(hasher), 51 | Value::U8(v) => v.hash(hasher), 52 | Value::U16(v) => v.hash(hasher), 53 | Value::U32(v) => v.hash(hasher), 54 | Value::U64(v) => v.hash(hasher), 55 | Value::I8(v) => v.hash(hasher), 56 | Value::I16(v) => v.hash(hasher), 57 | Value::I32(v) => v.hash(hasher), 58 | Value::I64(v) => v.hash(hasher), 59 | Value::F32(v) => OrderedFloat(v).hash(hasher), 60 | Value::F64(v) => OrderedFloat(v).hash(hasher), 61 | Value::Char(v) => v.hash(hasher), 62 | Value::String(ref v) => v.hash(hasher), 63 | Value::Unit => ().hash(hasher), 64 | Value::Option(ref v) => v.hash(hasher), 65 | Value::Newtype(ref v) => v.hash(hasher), 66 | Value::Seq(ref v) => v.hash(hasher), 67 | Value::Map(ref v) => v.hash(hasher), 68 | Value::Bytes(ref v) => v.hash(hasher), 69 | } 70 | } 71 | } 72 | 73 | impl PartialEq for Value { 74 | fn eq(&self, rhs: &Self) -> bool { 75 | match (self, rhs) { 76 | (&Value::Bool(v0), &Value::Bool(v1)) if v0 == v1 => true, 77 | (&Value::U8(v0), &Value::U8(v1)) if v0 == v1 => true, 78 | (&Value::U16(v0), &Value::U16(v1)) if v0 == v1 => true, 79 | (&Value::U32(v0), &Value::U32(v1)) if v0 == v1 => true, 80 | (&Value::U64(v0), &Value::U64(v1)) if v0 == v1 => true, 81 | (&Value::I8(v0), &Value::I8(v1)) if v0 == v1 => true, 82 | (&Value::I16(v0), &Value::I16(v1)) if v0 == v1 => true, 83 | (&Value::I32(v0), &Value::I32(v1)) if v0 == v1 => true, 84 | (&Value::I64(v0), &Value::I64(v1)) if v0 == v1 => true, 85 | (&Value::F32(v0), &Value::F32(v1)) if OrderedFloat(v0) == OrderedFloat(v1) => true, 86 | (&Value::F64(v0), &Value::F64(v1)) if OrderedFloat(v0) == OrderedFloat(v1) => true, 87 | (&Value::Char(v0), &Value::Char(v1)) if v0 == v1 => true, 88 | (&Value::String(ref v0), &Value::String(ref v1)) if v0 == v1 => true, 89 | (&Value::Unit, &Value::Unit) => true, 90 | (&Value::Option(ref v0), &Value::Option(ref v1)) if v0 == v1 => true, 91 | (&Value::Newtype(ref v0), &Value::Newtype(ref v1)) if v0 == v1 => true, 92 | (&Value::Seq(ref v0), &Value::Seq(ref v1)) if v0 == v1 => true, 93 | (&Value::Map(ref v0), &Value::Map(ref v1)) if v0 == v1 => true, 94 | (&Value::Bytes(ref v0), &Value::Bytes(ref v1)) if v0 == v1 => true, 95 | _ => false, 96 | } 97 | } 98 | } 99 | 100 | impl Ord for Value { 101 | fn cmp(&self, rhs: &Self) -> Ordering { 102 | match (self, rhs) { 103 | (&Value::Bool(v0), &Value::Bool(ref v1)) => v0.cmp(v1), 104 | (&Value::U8(v0), &Value::U8(ref v1)) => v0.cmp(v1), 105 | (&Value::U16(v0), &Value::U16(ref v1)) => v0.cmp(v1), 106 | (&Value::U32(v0), &Value::U32(ref v1)) => v0.cmp(v1), 107 | (&Value::U64(v0), &Value::U64(ref v1)) => v0.cmp(v1), 108 | (&Value::I8(v0), &Value::I8(ref v1)) => v0.cmp(v1), 109 | (&Value::I16(v0), &Value::I16(ref v1)) => v0.cmp(v1), 110 | (&Value::I32(v0), &Value::I32(ref v1)) => v0.cmp(v1), 111 | (&Value::I64(v0), &Value::I64(ref v1)) => v0.cmp(v1), 112 | (&Value::F32(v0), &Value::F32(v1)) => OrderedFloat(v0).cmp(&OrderedFloat(v1)), 113 | (&Value::F64(v0), &Value::F64(v1)) => OrderedFloat(v0).cmp(&OrderedFloat(v1)), 114 | (&Value::Char(v0), &Value::Char(ref v1)) => v0.cmp(v1), 115 | (&Value::String(ref v0), &Value::String(ref v1)) => v0.cmp(v1), 116 | (&Value::Unit, &Value::Unit) => Ordering::Equal, 117 | (&Value::Option(ref v0), &Value::Option(ref v1)) => v0.cmp(v1), 118 | (&Value::Newtype(ref v0), &Value::Newtype(ref v1)) => v0.cmp(v1), 119 | (&Value::Seq(ref v0), &Value::Seq(ref v1)) => v0.cmp(v1), 120 | (&Value::Map(ref v0), &Value::Map(ref v1)) => v0.cmp(v1), 121 | (&Value::Bytes(ref v0), &Value::Bytes(ref v1)) => v0.cmp(v1), 122 | (ref v0, ref v1) => v0.discriminant().cmp(&v1.discriminant()), 123 | } 124 | } 125 | } 126 | 127 | impl Value { 128 | fn discriminant(&self) -> usize { 129 | match *self { 130 | Value::Bool(..) => 0, 131 | Value::U8(..) => 1, 132 | Value::U16(..) => 2, 133 | Value::U32(..) => 3, 134 | Value::U64(..) => 4, 135 | Value::I8(..) => 5, 136 | Value::I16(..) => 6, 137 | Value::I32(..) => 7, 138 | Value::I64(..) => 8, 139 | Value::F32(..) => 9, 140 | Value::F64(..) => 10, 141 | Value::Char(..) => 11, 142 | Value::String(..) => 12, 143 | Value::Unit => 13, 144 | Value::Option(..) => 14, 145 | Value::Newtype(..) => 15, 146 | Value::Seq(..) => 16, 147 | Value::Map(..) => 17, 148 | Value::Bytes(..) => 18, 149 | } 150 | } 151 | 152 | fn unexpected(&self) -> serde::de::Unexpected { 153 | match *self { 154 | Value::Bool(b) => serde::de::Unexpected::Bool(b), 155 | Value::U8(n) => serde::de::Unexpected::Unsigned(n as u64), 156 | Value::U16(n) => serde::de::Unexpected::Unsigned(n as u64), 157 | Value::U32(n) => serde::de::Unexpected::Unsigned(n as u64), 158 | Value::U64(n) => serde::de::Unexpected::Unsigned(n), 159 | Value::I8(n) => serde::de::Unexpected::Signed(n as i64), 160 | Value::I16(n) => serde::de::Unexpected::Signed(n as i64), 161 | Value::I32(n) => serde::de::Unexpected::Signed(n as i64), 162 | Value::I64(n) => serde::de::Unexpected::Signed(n), 163 | Value::F32(n) => serde::de::Unexpected::Float(n as f64), 164 | Value::F64(n) => serde::de::Unexpected::Float(n), 165 | Value::Char(c) => serde::de::Unexpected::Char(c), 166 | Value::String(ref s) => serde::de::Unexpected::Str(s), 167 | Value::Unit => serde::de::Unexpected::Unit, 168 | Value::Option(_) => serde::de::Unexpected::Option, 169 | Value::Newtype(_) => serde::de::Unexpected::NewtypeStruct, 170 | Value::Seq(_) => serde::de::Unexpected::Seq, 171 | Value::Map(_) => serde::de::Unexpected::Map, 172 | Value::Bytes(ref b) => serde::de::Unexpected::Bytes(b), 173 | } 174 | } 175 | 176 | pub fn deserialize_into<'de, T: Deserialize<'de>>(self) -> Result { 177 | T::deserialize(self) 178 | } 179 | } 180 | 181 | impl Eq for Value { } 182 | impl PartialOrd for Value { 183 | fn partial_cmp(&self, rhs: &Self) -> Option { 184 | Some(self.cmp(rhs)) 185 | } 186 | } 187 | 188 | #[cfg(test)] 189 | use serde_derive::{Deserialize, Serialize}; 190 | 191 | #[test] 192 | fn de_smoke_test() { 193 | // some convoluted Value 194 | let value = Value::Option(Some(Box::new(Value::Seq(vec![ 195 | Value::U16(8), 196 | Value::Char('a'), 197 | Value::F32(1.0), 198 | Value::String("hello".into()), 199 | Value::Map(vec![ 200 | (Value::Bool(false), Value::Unit), 201 | (Value::Bool(true), Value::Newtype(Box::new( 202 | Value::Bytes(b"hi".as_ref().into()) 203 | ))), 204 | ].into_iter().collect()), 205 | ])))); 206 | 207 | // assert that the value remains unchanged through deserialization 208 | let value_de = Value::deserialize(value.clone()).unwrap(); 209 | assert_eq!(value_de, value); 210 | } 211 | 212 | #[test] 213 | fn ser_smoke_test() { 214 | #[derive(Serialize)] 215 | struct Foo { 216 | a: u32, 217 | b: String, 218 | c: Vec, 219 | } 220 | 221 | let foo = Foo { 222 | a: 15, 223 | b: "hello".into(), 224 | c: vec![true, false], 225 | }; 226 | 227 | let expected = Value::Map(vec![ 228 | (Value::String("a".into()), Value::U32(15)), 229 | (Value::String("b".into()), Value::String("hello".into())), 230 | (Value::String("c".into()), Value::Seq(vec![Value::Bool(true), Value::Bool(false)])), 231 | ].into_iter().collect()); 232 | 233 | let value = to_value(&foo).unwrap(); 234 | assert_eq!(expected, value); 235 | } 236 | 237 | #[test] 238 | fn deserialize_into_enum() { 239 | #[derive(Deserialize, Debug, PartialEq, Eq)] 240 | enum Foo { 241 | Bar, 242 | Baz(u8), 243 | } 244 | 245 | let value = Value::String("Bar".into()); 246 | assert_eq!(Foo::deserialize(value).unwrap(), Foo::Bar); 247 | 248 | let value = Value::Map(vec![ 249 | (Value::String("Baz".into()), Value::U8(1)) 250 | ].into_iter().collect()); 251 | assert_eq!(Foo::deserialize(value).unwrap(), Foo::Baz(1)); 252 | } 253 | 254 | #[test] 255 | fn serialize_from_enum() { 256 | #[derive(Serialize)] 257 | enum Foo { 258 | Bar, 259 | Baz(u8), 260 | Qux { quux: u8 }, 261 | Corge(u8, u8), 262 | } 263 | 264 | let bar = Foo::Bar; 265 | assert_eq!(to_value(&bar).unwrap(), Value::String("Bar".into())); 266 | 267 | let baz = Foo::Baz(1); 268 | assert_eq!( 269 | to_value(&baz).unwrap(), 270 | Value::Map( 271 | vec![(Value::String("Baz".into()), Value::U8(1))] 272 | .into_iter() 273 | .collect(), 274 | ) 275 | ); 276 | 277 | let qux = Foo::Qux { quux: 2 }; 278 | assert_eq!( 279 | to_value(&qux).unwrap(), 280 | Value::Map( 281 | vec![( 282 | Value::String("Qux".into()), 283 | Value::Map( 284 | vec![(Value::String("quux".into()), Value::U8(2))] 285 | .into_iter() 286 | .collect() 287 | ) 288 | )] 289 | .into_iter() 290 | .collect() 291 | ) 292 | ); 293 | 294 | let corge = Foo::Corge(3, 4); 295 | assert_eq!( 296 | to_value(&corge).unwrap(), 297 | Value::Map( 298 | vec![( 299 | Value::String("Corge".into()), 300 | Value::Seq(vec![Value::U8(3), Value::U8(4)]) 301 | )] 302 | .into_iter() 303 | .collect() 304 | ) 305 | ); 306 | } 307 | 308 | #[test] 309 | fn deserialize_inside_deserialize_impl() { 310 | #[derive(Debug, PartialEq, Eq)] 311 | enum Event { 312 | Added(u32), 313 | Error(u8), 314 | } 315 | 316 | impl<'de> serde::Deserialize<'de> for Event { 317 | fn deserialize(deserializer: D) -> Result where D: serde::Deserializer<'de> { 318 | #[derive(Deserialize)] 319 | struct RawEvent { 320 | kind: String, 321 | object: Value, 322 | } 323 | 324 | let raw_event = RawEvent::deserialize(deserializer)?; 325 | 326 | // Cannot directly use Value as Deserializer, since error type needs to be 327 | // generic D::Error rather than specific serde_value::DeserializerError 328 | let object_deserializer = ValueDeserializer::new(raw_event.object); 329 | 330 | Ok(match &*raw_event.kind { 331 | "ADDED" => Event::Added(<_>::deserialize(object_deserializer)?), 332 | "ERROR" => Event::Error(<_>::deserialize(object_deserializer)?), 333 | kind => return Err(serde::de::Error::unknown_variant(kind, &["ADDED", "ERROR"])), 334 | }) 335 | } 336 | } 337 | 338 | let input = Value::Map(vec![ 339 | (Value::String("kind".to_owned()), Value::String("ADDED".to_owned())), 340 | (Value::String("object".to_owned()), Value::U32(5)), 341 | ].into_iter().collect()); 342 | let event = Event::deserialize(input).expect("could not deserialize ADDED event"); 343 | assert_eq!(event, Event::Added(5)); 344 | 345 | let input = Value::Map(vec![ 346 | (Value::String("kind".to_owned()), Value::String("ERROR".to_owned())), 347 | (Value::String("object".to_owned()), Value::U8(5)), 348 | ].into_iter().collect()); 349 | let event = Event::deserialize(input).expect("could not deserialize ERROR event"); 350 | assert_eq!(event, Event::Error(5)); 351 | 352 | let input = Value::Map(vec![ 353 | (Value::String("kind".to_owned()), Value::String("ADDED".to_owned())), 354 | (Value::String("object".to_owned()), Value::Unit), 355 | ].into_iter().collect()); 356 | let _ = Event::deserialize(input).expect_err("expected deserializing bad ADDED event to fail"); 357 | } 358 | 359 | #[test] 360 | fn deserialize_newtype() { 361 | #[derive(Debug, Deserialize, PartialEq)] 362 | struct Foo(i32); 363 | 364 | let input = Value::I32(5); 365 | let foo = Foo::deserialize(input).unwrap(); 366 | assert_eq!(foo, Foo(5)); 367 | } 368 | 369 | #[test] 370 | fn deserialize_newtype2() { 371 | #[derive(Debug, Deserialize, PartialEq)] 372 | struct Foo(i32); 373 | 374 | #[derive(Debug, Deserialize, PartialEq)] 375 | struct Bar { 376 | foo: Foo, 377 | } 378 | 379 | let input = Value::Map(vec![ 380 | (Value::String("foo".to_owned()), Value::I32(5)) 381 | ].into_iter().collect()); 382 | let bar = Bar::deserialize(input).unwrap(); 383 | assert_eq!(bar, Bar { foo: Foo(5) }); 384 | } 385 | -------------------------------------------------------------------------------- /src/ser.rs: -------------------------------------------------------------------------------- 1 | use serde::ser; 2 | use std::collections::BTreeMap; 3 | use std::error::Error; 4 | use std::fmt; 5 | 6 | use crate::Value; 7 | 8 | #[derive(Debug)] 9 | pub enum SerializerError { 10 | Custom(String), 11 | } 12 | 13 | impl fmt::Display for SerializerError { 14 | fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { 15 | match *self { 16 | SerializerError::Custom(ref s) => fmt.write_str(s), 17 | } 18 | } 19 | } 20 | 21 | impl Error for SerializerError { 22 | fn description(&self) -> &str { 23 | "Value serializer error" 24 | } 25 | } 26 | 27 | impl ser::Error for SerializerError { 28 | fn custom(msg: T) -> SerializerError { 29 | SerializerError::Custom(msg.to_string()) 30 | } 31 | } 32 | 33 | impl ser::Serialize for Value { 34 | fn serialize(&self, s: S) -> Result { 35 | match *self { 36 | Value::Bool(v) => s.serialize_bool(v), 37 | Value::U8(v) => s.serialize_u8(v), 38 | Value::U16(v) => s.serialize_u16(v), 39 | Value::U32(v) => s.serialize_u32(v), 40 | Value::U64(v) => s.serialize_u64(v), 41 | Value::I8(v) => s.serialize_i8(v), 42 | Value::I16(v) => s.serialize_i16(v), 43 | Value::I32(v) => s.serialize_i32(v), 44 | Value::I64(v) => s.serialize_i64(v), 45 | Value::F32(v) => s.serialize_f32(v), 46 | Value::F64(v) => s.serialize_f64(v), 47 | Value::Char(v) => s.serialize_char(v), 48 | Value::String(ref v) => s.serialize_str(v), 49 | Value::Unit => s.serialize_unit(), 50 | Value::Option(None) => s.serialize_none(), 51 | Value::Option(Some(ref v)) => s.serialize_some(v), 52 | Value::Newtype(ref v) => s.serialize_newtype_struct("", v), 53 | Value::Seq(ref v) => v.serialize(s), 54 | Value::Map(ref v) => v.serialize(s), 55 | Value::Bytes(ref v) => s.serialize_bytes(v), 56 | } 57 | } 58 | } 59 | 60 | pub fn to_value(value: T) -> Result { 61 | value.serialize(Serializer) 62 | } 63 | 64 | struct Serializer; 65 | 66 | impl ser::Serializer for Serializer { 67 | type Ok = Value; 68 | type Error = SerializerError; 69 | type SerializeSeq = SerializeSeq; 70 | type SerializeTuple = SerializeTuple; 71 | type SerializeTupleStruct = SerializeTupleStruct; 72 | type SerializeTupleVariant = SerializeTupleVariant; 73 | type SerializeMap = SerializeMap; 74 | type SerializeStruct = SerializeStruct; 75 | type SerializeStructVariant = SerializeStructVariant; 76 | 77 | fn serialize_bool(self, v: bool) -> Result { 78 | Ok(Value::Bool(v)) 79 | } 80 | 81 | fn serialize_i8(self, v: i8) -> Result { 82 | Ok(Value::I8(v)) 83 | } 84 | 85 | fn serialize_i16(self, v: i16) -> Result { 86 | Ok(Value::I16(v)) 87 | } 88 | 89 | fn serialize_i32(self, v: i32) -> Result { 90 | Ok(Value::I32(v)) 91 | } 92 | 93 | fn serialize_i64(self, v: i64) -> Result { 94 | Ok(Value::I64(v)) 95 | } 96 | 97 | fn serialize_u8(self, v: u8) -> Result { 98 | Ok(Value::U8(v)) 99 | } 100 | 101 | fn serialize_u16(self, v: u16) -> Result { 102 | Ok(Value::U16(v)) 103 | } 104 | 105 | fn serialize_u32(self, v: u32) -> Result { 106 | Ok(Value::U32(v)) 107 | } 108 | 109 | fn serialize_u64(self, v: u64) -> Result { 110 | Ok(Value::U64(v)) 111 | } 112 | 113 | fn serialize_f32(self, v: f32) -> Result { 114 | Ok(Value::F32(v)) 115 | } 116 | 117 | fn serialize_f64(self, v: f64) -> Result { 118 | Ok(Value::F64(v)) 119 | } 120 | 121 | fn serialize_char(self, v: char) -> Result { 122 | Ok(Value::Char(v)) 123 | } 124 | 125 | fn serialize_str(self, v: &str) -> Result { 126 | Ok(Value::String(v.to_string())) 127 | } 128 | 129 | fn serialize_bytes(self, v: &[u8]) -> Result { 130 | Ok(Value::Bytes(v.to_vec())) 131 | } 132 | 133 | fn serialize_none(self) -> Result { 134 | Ok(Value::Option(None)) 135 | } 136 | 137 | fn serialize_some( 138 | self, 139 | value: &T 140 | ) -> Result 141 | where 142 | T: ser::Serialize 143 | { 144 | value.serialize(Serializer).map(|v| Value::Option(Some(Box::new(v)))) 145 | } 146 | 147 | fn serialize_unit(self) -> Result { 148 | Ok(Value::Unit) 149 | } 150 | 151 | fn serialize_unit_struct( 152 | self, 153 | _name: &'static str 154 | ) -> Result { 155 | Ok(Value::Unit) 156 | } 157 | 158 | fn serialize_unit_variant( 159 | self, 160 | _name: &'static str, 161 | _variant_index: u32, 162 | variant: &'static str, 163 | ) -> Result { 164 | Ok(Value::String(variant.to_string())) 165 | } 166 | 167 | fn serialize_newtype_struct( 168 | self, 169 | _name: &'static str, 170 | value: &T 171 | ) -> Result 172 | where 173 | T: ser::Serialize 174 | { 175 | value.serialize(Serializer).map(|v| Value::Newtype(Box::new(v))) 176 | } 177 | 178 | fn serialize_newtype_variant( 179 | self, 180 | _name: &'static str, 181 | _variant_index: u32, 182 | variant: &'static str, 183 | value: &T 184 | ) -> Result 185 | where 186 | T: ser::Serialize 187 | { 188 | value.serialize(Serializer).map(|v| { 189 | let mut map = BTreeMap::new(); 190 | map.insert(Value::String(variant.to_string()), v); 191 | Value::Map(map) 192 | }) 193 | } 194 | 195 | fn serialize_seq( 196 | self, 197 | _len: Option 198 | ) -> Result { 199 | Ok(SerializeSeq(vec![])) 200 | } 201 | 202 | fn serialize_tuple( 203 | self, 204 | _len: usize 205 | ) -> Result { 206 | Ok(SerializeTuple(vec![])) 207 | } 208 | 209 | fn serialize_tuple_struct( 210 | self, 211 | _name: &'static str, 212 | _len: usize 213 | ) -> Result { 214 | Ok(SerializeTupleStruct(vec![])) 215 | } 216 | 217 | fn serialize_tuple_variant( 218 | self, 219 | _name: &'static str, 220 | _variant_index: u32, 221 | variant: &'static str, 222 | len: usize 223 | ) -> Result { 224 | Ok(SerializeTupleVariant( 225 | Value::String(variant.to_string()), 226 | Vec::with_capacity(len), 227 | )) 228 | } 229 | 230 | fn serialize_map( 231 | self, 232 | _len: Option 233 | ) -> Result { 234 | Ok(SerializeMap { map: BTreeMap::new(), key: None }) 235 | } 236 | 237 | fn serialize_struct( 238 | self, 239 | _name: &'static str, 240 | _len: usize 241 | ) -> Result { 242 | Ok(SerializeStruct(BTreeMap::new())) 243 | } 244 | 245 | fn serialize_struct_variant( 246 | self, 247 | _name: &'static str, 248 | _variant_index: u32, 249 | variant: &'static str, 250 | _len: usize 251 | ) -> Result { 252 | Ok(SerializeStructVariant( 253 | Value::String(variant.to_string()), 254 | BTreeMap::new(), 255 | )) 256 | } 257 | } 258 | 259 | struct SerializeSeq(Vec); 260 | 261 | impl ser::SerializeSeq for SerializeSeq { 262 | type Ok = Value; 263 | type Error = SerializerError; 264 | 265 | fn serialize_element( 266 | &mut self, 267 | value: &T 268 | ) -> Result<(), Self::Error> 269 | where 270 | T: ser::Serialize 271 | { 272 | let value = value.serialize(Serializer)?; 273 | self.0.push(value); 274 | Ok(()) 275 | } 276 | 277 | fn end(self) -> Result { 278 | Ok(Value::Seq(self.0)) 279 | } 280 | } 281 | 282 | struct SerializeTuple(Vec); 283 | 284 | impl ser::SerializeTuple for SerializeTuple { 285 | type Ok = Value; 286 | type Error = SerializerError; 287 | 288 | fn serialize_element( 289 | &mut self, 290 | value: &T 291 | ) -> Result<(), Self::Error> 292 | where 293 | T: ser::Serialize 294 | { 295 | let value = value.serialize(Serializer)?; 296 | self.0.push(value); 297 | Ok(()) 298 | } 299 | 300 | fn end(self) -> Result { 301 | Ok(Value::Seq(self.0)) 302 | } 303 | } 304 | 305 | struct SerializeTupleStruct(Vec); 306 | 307 | impl ser::SerializeTupleStruct for SerializeTupleStruct { 308 | type Ok = Value; 309 | type Error = SerializerError; 310 | 311 | fn serialize_field( 312 | &mut self, 313 | value: &T 314 | ) -> Result<(), Self::Error> 315 | where 316 | T: ser::Serialize 317 | { 318 | let value = value.serialize(Serializer)?; 319 | self.0.push(value); 320 | Ok(()) 321 | } 322 | 323 | fn end(self) -> Result { 324 | Ok(Value::Seq(self.0)) 325 | } 326 | } 327 | 328 | struct SerializeTupleVariant(Value, Vec); 329 | 330 | impl ser::SerializeTupleVariant for SerializeTupleVariant { 331 | type Ok = Value; 332 | type Error = SerializerError; 333 | 334 | fn serialize_field( 335 | &mut self, 336 | value: &T 337 | ) -> Result<(), Self::Error> 338 | where 339 | T: ser::Serialize 340 | { 341 | let value = value.serialize(Serializer)?; 342 | self.1.push(value); 343 | Ok(()) 344 | } 345 | 346 | fn end(self) -> Result { 347 | let mut map = BTreeMap::new(); 348 | map.insert(self.0, Value::Seq(self.1)); 349 | Ok(Value::Map(map)) 350 | } 351 | } 352 | 353 | struct SerializeMap { 354 | map: BTreeMap, 355 | key: Option, 356 | } 357 | 358 | impl ser::SerializeMap for SerializeMap { 359 | type Ok = Value; 360 | type Error = SerializerError; 361 | 362 | fn serialize_key(&mut self, key: &T) -> Result<(), Self::Error> 363 | where 364 | T: ser::Serialize 365 | { 366 | let key = key.serialize(Serializer)?; 367 | self.key = Some(key); 368 | Ok(()) 369 | } 370 | 371 | fn serialize_value( 372 | &mut self, 373 | value: &T 374 | ) -> Result<(), Self::Error> 375 | where 376 | T: ser::Serialize 377 | { 378 | let value = value.serialize(Serializer)?; 379 | self.map.insert(self.key.take().unwrap(), value); 380 | Ok(()) 381 | } 382 | 383 | fn end(self) -> Result { 384 | Ok(Value::Map(self.map)) 385 | } 386 | } 387 | 388 | struct SerializeStruct(BTreeMap); 389 | 390 | impl ser::SerializeStruct for SerializeStruct { 391 | type Ok = Value; 392 | type Error = SerializerError; 393 | 394 | fn serialize_field( 395 | &mut self, 396 | key: &'static str, 397 | value: &T 398 | ) -> Result<(), Self::Error> 399 | where 400 | T: ser::Serialize 401 | { 402 | let key = Value::String(key.to_string()); 403 | let value = value.serialize(Serializer)?; 404 | self.0.insert(key, value); 405 | Ok(()) 406 | } 407 | 408 | fn end(self) -> Result { 409 | Ok(Value::Map(self.0)) 410 | } 411 | } 412 | 413 | struct SerializeStructVariant(Value, BTreeMap); 414 | 415 | impl ser::SerializeStructVariant for SerializeStructVariant { 416 | type Ok = Value; 417 | type Error = SerializerError; 418 | 419 | fn serialize_field( 420 | &mut self, 421 | key: &'static str, 422 | value: &T 423 | ) -> Result<(), Self::Error> 424 | where 425 | T: ser::Serialize 426 | { 427 | let key = Value::String(key.to_string()); 428 | let value = value.serialize(Serializer)?; 429 | self.1.insert(key, value); 430 | Ok(()) 431 | } 432 | 433 | fn end(self) -> Result { 434 | let mut map = BTreeMap::new(); 435 | map.insert(self.0, Value::Map(self.1)); 436 | Ok(Value::Map(map)) 437 | } 438 | } 439 | --------------------------------------------------------------------------------