| 1 | use crate::any::Any; |
| 2 | use crate::encoding::read::Error; |
| 3 | use serde::de::value::{MapAccessDeserializer, MapDeserializer, SeqDeserializer}; |
| 4 | use serde::de::{IntoDeserializer, MapAccess, SeqAccess, Visitor}; |
| 5 | use serde::{Deserialize, Deserializer}; |
| 6 | use std::any::type_name; |
| 7 | use std::collections::HashMap; |
| 8 | use std::convert::{TryFrom, TryInto}; |
| 9 | use std::fmt::{Display, Formatter}; |
| 10 | use std::sync::Arc; |
| 11 | |
| 12 | pub fn from_any<'de, T: Deserialize<'de>>(any: &'de Any) -> Result<T, Error> { |
| 13 | let deserializer = AnyDeserializer { value: any }; |
| 14 | T::deserialize(deserializer) |
| 15 | } |
| 16 | |
| 17 | impl<'de> Deserialize<'de> for Any { |
| 18 | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> |
| 19 | where |
| 20 | D: Deserializer<'de>, |
| 21 | { |
| 22 | struct AnyVisitor; |
| 23 | impl<'de> Visitor<'de> for AnyVisitor { |
| 24 | type Value = Any; |
| 25 | |
| 26 | fn expecting(&self, formatter: &mut Formatter) -> std::fmt::Result { |
| 27 | formatter.write_str("enum Any") |
| 28 | } |
| 29 | |
| 30 | fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E> |
| 31 | where |
| 32 | E: serde::de::Error, |
| 33 | { |
| 34 | Ok(Any::from(v)) |
| 35 | } |
| 36 | |
| 37 | fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> |
| 38 | where |
| 39 | E: serde::de::Error, |
| 40 | { |
| 41 | Ok(Any::Number(v as f64)) |
| 42 | } |
| 43 | |
| 44 | fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E> |
| 45 | where |
| 46 | E: serde::de::Error, |
| 47 | { |
| 48 | Ok(Any::from(v)) |
| 49 | } |
| 50 | |
| 51 | fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E> |
| 52 | where |
| 53 | E: serde::de::Error, |
| 54 | { |
| 55 | Ok(Any::from(v)) |
| 56 | } |
| 57 | |
| 58 | fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E> |
| 59 | where |
| 60 | E: serde::de::Error, |
| 61 | { |
| 62 | Ok(Any::from(v)) |
| 63 | } |
| 64 | |
| 65 | fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E> |
| 66 | where |
| 67 | E: serde::de::Error, |
| 68 | { |
| 69 | Ok(Any::Number(v as f64)) |
| 70 | } |
| 71 | |
| 72 | fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E> |
| 73 | where |
| 74 | E: serde::de::Error, |
| 75 | { |
| 76 | Ok(Any::from(v)) |
| 77 | } |
| 78 | |
| 79 | fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E> |
| 80 | where |
| 81 | E: serde::de::Error, |
| 82 | { |
| 83 | Ok(Any::from(v)) |
| 84 | } |
| 85 | |
| 86 | fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E> |
| 87 | where |
| 88 | E: serde::de::Error, |
| 89 | { |
| 90 | match Any::try_from(v) { |
| 91 | Ok(any) => Ok(any), |
| 92 | Err(v) => Err(serde::de::Error::custom(format!( |
| 93 | "Value {} out of range for i64", |
| 94 | v |
| 95 | ))), |
| 96 | } |
| 97 | } |
| 98 | |
| 99 | fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E> |
| 100 | where |
| 101 | E: serde::de::Error, |
| 102 | { |
| 103 | Ok(Any::from(v)) |
| 104 | } |
| 105 | |
| 106 | fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E> |
| 107 | where |
| 108 | E: serde::de::Error, |
| 109 | { |
| 110 | Ok(Any::from(v)) |
| 111 | } |
| 112 | |
| 113 | fn visit_char<E>(self, v: char) -> Result<Self::Value, E> |
| 114 | where |
| 115 | E: serde::de::Error, |
| 116 | { |
| 117 | Ok(Any::from(v.to_string())) |
| 118 | } |
| 119 | |
| 120 | fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> |
| 121 | where |
| 122 | E: serde::de::Error, |
| 123 | { |
| 124 | Ok(Any::from(v)) |
| 125 | } |
| 126 | |
| 127 | fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E> |
| 128 | where |
| 129 | E: serde::de::Error, |
| 130 | { |
| 131 | Ok(Any::from(v)) |
| 132 | } |
| 133 | |
| 134 | fn visit_string<E>(self, v: String) -> Result<Self::Value, E> |
| 135 | where |
| 136 | E: serde::de::Error, |
| 137 | { |
| 138 | Ok(Any::from(v)) |
| 139 | } |
| 140 | |
| 141 | fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E> |
| 142 | where |
| 143 | E: serde::de::Error, |
| 144 | { |
| 145 | Ok(Any::from(v)) |
| 146 | } |
| 147 | |
| 148 | fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E> |
| 149 | where |
| 150 | E: serde::de::Error, |
| 151 | { |
| 152 | Ok(Any::from(v)) |
| 153 | } |
| 154 | |
| 155 | fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E> |
| 156 | where |
| 157 | E: serde::de::Error, |
| 158 | { |
| 159 | Ok(Any::from(v)) |
| 160 | } |
| 161 | |
| 162 | fn visit_none<E>(self) -> Result<Self::Value, E> |
| 163 | where |
| 164 | E: serde::de::Error, |
| 165 | { |
| 166 | Ok(Any::Null) |
| 167 | } |
| 168 | |
| 169 | fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error> |
| 170 | where |
| 171 | D: Deserializer<'de>, |
| 172 | { |
| 173 | Any::deserialize(deserializer) |
| 174 | } |
| 175 | |
| 176 | fn visit_unit<E>(self) -> Result<Self::Value, E> |
| 177 | where |
| 178 | E: serde::de::Error, |
| 179 | { |
| 180 | Ok(Any::Null) |
| 181 | } |
| 182 | |
| 183 | fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error> |
| 184 | where |
| 185 | A: SeqAccess<'de>, |
| 186 | { |
| 187 | let mut vec = Vec::new(); |
| 188 | |
| 189 | while let Some(value) = seq.next_element()? { |
| 190 | vec.push(value); |
| 191 | } |
| 192 | |
| 193 | Ok(Any::Array(vec.into())) |
| 194 | } |
| 195 | |
| 196 | fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> |
| 197 | where |
| 198 | A: MapAccess<'de>, |
| 199 | { |
| 200 | let mut any_map = HashMap::new(); |
| 201 | while let Some((key, value)) = map.next_entry()? { |
| 202 | any_map.insert(key, value); |
| 203 | } |
| 204 | |
| 205 | Ok(Any::Map(Arc::new(any_map))) |
| 206 | } |
| 207 | } |
| 208 | |
| 209 | deserializer.deserialize_any(AnyVisitor) |
| 210 | } |
| 211 | } |
| 212 | |
| 213 | pub struct AnyDeserializer<'a> { |
| 214 | value: &'a Any, |
| 215 | } |
| 216 | |
| 217 | impl<'de, 'a: 'de> IntoDeserializer<'de, Error> for &'a Any { |
| 218 | type Deserializer = AnyDeserializer<'de>; |
| 219 | |
| 220 | fn into_deserializer(self) -> Self::Deserializer { |
| 221 | AnyDeserializer { value: self } |
| 222 | } |
| 223 | } |
| 224 | |
| 225 | impl serde::de::Error for Error { |
| 226 | fn custom<T>(msg: T) -> Self |
| 227 | where |
| 228 | T: Display, |
| 229 | { |
| 230 | Error::Custom(msg.to_string()) |
| 231 | } |
| 232 | } |
| 233 | |
| 234 | impl<'de> Deserializer<'de> for AnyDeserializer<'de> { |
| 235 | type Error = Error; |
| 236 | |
| 237 | fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| 238 | where |
| 239 | V: Visitor<'de>, |
| 240 | { |
| 241 | match self.value { |
| 242 | Any::Null => self.deserialize_unit(visitor), |
| 243 | Any::Undefined => self.deserialize_unit(visitor), |
| 244 | Any::Bool(_) => self.deserialize_bool(visitor), |
| 245 | Any::Number(_) => self.deserialize_f64(visitor), |
| 246 | Any::BigInt(_) => self.deserialize_i64(visitor), |
| 247 | Any::String(_) => self.deserialize_string(visitor), |
| 248 | Any::Buffer(_) => self.deserialize_byte_buf(visitor), |
| 249 | Any::Array(_) => self.deserialize_seq(visitor), |
| 250 | Any::Map(_) => self.deserialize_map(visitor), |
| 251 | } |
| 252 | } |
| 253 | |
| 254 | fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| 255 | where |
| 256 | V: Visitor<'de>, |
| 257 | { |
| 258 | match self.value { |
| 259 | Any::Bool(b) => visitor.visit_bool(*b), |
| 260 | _ => Err(Error::TypeMismatch(type_name::<bool>())), |
| 261 | } |
| 262 | } |
| 263 | |
| 264 | fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| 265 | where |
| 266 | V: Visitor<'de>, |
| 267 | { |
| 268 | let value = match self.value { |
| 269 | Any::Number(i) => { |
| 270 | if i.fract() == 0.0 { |
| 271 | *i as i64 |
| 272 | } else { |
| 273 | return Err(Error::type_mismatch::<i8>()); |
| 274 | } |
| 275 | } |
| 276 | Any::BigInt(i) => *i, |
| 277 | _ => return Err(Error::type_mismatch::<i8>()), |
| 278 | } |
| 279 | .try_into() |
| 280 | .map_err(|_| Error::UnexpectedValue)?; |
| 281 | visitor.visit_i8(value) |
| 282 | } |
| 283 | |
| 284 | fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| 285 | where |
| 286 | V: Visitor<'de>, |
| 287 | { |
| 288 | let value = match self.value { |
| 289 | Any::Number(i) => { |
| 290 | if i.fract() == 0.0 { |
| 291 | *i as i64 |
| 292 | } else { |
| 293 | return Err(Error::type_mismatch::<i16>()); |
| 294 | } |
| 295 | } |
| 296 | Any::BigInt(i) => *i, |
| 297 | _ => return Err(Error::type_mismatch::<i16>()), |
| 298 | } |
| 299 | .try_into() |
| 300 | .map_err(|_| Error::UnexpectedValue)?; |
| 301 | visitor.visit_i16(value) |
| 302 | } |
| 303 | |
| 304 | fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| 305 | where |
| 306 | V: Visitor<'de>, |
| 307 | { |
| 308 | let value = match self.value { |
| 309 | Any::Number(i) => { |
| 310 | if i.fract() == 0.0 { |
| 311 | *i as i64 |
| 312 | } else { |
| 313 | return Err(Error::type_mismatch::<i32>()); |
| 314 | } |
| 315 | } |
| 316 | Any::BigInt(i) => *i, |
| 317 | _ => return Err(Error::type_mismatch::<i32>()), |
| 318 | } |
| 319 | .try_into() |
| 320 | .map_err(|_| Error::UnexpectedValue)?; |
| 321 | visitor.visit_i32(value) |
| 322 | } |
| 323 | |
| 324 | fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| 325 | where |
| 326 | V: Visitor<'de>, |
| 327 | { |
| 328 | let value = match self.value { |
| 329 | Any::Number(i) => { |
| 330 | if i.fract() == 0.0 { |
| 331 | *i as i64 |
| 332 | } else { |
| 333 | return Err(Error::type_mismatch::<i64>()); |
| 334 | } |
| 335 | } |
| 336 | Any::BigInt(i) => *i, |
| 337 | _ => return Err(Error::type_mismatch::<i64>()), |
| 338 | }; |
| 339 | visitor.visit_i64(value) |
| 340 | } |
| 341 | |
| 342 | fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| 343 | where |
| 344 | V: Visitor<'de>, |
| 345 | { |
| 346 | let value = match self.value { |
| 347 | Any::Number(i) => { |
| 348 | if i.fract() == 0.0 { |
| 349 | *i as i64 |
| 350 | } else { |
| 351 | return Err(Error::type_mismatch::<u8>()); |
| 352 | } |
| 353 | } |
| 354 | Any::BigInt(i) => *i, |
| 355 | _ => return Err(Error::type_mismatch::<u8>()), |
| 356 | } |
| 357 | .try_into() |
| 358 | .map_err(|_| Error::UnexpectedValue)?; |
| 359 | visitor.visit_u8(value) |
| 360 | } |
| 361 | |
| 362 | fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| 363 | where |
| 364 | V: Visitor<'de>, |
| 365 | { |
| 366 | let value = match self.value { |
| 367 | Any::Number(i) => { |
| 368 | if i.fract() == 0.0 { |
| 369 | *i as i64 |
| 370 | } else { |
| 371 | return Err(Error::type_mismatch::<u16>()); |
| 372 | } |
| 373 | } |
| 374 | Any::BigInt(i) => *i, |
| 375 | _ => return Err(Error::type_mismatch::<u16>()), |
| 376 | } |
| 377 | .try_into() |
| 378 | .map_err(|_| Error::UnexpectedValue)?; |
| 379 | visitor.visit_u16(value) |
| 380 | } |
| 381 | |
| 382 | fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| 383 | where |
| 384 | V: Visitor<'de>, |
| 385 | { |
| 386 | let value = match self.value { |
| 387 | Any::Number(i) => { |
| 388 | if i.fract() == 0.0 { |
| 389 | *i as i64 |
| 390 | } else { |
| 391 | return Err(Error::type_mismatch::<u32>()); |
| 392 | } |
| 393 | } |
| 394 | Any::BigInt(i) => *i, |
| 395 | _ => return Err(Error::type_mismatch::<u32>()), |
| 396 | } |
| 397 | .try_into() |
| 398 | .map_err(|_| Error::UnexpectedValue)?; |
| 399 | visitor.visit_u32(value) |
| 400 | } |
| 401 | |
| 402 | fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| 403 | where |
| 404 | V: Visitor<'de>, |
| 405 | { |
| 406 | let value = match self.value { |
| 407 | Any::Number(i) => { |
| 408 | if i.fract() == 0.0 { |
| 409 | *i as i64 |
| 410 | } else { |
| 411 | return Err(Error::type_mismatch::<u64>()); |
| 412 | } |
| 413 | } |
| 414 | Any::BigInt(i) => *i, |
| 415 | _ => return Err(Error::type_mismatch::<u64>()), |
| 416 | } |
| 417 | .try_into() |
| 418 | .map_err(|_| Error::UnexpectedValue)?; |
| 419 | visitor.visit_u64(value) |
| 420 | } |
| 421 | |
| 422 | fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| 423 | where |
| 424 | V: Visitor<'de>, |
| 425 | { |
| 426 | match self.value { |
| 427 | Any::Number(f) => visitor.visit_f32(*f as f32), |
| 428 | Any::BigInt(f) => visitor.visit_f32(*f as f32), |
| 429 | _ => Err(Error::type_mismatch::<f32>()), |
| 430 | } |
| 431 | } |
| 432 | |
| 433 | fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| 434 | where |
| 435 | V: Visitor<'de>, |
| 436 | { |
| 437 | match self.value { |
| 438 | Any::Number(f) => visitor.visit_f64(*f), |
| 439 | Any::BigInt(f) => visitor.visit_f64(*f as f64), |
| 440 | _ => Err(Error::type_mismatch::<f64>()), |
| 441 | } |
| 442 | } |
| 443 | |
| 444 | fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| 445 | where |
| 446 | V: Visitor<'de>, |
| 447 | { |
| 448 | match self.value { |
| 449 | Any::String(s) => { |
| 450 | let mut chars = s.chars(); |
| 451 | // Match on first two characters |
| 452 | match (chars.next(), chars.next()) { |
| 453 | (Some(c), None) => visitor.visit_char(c), |
| 454 | _ => Err(Error::type_mismatch::<char>()), |
| 455 | } |
| 456 | } |
| 457 | _ => Err(Error::type_mismatch::<char>()), |
| 458 | } |
| 459 | } |
| 460 | |
| 461 | fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| 462 | where |
| 463 | V: Visitor<'de>, |
| 464 | { |
| 465 | match self.value { |
| 466 | Any::String(s) => visitor.visit_borrowed_str(s), |
| 467 | _ => Err(Error::type_mismatch::<&str>()), |
| 468 | } |
| 469 | } |
| 470 | |
| 471 | fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| 472 | where |
| 473 | V: Visitor<'de>, |
| 474 | { |
| 475 | match self.value { |
| 476 | Any::String(s) => visitor.visit_string(s.to_string()), |
| 477 | _ => Err(Error::type_mismatch::<String>()), |
| 478 | } |
| 479 | } |
| 480 | |
| 481 | fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| 482 | where |
| 483 | V: Visitor<'de>, |
| 484 | { |
| 485 | match self.value { |
| 486 | Any::Buffer(b) => visitor.visit_borrowed_bytes(b), |
| 487 | _ => Err(Error::type_mismatch::<&[u8]>()), |
| 488 | } |
| 489 | } |
| 490 | |
| 491 | fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| 492 | where |
| 493 | V: Visitor<'de>, |
| 494 | { |
| 495 | match self.value { |
| 496 | Any::Buffer(b) => visitor.visit_bytes(b), |
| 497 | _ => Err(Error::type_mismatch::<Vec<u8>>()), |
| 498 | } |
| 499 | } |
| 500 | |
| 501 | fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| 502 | where |
| 503 | V: Visitor<'de>, |
| 504 | { |
| 505 | match self.value { |
| 506 | Any::Null | Any::Undefined => visitor.visit_none(), |
| 507 | _ => visitor.visit_some(self), |
| 508 | } |
| 509 | } |
| 510 | |
| 511 | fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| 512 | where |
| 513 | V: Visitor<'de>, |
| 514 | { |
| 515 | match self.value { |
| 516 | Any::Null | Any::Undefined => visitor.visit_unit(), |
| 517 | _ => Err(Error::type_mismatch::<()>()), |
| 518 | } |
| 519 | } |
| 520 | |
| 521 | fn deserialize_unit_struct<V>( |
| 522 | self, |
| 523 | _name: &'static str, |
| 524 | visitor: V, |
| 525 | ) -> Result<V::Value, Self::Error> |
| 526 | where |
| 527 | V: Visitor<'de>, |
| 528 | { |
| 529 | self.deserialize_unit(visitor) |
| 530 | } |
| 531 | |
| 532 | fn deserialize_newtype_struct<V>( |
| 533 | self, |
| 534 | _name: &'static str, |
| 535 | visitor: V, |
| 536 | ) -> Result<V::Value, Self::Error> |
| 537 | where |
| 538 | V: Visitor<'de>, |
| 539 | { |
| 540 | visitor.visit_newtype_struct(self) |
| 541 | } |
| 542 | |
| 543 | fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| 544 | where |
| 545 | V: Visitor<'de>, |
| 546 | { |
| 547 | match self.value { |
| 548 | Any::Array(a) => visitor.visit_seq(SeqDeserializer::new(a.iter())), |
| 549 | _ => visitor.visit_some(self), |
| 550 | } |
| 551 | } |
| 552 | |
| 553 | fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error> |
| 554 | where |
| 555 | V: Visitor<'de>, |
| 556 | { |
| 557 | self.deserialize_seq(visitor) |
| 558 | } |
| 559 | |
| 560 | fn deserialize_tuple_struct<V>( |
| 561 | self, |
| 562 | _name: &'static str, |
| 563 | _len: usize, |
| 564 | visitor: V, |
| 565 | ) -> Result<V::Value, Self::Error> |
| 566 | where |
| 567 | V: Visitor<'de>, |
| 568 | { |
| 569 | self.deserialize_seq(visitor) |
| 570 | } |
| 571 | |
| 572 | fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| 573 | where |
| 574 | V: Visitor<'de>, |
| 575 | { |
| 576 | match self.value { |
| 577 | Any::Map(m) => visitor.visit_map(MapDeserializer::new( |
| 578 | m.iter().map(|(key, value)| (key.as_str(), value)), |
| 579 | )), |
| 580 | _ => Err(Error::type_mismatch::<V::Value>()), |
| 581 | } |
| 582 | } |
| 583 | |
| 584 | fn deserialize_struct<V>( |
| 585 | self, |
| 586 | _name: &'static str, |
| 587 | _fields: &'static [&'static str], |
| 588 | visitor: V, |
| 589 | ) -> Result<V::Value, Self::Error> |
| 590 | where |
| 591 | V: Visitor<'de>, |
| 592 | { |
| 593 | self.deserialize_map(visitor) |
| 594 | } |
| 595 | |
| 596 | fn deserialize_enum<V>( |
| 597 | self, |
| 598 | _name: &'static str, |
| 599 | _variants: &'static [&'static str], |
| 600 | visitor: V, |
| 601 | ) -> Result<V::Value, Self::Error> |
| 602 | where |
| 603 | V: Visitor<'de>, |
| 604 | { |
| 605 | match self.value { |
| 606 | Any::String(s) => visitor.visit_enum(s.into_deserializer()), |
| 607 | Any::Map(m) => visitor.visit_enum(MapAccessDeserializer::new(MapDeserializer::new( |
| 608 | m.iter().map(|(key, value)| (key.as_str(), value)), |
| 609 | ))), |
| 610 | _ => Err(Error::type_mismatch::<V::Value>()), |
| 611 | } |
| 612 | } |
| 613 | |
| 614 | fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| 615 | where |
| 616 | V: Visitor<'de>, |
| 617 | { |
| 618 | self.deserialize_str(visitor) |
| 619 | } |
| 620 | |
| 621 | fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> |
| 622 | where |
| 623 | V: Visitor<'de>, |
| 624 | { |
| 625 | self.deserialize_any(visitor) |
| 626 | } |
| 627 | } |
| 628 | |
| 629 | #[cfg(test)] |
| 630 | mod test { |
| 631 | use super::*; |
| 632 | use crate::any::Any; |
| 633 | use serde::Deserialize; |
| 634 | use std::collections::HashMap; |
| 635 | |
| 636 | #[test] |
| 637 | fn test_deserialize_any_from_bool() { |
| 638 | assert_eq!( |
| 639 | serde_json::from_str::<Any>("true").unwrap(), |
| 640 | Any::from(true) |
| 641 | ); |
| 642 | } |
| 643 | |
| 644 | #[test] |
| 645 | fn test_deserialize_any_from_float() { |
| 646 | assert_eq!( |
| 647 | serde_json::from_str::<Any>("18.812036").unwrap(), |
| 648 | Any::from(18.812036f64) |
| 649 | ); |
| 650 | } |
| 651 | |
| 652 | #[test] |
| 653 | fn test_deserialize_any_from_int() { |
| 654 | assert_eq!(serde_json::from_str::<Any>("18").unwrap(), Any::from(18)); |
| 655 | } |
| 656 | |
| 657 | #[test] |
| 658 | fn test_deserialize_any_from_int_unrepresentable() { |
| 659 | assert!(serde_json::from_str::<Any>(&u64::MAX.to_string()).is_err()); |
| 660 | } |
| 661 | |
| 662 | #[test] |
| 663 | fn test_deserialize_any_from_string() { |
| 664 | assert_eq!( |
| 665 | serde_json::from_str::<Any>("\"string\"").unwrap(), |
| 666 | Any::from("string") |
| 667 | ); |
| 668 | } |
| 669 | |
| 670 | #[test] |
| 671 | fn test_deserialize_any_from_null() { |
| 672 | assert_eq!(serde_json::from_str::<Any>("null").unwrap(), Any::Null); |
| 673 | } |
| 674 | |
| 675 | #[test] |
| 676 | fn test_deserialize_any_from_array() { |
| 677 | assert_eq!( |
| 678 | serde_json::from_str::<Any>("[true, -101]").unwrap(), |
| 679 | Any::from(vec![Any::from(true), Any::from(-101)]) |
| 680 | ); |
| 681 | } |
| 682 | |
| 683 | #[test] |
| 684 | fn test_deserialize_any_from_map() { |
| 685 | assert_eq!( |
| 686 | serde_json::from_str::<Any>("{\"key1\":true,\"key2\":-12307.2138}").unwrap(), |
| 687 | Any::from(HashMap::from([ |
| 688 | ("key1".into(), Any::from(true)), |
| 689 | ("key2".into(), Any::from(-12307.2138f64)) |
| 690 | ])) |
| 691 | ); |
| 692 | } |
| 693 | |
| 694 | #[test] |
| 695 | fn test_deserialize_any_from_nested_map() { |
| 696 | assert_eq!( |
| 697 | serde_json::from_str::<Any>("{\"key1\":true,\"key2\":1.1,\"key3\":{\"key4\":true,\"key5\":1},\"key6\":[true,1,null]}").unwrap(), |
| 698 | Any::from(HashMap::from([ |
| 699 | ("key1".into(), Any::from(true)), |
| 700 | ("key2".into(), Any::from(1.1f64)), |
| 701 | ("key3".into(), Any::from( |
| 702 | HashMap::from([ |
| 703 | ("key4".into(), Any::from(true)), |
| 704 | ("key5".into(), Any::from(1)) |
| 705 | ]) |
| 706 | )), |
| 707 | ("key6".into(), Any::from(vec![Any::from(true), Any::from(1), Any::Null])) |
| 708 | ]) |
| 709 | ) |
| 710 | ); |
| 711 | } |
| 712 | |
| 713 | #[test] |
| 714 | fn test_any_deserializer_many_fields() { |
| 715 | #[derive(Debug, Deserialize, PartialEq)] |
| 716 | struct Test { |
| 717 | bool: bool, |
| 718 | int: i64, |
| 719 | negative_int: i64, |
| 720 | max_int: i64, |
| 721 | min_int: i64, |
| 722 | real_number: f64, |
| 723 | max_number: f64, |
| 724 | min_number: f64, |
| 725 | null: Option<bool>, |
| 726 | some: Option<bool>, |
| 727 | undefined: Option<bool>, |
| 728 | nested: Nested, |
| 729 | enum_a: StringEnum, |
| 730 | enum_b: StringEnum, |
| 731 | } |
| 732 | |
| 733 | #[derive(Debug, Deserialize, PartialEq)] |
| 734 | struct Nested { |
| 735 | int: i16, |
| 736 | other: f32, |
| 737 | } |
| 738 | |
| 739 | #[derive(Debug, Deserialize, PartialEq)] |
| 740 | enum StringEnum { |
| 741 | VariantA, |
| 742 | VariantB, |
| 743 | } |
| 744 | |
| 745 | let any = Any::from(HashMap::from([ |
| 746 | ("bool".to_string(), Any::from(true)), |
| 747 | ("int".to_string(), Any::from(1)), |
| 748 | ("negative_int".to_string(), Any::from(-1)), |
| 749 | ("max_int".to_string(), Any::from(i64::MAX)), |
| 750 | ("min_int".to_string(), Any::from(i64::MIN)), |
| 751 | ("real_number".to_string(), Any::from(-123.2387f64)), |
| 752 | ("max_number".to_string(), Any::from(f64::MIN)), |
| 753 | ("min_number".to_string(), Any::from(f64::MAX)), |
| 754 | ("null".to_string(), Any::Null), |
| 755 | ("some".to_string(), Any::from(false)), |
| 756 | ("undefined".to_string(), Any::Undefined), |
| 757 | ( |
| 758 | "nested".to_string(), |
| 759 | Any::from(HashMap::from([ |
| 760 | ("int".to_string(), Any::from(100)), |
| 761 | ("other".to_string(), Any::from(100.0)), |
| 762 | ])), |
| 763 | ), |
| 764 | ("enum_a".to_string(), "VariantA".into()), |
| 765 | ("enum_b".to_string(), "VariantB".into()), |
| 766 | ])); |
| 767 | |
| 768 | assert_eq!( |
| 769 | Test { |
| 770 | bool: true, |
| 771 | int: 1, |
| 772 | negative_int: -1, |
| 773 | max_int: i64::MAX, |
| 774 | min_int: i64::MIN, |
| 775 | real_number: -123.2387f64, |
| 776 | max_number: f64::MIN, |
| 777 | min_number: f64::MAX, |
| 778 | null: None, |
| 779 | some: Some(false), |
| 780 | undefined: None, |
| 781 | nested: Nested { |
| 782 | int: 100, |
| 783 | other: 100.0 |
| 784 | }, |
| 785 | enum_a: StringEnum::VariantA, |
| 786 | enum_b: StringEnum::VariantB |
| 787 | }, |
| 788 | from_any(&any).unwrap() |
| 789 | ) |
| 790 | } |
| 791 | |
| 792 | #[test] |
| 793 | fn test_deserialize_any_to_any() { |
| 794 | let any = Any::from(HashMap::from([ |
| 795 | ("bool".to_string(), Any::from(true)), |
| 796 | ("int".to_string(), Any::from(1)), |
| 797 | ("negative_int".to_string(), Any::from(-1)), |
| 798 | ("max_int".to_string(), Any::from(i64::MAX)), |
| 799 | ("min_int".to_string(), Any::from(i64::MIN)), |
| 800 | ("real_number".to_string(), Any::from(-123.2387f64)), |
| 801 | ("max_number".to_string(), Any::from(f64::MIN)), |
| 802 | ("min_number".to_string(), Any::from(f64::MAX)), |
| 803 | ("null".to_string(), Any::Null), |
| 804 | ("some".to_string(), Any::from(false)), |
| 805 | ( |
| 806 | "nested".to_string(), |
| 807 | Any::from(HashMap::from([ |
| 808 | ("int".to_string(), Any::from(1i64 << 54)), |
| 809 | ("other".to_string(), Any::from(100.0)), |
| 810 | ])), |
| 811 | ), |
| 812 | ("enum_a".to_string(), "VariantA".into()), |
| 813 | ("enum_b".to_string(), "VariantB".into()), |
| 814 | ])); |
| 815 | |
| 816 | assert_eq!(any, from_any(&any.clone()).unwrap()) |
| 817 | } |
| 818 | |
| 819 | #[test] |
| 820 | fn test_any_deserializer_multiple_borrows() { |
| 821 | #[derive(Debug, Deserialize, PartialEq)] |
| 822 | struct Test<'a> { |
| 823 | str: &'a str, |
| 824 | bytes: &'a [u8], |
| 825 | } |
| 826 | |
| 827 | let any = Any::from(HashMap::from([ |
| 828 | ("str".to_string(), Any::from("String")), |
| 829 | ("bytes".to_string(), b"Bytes".to_vec().into()), |
| 830 | ])); |
| 831 | |
| 832 | assert_eq!( |
| 833 | Test { |
| 834 | str: "String", |
| 835 | bytes: b"Bytes" |
| 836 | }, |
| 837 | from_any(&any).unwrap() |
| 838 | ) |
| 839 | } |
| 840 | |
| 841 | #[test] |
| 842 | fn test_any_deserializer_nested_array() { |
| 843 | #[derive(Debug, Deserialize, PartialEq)] |
| 844 | struct Test { |
| 845 | array: Vec<Vec<bool>>, |
| 846 | } |
| 847 | |
| 848 | let any: Any = HashMap::from([( |
| 849 | "array".to_string(), |
| 850 | Any::from(vec![ |
| 851 | Any::from(vec![Any::Bool(true), Any::Bool(false)]), |
| 852 | Any::from(vec![Any::Bool(true)]), |
| 853 | ]), |
| 854 | )]) |
| 855 | .into(); |
| 856 | |
| 857 | assert_eq!( |
| 858 | Test { |
| 859 | array: vec![vec![true, false], vec![true]] |
| 860 | }, |
| 861 | from_any(&any).unwrap() |
| 862 | ) |
| 863 | } |
| 864 | |
| 865 | #[test] |
| 866 | fn test_any_deserializer_undefined() { |
| 867 | #[derive(Debug, Deserialize, PartialEq)] |
| 868 | struct Test { |
| 869 | undefined: Option<bool>, |
| 870 | } |
| 871 | |
| 872 | let any: Any = HashMap::from([("undefined".to_string(), Any::Undefined)]).into(); |
| 873 | |
| 874 | assert_eq!(Test { undefined: None }, from_any(&any).unwrap()) |
| 875 | } |
| 876 | |
| 877 | #[test] |
| 878 | fn test_any_deserializer_int_does_not_fit_error() { |
| 879 | #[derive(Debug, Deserialize, PartialEq)] |
| 880 | struct Test { |
| 881 | test: i8, |
| 882 | } |
| 883 | |
| 884 | let any: Any = HashMap::from([("test".to_string(), Any::BigInt(1000))]).into(); |
| 885 | |
| 886 | assert!(matches!( |
| 887 | from_any::<Test>(&any).unwrap_err(), |
| 888 | Error::UnexpectedValue, |
| 889 | )) |
| 890 | } |
| 891 | |
| 892 | #[test] |
| 893 | fn test_any_deserializer_type_mismatch_error() { |
| 894 | #[derive(Debug, Deserialize, PartialEq)] |
| 895 | struct Test { |
| 896 | test: i8, |
| 897 | } |
| 898 | |
| 899 | let any: Any = HashMap::from([("test".to_string(), Any::Number(1000.1f64))]).into(); |
| 900 | |
| 901 | let error = from_any::<Test>(&any).unwrap_err(); |
| 902 | match error { |
| 903 | Error::TypeMismatch("i8") => { /* ok */ } |
| 904 | other => panic!("unexpected error {}", other), |
| 905 | } |
| 906 | } |
| 907 | } |
| 908 | |
amadan