1 use std::fmt::Display; 2 use std::fmt::Write as _; 3 4 use serde::ser; 5 6 use crate::error::{ConfigError, Result}; 7 use crate::value::{Value, ValueKind}; 8 use crate::Config; 9 10 #[derive(Default, Debug)] 11 pub struct ConfigSerializer { 12 keys: Vec<SerKey>, 13 pub output: Config, 14 } 15 16 #[derive(Debug)] 17 enum SerKey { 18 Named(String), 19 Seq(usize), 20 } 21 22 /// Serializer for numbered sequences 23 /// 24 /// This wrapper is present when we are outputting a sequence (numbered indices). 25 /// Making this a separate type centralises the handling of sequences 26 /// and ensures we don't have any call sites for `ser::SerializeSeq::serialize_element` 27 /// that don't do the necessary work of `SeqSerializer::new`. 28 /// 29 /// Existence of this wrapper implies that `.0.keys.last()` is 30 /// `Some(SerKey::Seq(next_index))`. 31 pub struct SeqSerializer<'a>(&'a mut ConfigSerializer); 32 33 impl ConfigSerializer { serialize_primitive<T>(&mut self, value: T) -> Result<()> where T: Into<Value> + Display,34 fn serialize_primitive<T>(&mut self, value: T) -> Result<()> 35 where 36 T: Into<Value> + Display, 37 { 38 // At some future point we could perhaps retain a cursor into the output `Config`, 39 // rather than reifying the whole thing into a single string with `make_full_key` 40 // and passing that whole path to the `set` method. 41 // 42 // That would be marginally more performant, but more fiddly. 43 let key = self.make_full_key()?; 44 45 #[allow(deprecated)] 46 self.output.set(&key, value.into())?; 47 Ok(()) 48 } 49 make_full_key(&self) -> Result<String>50 fn make_full_key(&self) -> Result<String> { 51 let mut keys = self.keys.iter(); 52 53 let mut whole = match keys.next() { 54 Some(SerKey::Named(s)) => s.clone(), 55 _ => { 56 return Err(ConfigError::Message( 57 "top level is not a struct".to_string(), 58 )) 59 } 60 }; 61 62 for k in keys { 63 match k { 64 SerKey::Named(s) => write!(whole, ".{}", s), 65 SerKey::Seq(i) => write!(whole, "[{}]", i), 66 } 67 .expect("write! to a string failed"); 68 } 69 70 Ok(whole) 71 } 72 push_key(&mut self, key: &str)73 fn push_key(&mut self, key: &str) { 74 self.keys.push(SerKey::Named(key.to_string())); 75 } 76 pop_key(&mut self)77 fn pop_key(&mut self) { 78 self.keys.pop(); 79 } 80 } 81 82 impl<'a> ser::Serializer for &'a mut ConfigSerializer { 83 type Ok = (); 84 type Error = ConfigError; 85 type SerializeSeq = SeqSerializer<'a>; 86 type SerializeTuple = SeqSerializer<'a>; 87 type SerializeTupleStruct = SeqSerializer<'a>; 88 type SerializeTupleVariant = SeqSerializer<'a>; 89 type SerializeMap = Self; 90 type SerializeStruct = Self; 91 type SerializeStructVariant = Self; 92 serialize_bool(self, v: bool) -> Result<Self::Ok>93 fn serialize_bool(self, v: bool) -> Result<Self::Ok> { 94 self.serialize_primitive(v) 95 } 96 serialize_i8(self, v: i8) -> Result<Self::Ok>97 fn serialize_i8(self, v: i8) -> Result<Self::Ok> { 98 self.serialize_i64(v.into()) 99 } 100 serialize_i16(self, v: i16) -> Result<Self::Ok>101 fn serialize_i16(self, v: i16) -> Result<Self::Ok> { 102 self.serialize_i64(v.into()) 103 } 104 serialize_i32(self, v: i32) -> Result<Self::Ok>105 fn serialize_i32(self, v: i32) -> Result<Self::Ok> { 106 self.serialize_i64(v.into()) 107 } 108 serialize_i64(self, v: i64) -> Result<Self::Ok>109 fn serialize_i64(self, v: i64) -> Result<Self::Ok> { 110 self.serialize_primitive(v) 111 } 112 serialize_u8(self, v: u8) -> Result<Self::Ok>113 fn serialize_u8(self, v: u8) -> Result<Self::Ok> { 114 self.serialize_u64(v.into()) 115 } 116 serialize_u16(self, v: u16) -> Result<Self::Ok>117 fn serialize_u16(self, v: u16) -> Result<Self::Ok> { 118 self.serialize_u64(v.into()) 119 } 120 serialize_u32(self, v: u32) -> Result<Self::Ok>121 fn serialize_u32(self, v: u32) -> Result<Self::Ok> { 122 self.serialize_u64(v.into()) 123 } 124 serialize_u64(self, v: u64) -> Result<Self::Ok>125 fn serialize_u64(self, v: u64) -> Result<Self::Ok> { 126 if v > (i64::max_value() as u64) { 127 Err(ConfigError::Message(format!( 128 "value {} is greater than the max {}", 129 v, 130 i64::max_value() 131 ))) 132 } else { 133 self.serialize_i64(v as i64) 134 } 135 } 136 serialize_f32(self, v: f32) -> Result<Self::Ok>137 fn serialize_f32(self, v: f32) -> Result<Self::Ok> { 138 self.serialize_f64(v.into()) 139 } 140 serialize_f64(self, v: f64) -> Result<Self::Ok>141 fn serialize_f64(self, v: f64) -> Result<Self::Ok> { 142 self.serialize_primitive(v) 143 } 144 serialize_char(self, v: char) -> Result<Self::Ok>145 fn serialize_char(self, v: char) -> Result<Self::Ok> { 146 self.serialize_primitive(v.to_string()) 147 } 148 serialize_str(self, v: &str) -> Result<Self::Ok>149 fn serialize_str(self, v: &str) -> Result<Self::Ok> { 150 self.serialize_primitive(v.to_string()) 151 } 152 serialize_bytes(self, v: &[u8]) -> Result<Self::Ok>153 fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok> { 154 use serde::ser::SerializeSeq; 155 let mut seq = self.serialize_seq(Some(v.len()))?; 156 for byte in v { 157 seq.serialize_element(byte)?; 158 } 159 seq.end(); 160 Ok(()) 161 } 162 serialize_none(self) -> Result<Self::Ok>163 fn serialize_none(self) -> Result<Self::Ok> { 164 self.serialize_unit() 165 } 166 serialize_some<T>(self, value: &T) -> Result<Self::Ok> where T: ?Sized + ser::Serialize,167 fn serialize_some<T>(self, value: &T) -> Result<Self::Ok> 168 where 169 T: ?Sized + ser::Serialize, 170 { 171 value.serialize(self) 172 } 173 serialize_unit(self) -> Result<Self::Ok>174 fn serialize_unit(self) -> Result<Self::Ok> { 175 self.serialize_primitive(Value::from(ValueKind::Nil)) 176 } 177 serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok>178 fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok> { 179 self.serialize_unit() 180 } 181 serialize_unit_variant( self, _name: &'static str, _variant_index: u32, variant: &'static str, ) -> Result<Self::Ok>182 fn serialize_unit_variant( 183 self, 184 _name: &'static str, 185 _variant_index: u32, 186 variant: &'static str, 187 ) -> Result<Self::Ok> { 188 self.serialize_str(variant) 189 } 190 serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Self::Ok> where T: ?Sized + ser::Serialize,191 fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Self::Ok> 192 where 193 T: ?Sized + ser::Serialize, 194 { 195 value.serialize(self) 196 } 197 serialize_newtype_variant<T>( self, _name: &'static str, _variant_index: u32, variant: &'static str, value: &T, ) -> Result<Self::Ok> where T: ?Sized + ser::Serialize,198 fn serialize_newtype_variant<T>( 199 self, 200 _name: &'static str, 201 _variant_index: u32, 202 variant: &'static str, 203 value: &T, 204 ) -> Result<Self::Ok> 205 where 206 T: ?Sized + ser::Serialize, 207 { 208 self.push_key(variant); 209 value.serialize(&mut *self)?; 210 self.pop_key(); 211 Ok(()) 212 } 213 serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq>214 fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> { 215 SeqSerializer::new(self) 216 } 217 serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple>218 fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> { 219 self.serialize_seq(Some(len)) 220 } 221 serialize_tuple_struct( self, _name: &'static str, len: usize, ) -> Result<Self::SerializeTupleStruct>222 fn serialize_tuple_struct( 223 self, 224 _name: &'static str, 225 len: usize, 226 ) -> Result<Self::SerializeTupleStruct> { 227 self.serialize_seq(Some(len)) 228 } 229 serialize_tuple_variant( self, _name: &'static str, _variant_index: u32, variant: &'static str, len: usize, ) -> Result<Self::SerializeTupleVariant>230 fn serialize_tuple_variant( 231 self, 232 _name: &'static str, 233 _variant_index: u32, 234 variant: &'static str, 235 len: usize, 236 ) -> Result<Self::SerializeTupleVariant> { 237 self.push_key(variant); 238 self.serialize_seq(Some(len)) 239 } 240 serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap>241 fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> { 242 Ok(self) 243 } 244 serialize_struct(self, _name: &'static str, len: usize) -> Result<Self::SerializeStruct>245 fn serialize_struct(self, _name: &'static str, len: usize) -> Result<Self::SerializeStruct> { 246 self.serialize_map(Some(len)) 247 } 248 serialize_struct_variant( self, _name: &'static str, _variant_index: u32, variant: &'static str, _len: usize, ) -> Result<Self::SerializeStructVariant>249 fn serialize_struct_variant( 250 self, 251 _name: &'static str, 252 _variant_index: u32, 253 variant: &'static str, 254 _len: usize, 255 ) -> Result<Self::SerializeStructVariant> { 256 self.push_key(variant); 257 Ok(self) 258 } 259 } 260 261 impl<'a> SeqSerializer<'a> { new(inner: &'a mut ConfigSerializer) -> Result<Self>262 fn new(inner: &'a mut ConfigSerializer) -> Result<Self> { 263 inner.keys.push(SerKey::Seq(0)); 264 265 Ok(SeqSerializer(inner)) 266 } 267 end(self) -> &'a mut ConfigSerializer268 fn end(self) -> &'a mut ConfigSerializer { 269 // This ought to be Some(SerKey::Seq(..)) but we don't want to panic if we are buggy 270 let _: Option<SerKey> = self.0.keys.pop(); 271 self.0 272 } 273 } 274 275 impl<'a> ser::SerializeSeq for SeqSerializer<'a> { 276 type Ok = (); 277 type Error = ConfigError; 278 serialize_element<T>(&mut self, value: &T) -> Result<()> where T: ?Sized + ser::Serialize,279 fn serialize_element<T>(&mut self, value: &T) -> Result<()> 280 where 281 T: ?Sized + ser::Serialize, 282 { 283 value.serialize(&mut *(self.0))?; 284 match self.0.keys.last_mut() { 285 Some(SerKey::Seq(i)) => *i += 1, 286 _ => { 287 return Err(ConfigError::Message( 288 "config-rs internal error (ser._element but last not Seq!".to_string(), 289 )) 290 } 291 }; 292 Ok(()) 293 } 294 end(self) -> Result<Self::Ok>295 fn end(self) -> Result<Self::Ok> { 296 self.end(); 297 Ok(()) 298 } 299 } 300 301 impl<'a> ser::SerializeTuple for SeqSerializer<'a> { 302 type Ok = (); 303 type Error = ConfigError; 304 serialize_element<T>(&mut self, value: &T) -> Result<()> where T: ?Sized + ser::Serialize,305 fn serialize_element<T>(&mut self, value: &T) -> Result<()> 306 where 307 T: ?Sized + ser::Serialize, 308 { 309 ser::SerializeSeq::serialize_element(self, value) 310 } 311 end(self) -> Result<Self::Ok>312 fn end(self) -> Result<Self::Ok> { 313 ser::SerializeSeq::end(self) 314 } 315 } 316 317 impl<'a> ser::SerializeTupleStruct for SeqSerializer<'a> { 318 type Ok = (); 319 type Error = ConfigError; 320 serialize_field<T>(&mut self, value: &T) -> Result<()> where T: ?Sized + ser::Serialize,321 fn serialize_field<T>(&mut self, value: &T) -> Result<()> 322 where 323 T: ?Sized + ser::Serialize, 324 { 325 ser::SerializeSeq::serialize_element(self, value) 326 } 327 end(self) -> Result<Self::Ok>328 fn end(self) -> Result<Self::Ok> { 329 ser::SerializeSeq::end(self) 330 } 331 } 332 333 impl<'a> ser::SerializeTupleVariant for SeqSerializer<'a> { 334 type Ok = (); 335 type Error = ConfigError; 336 serialize_field<T>(&mut self, value: &T) -> Result<()> where T: ?Sized + ser::Serialize,337 fn serialize_field<T>(&mut self, value: &T) -> Result<()> 338 where 339 T: ?Sized + ser::Serialize, 340 { 341 ser::SerializeSeq::serialize_element(self, value) 342 } 343 end(self) -> Result<Self::Ok>344 fn end(self) -> Result<Self::Ok> { 345 let inner = self.end(); 346 inner.pop_key(); 347 Ok(()) 348 } 349 } 350 351 impl<'a> ser::SerializeMap for &'a mut ConfigSerializer { 352 type Ok = (); 353 type Error = ConfigError; 354 serialize_key<T>(&mut self, key: &T) -> Result<()> where T: ?Sized + ser::Serialize,355 fn serialize_key<T>(&mut self, key: &T) -> Result<()> 356 where 357 T: ?Sized + ser::Serialize, 358 { 359 let key_serializer = StringKeySerializer; 360 let key = key.serialize(key_serializer)?; 361 self.push_key(&key); 362 Ok(()) 363 } 364 serialize_value<T>(&mut self, value: &T) -> Result<()> where T: ?Sized + ser::Serialize,365 fn serialize_value<T>(&mut self, value: &T) -> Result<()> 366 where 367 T: ?Sized + ser::Serialize, 368 { 369 value.serialize(&mut **self)?; 370 self.pop_key(); 371 Ok(()) 372 } 373 end(self) -> Result<Self::Ok>374 fn end(self) -> Result<Self::Ok> { 375 Ok(()) 376 } 377 } 378 379 impl<'a> ser::SerializeStruct for &'a mut ConfigSerializer { 380 type Ok = (); 381 type Error = ConfigError; 382 serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()> where T: ?Sized + ser::Serialize,383 fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()> 384 where 385 T: ?Sized + ser::Serialize, 386 { 387 self.push_key(key); 388 value.serialize(&mut **self)?; 389 self.pop_key(); 390 Ok(()) 391 } 392 end(self) -> Result<Self::Ok>393 fn end(self) -> Result<Self::Ok> { 394 Ok(()) 395 } 396 } 397 398 impl<'a> ser::SerializeStructVariant for &'a mut ConfigSerializer { 399 type Ok = (); 400 type Error = ConfigError; 401 serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()> where T: ?Sized + ser::Serialize,402 fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()> 403 where 404 T: ?Sized + ser::Serialize, 405 { 406 self.push_key(key); 407 value.serialize(&mut **self)?; 408 self.pop_key(); 409 Ok(()) 410 } 411 end(self) -> Result<Self::Ok>412 fn end(self) -> Result<Self::Ok> { 413 self.pop_key(); 414 Ok(()) 415 } 416 } 417 418 pub struct StringKeySerializer; 419 420 impl ser::Serializer for StringKeySerializer { 421 type Ok = String; 422 type Error = ConfigError; 423 type SerializeSeq = Self; 424 type SerializeTuple = Self; 425 type SerializeTupleStruct = Self; 426 type SerializeTupleVariant = Self; 427 type SerializeMap = Self; 428 type SerializeStruct = Self; 429 type SerializeStructVariant = Self; 430 serialize_bool(self, v: bool) -> Result<Self::Ok>431 fn serialize_bool(self, v: bool) -> Result<Self::Ok> { 432 Ok(v.to_string()) 433 } 434 serialize_i8(self, v: i8) -> Result<Self::Ok>435 fn serialize_i8(self, v: i8) -> Result<Self::Ok> { 436 Ok(v.to_string()) 437 } 438 serialize_i16(self, v: i16) -> Result<Self::Ok>439 fn serialize_i16(self, v: i16) -> Result<Self::Ok> { 440 Ok(v.to_string()) 441 } 442 serialize_i32(self, v: i32) -> Result<Self::Ok>443 fn serialize_i32(self, v: i32) -> Result<Self::Ok> { 444 Ok(v.to_string()) 445 } 446 serialize_i64(self, v: i64) -> Result<Self::Ok>447 fn serialize_i64(self, v: i64) -> Result<Self::Ok> { 448 Ok(v.to_string()) 449 } 450 serialize_u8(self, v: u8) -> Result<Self::Ok>451 fn serialize_u8(self, v: u8) -> Result<Self::Ok> { 452 Ok(v.to_string()) 453 } 454 serialize_u16(self, v: u16) -> Result<Self::Ok>455 fn serialize_u16(self, v: u16) -> Result<Self::Ok> { 456 Ok(v.to_string()) 457 } 458 serialize_u32(self, v: u32) -> Result<Self::Ok>459 fn serialize_u32(self, v: u32) -> Result<Self::Ok> { 460 Ok(v.to_string()) 461 } 462 serialize_u64(self, v: u64) -> Result<Self::Ok>463 fn serialize_u64(self, v: u64) -> Result<Self::Ok> { 464 Ok(v.to_string()) 465 } 466 serialize_f32(self, v: f32) -> Result<Self::Ok>467 fn serialize_f32(self, v: f32) -> Result<Self::Ok> { 468 Ok(v.to_string()) 469 } 470 serialize_f64(self, v: f64) -> Result<Self::Ok>471 fn serialize_f64(self, v: f64) -> Result<Self::Ok> { 472 Ok(v.to_string()) 473 } 474 serialize_char(self, v: char) -> Result<Self::Ok>475 fn serialize_char(self, v: char) -> Result<Self::Ok> { 476 Ok(v.to_string()) 477 } 478 serialize_str(self, v: &str) -> Result<Self::Ok>479 fn serialize_str(self, v: &str) -> Result<Self::Ok> { 480 Ok(v.to_string()) 481 } 482 serialize_bytes(self, v: &[u8]) -> Result<Self::Ok>483 fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok> { 484 Ok(String::from_utf8_lossy(v).to_string()) 485 } 486 serialize_none(self) -> Result<Self::Ok>487 fn serialize_none(self) -> Result<Self::Ok> { 488 self.serialize_unit() 489 } 490 serialize_some<T>(self, value: &T) -> Result<Self::Ok> where T: ?Sized + ser::Serialize,491 fn serialize_some<T>(self, value: &T) -> Result<Self::Ok> 492 where 493 T: ?Sized + ser::Serialize, 494 { 495 value.serialize(self) 496 } 497 serialize_unit(self) -> Result<Self::Ok>498 fn serialize_unit(self) -> Result<Self::Ok> { 499 Ok(String::new()) 500 } 501 serialize_unit_struct(self, _name: &str) -> Result<Self::Ok>502 fn serialize_unit_struct(self, _name: &str) -> Result<Self::Ok> { 503 self.serialize_unit() 504 } 505 serialize_unit_variant( self, _name: &str, _variant_index: u32, variant: &str, ) -> Result<Self::Ok>506 fn serialize_unit_variant( 507 self, 508 _name: &str, 509 _variant_index: u32, 510 variant: &str, 511 ) -> Result<Self::Ok> { 512 Ok(variant.to_string()) 513 } 514 serialize_newtype_struct<T>(self, _name: &str, value: &T) -> Result<Self::Ok> where T: ?Sized + ser::Serialize,515 fn serialize_newtype_struct<T>(self, _name: &str, value: &T) -> Result<Self::Ok> 516 where 517 T: ?Sized + ser::Serialize, 518 { 519 value.serialize(self) 520 } 521 serialize_newtype_variant<T>( self, _name: &str, _variant_index: u32, _variant: &str, value: &T, ) -> Result<Self::Ok> where T: ?Sized + ser::Serialize,522 fn serialize_newtype_variant<T>( 523 self, 524 _name: &str, 525 _variant_index: u32, 526 _variant: &str, 527 value: &T, 528 ) -> Result<Self::Ok> 529 where 530 T: ?Sized + ser::Serialize, 531 { 532 value.serialize(self) 533 } 534 serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq>535 fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> { 536 Err(ConfigError::Message( 537 "seq can't serialize to string key".to_string(), 538 )) 539 } 540 serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple>541 fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> { 542 Err(ConfigError::Message( 543 "tuple can't serialize to string key".to_string(), 544 )) 545 } 546 serialize_tuple_struct(self, name: &str, _len: usize) -> Result<Self::SerializeTupleStruct>547 fn serialize_tuple_struct(self, name: &str, _len: usize) -> Result<Self::SerializeTupleStruct> { 548 Err(ConfigError::Message(format!( 549 "tuple struct {} can't serialize to string key", 550 name 551 ))) 552 } 553 serialize_tuple_variant( self, name: &str, _variant_index: u32, variant: &str, _len: usize, ) -> Result<Self::SerializeTupleVariant>554 fn serialize_tuple_variant( 555 self, 556 name: &str, 557 _variant_index: u32, 558 variant: &str, 559 _len: usize, 560 ) -> Result<Self::SerializeTupleVariant> { 561 Err(ConfigError::Message(format!( 562 "tuple variant {}::{} can't serialize to string key", 563 name, variant 564 ))) 565 } 566 serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap>567 fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> { 568 Err(ConfigError::Message( 569 "map can't serialize to string key".to_string(), 570 )) 571 } 572 serialize_struct(self, name: &str, _len: usize) -> Result<Self::SerializeStruct>573 fn serialize_struct(self, name: &str, _len: usize) -> Result<Self::SerializeStruct> { 574 Err(ConfigError::Message(format!( 575 "struct {} can't serialize to string key", 576 name 577 ))) 578 } 579 serialize_struct_variant( self, name: &str, _variant_index: u32, variant: &str, _len: usize, ) -> Result<Self::SerializeStructVariant>580 fn serialize_struct_variant( 581 self, 582 name: &str, 583 _variant_index: u32, 584 variant: &str, 585 _len: usize, 586 ) -> Result<Self::SerializeStructVariant> { 587 Err(ConfigError::Message(format!( 588 "struct variant {}::{} can't serialize to string key", 589 name, variant 590 ))) 591 } 592 } 593 594 impl ser::SerializeSeq for StringKeySerializer { 595 type Ok = String; 596 type Error = ConfigError; 597 serialize_element<T>(&mut self, _value: &T) -> Result<()> where T: ?Sized + ser::Serialize,598 fn serialize_element<T>(&mut self, _value: &T) -> Result<()> 599 where 600 T: ?Sized + ser::Serialize, 601 { 602 unreachable!() 603 } 604 end(self) -> Result<Self::Ok>605 fn end(self) -> Result<Self::Ok> { 606 unreachable!() 607 } 608 } 609 610 impl ser::SerializeTuple for StringKeySerializer { 611 type Ok = String; 612 type Error = ConfigError; 613 serialize_element<T>(&mut self, _value: &T) -> Result<()> where T: ?Sized + ser::Serialize,614 fn serialize_element<T>(&mut self, _value: &T) -> Result<()> 615 where 616 T: ?Sized + ser::Serialize, 617 { 618 unreachable!() 619 } 620 end(self) -> Result<Self::Ok>621 fn end(self) -> Result<Self::Ok> { 622 unreachable!() 623 } 624 } 625 626 impl ser::SerializeTupleStruct for StringKeySerializer { 627 type Ok = String; 628 type Error = ConfigError; 629 serialize_field<T>(&mut self, _value: &T) -> Result<()> where T: ?Sized + ser::Serialize,630 fn serialize_field<T>(&mut self, _value: &T) -> Result<()> 631 where 632 T: ?Sized + ser::Serialize, 633 { 634 unreachable!() 635 } 636 end(self) -> Result<Self::Ok>637 fn end(self) -> Result<Self::Ok> { 638 unreachable!() 639 } 640 } 641 642 impl ser::SerializeTupleVariant for StringKeySerializer { 643 type Ok = String; 644 type Error = ConfigError; 645 serialize_field<T>(&mut self, _value: &T) -> Result<()> where T: ?Sized + ser::Serialize,646 fn serialize_field<T>(&mut self, _value: &T) -> Result<()> 647 where 648 T: ?Sized + ser::Serialize, 649 { 650 unreachable!() 651 } 652 end(self) -> Result<Self::Ok>653 fn end(self) -> Result<Self::Ok> { 654 unreachable!() 655 } 656 } 657 658 impl ser::SerializeMap for StringKeySerializer { 659 type Ok = String; 660 type Error = ConfigError; 661 serialize_key<T>(&mut self, _key: &T) -> Result<()> where T: ?Sized + ser::Serialize,662 fn serialize_key<T>(&mut self, _key: &T) -> Result<()> 663 where 664 T: ?Sized + ser::Serialize, 665 { 666 unreachable!() 667 } 668 serialize_value<T>(&mut self, _value: &T) -> Result<()> where T: ?Sized + ser::Serialize,669 fn serialize_value<T>(&mut self, _value: &T) -> Result<()> 670 where 671 T: ?Sized + ser::Serialize, 672 { 673 unreachable!() 674 } 675 end(self) -> Result<Self::Ok>676 fn end(self) -> Result<Self::Ok> { 677 unreachable!() 678 } 679 } 680 681 impl ser::SerializeStruct for StringKeySerializer { 682 type Ok = String; 683 type Error = ConfigError; 684 serialize_field<T>(&mut self, _key: &'static str, _value: &T) -> Result<()> where T: ?Sized + ser::Serialize,685 fn serialize_field<T>(&mut self, _key: &'static str, _value: &T) -> Result<()> 686 where 687 T: ?Sized + ser::Serialize, 688 { 689 unreachable!() 690 } 691 end(self) -> Result<Self::Ok>692 fn end(self) -> Result<Self::Ok> { 693 unreachable!() 694 } 695 } 696 697 impl ser::SerializeStructVariant for StringKeySerializer { 698 type Ok = String; 699 type Error = ConfigError; 700 serialize_field<T>(&mut self, _key: &'static str, _value: &T) -> Result<()> where T: ?Sized + ser::Serialize,701 fn serialize_field<T>(&mut self, _key: &'static str, _value: &T) -> Result<()> 702 where 703 T: ?Sized + ser::Serialize, 704 { 705 unreachable!() 706 } 707 end(self) -> Result<Self::Ok>708 fn end(self) -> Result<Self::Ok> { 709 unreachable!() 710 } 711 } 712 713 #[cfg(test)] 714 mod test { 715 use super::*; 716 use serde::{Deserialize, Serialize}; 717 718 #[test] test_struct()719 fn test_struct() { 720 #[derive(Debug, Serialize, Deserialize, PartialEq)] 721 struct Test { 722 int: u32, 723 seq: Vec<String>, 724 } 725 726 let test = Test { 727 int: 1, 728 seq: vec!["a".to_string(), "b".to_string()], 729 }; 730 let config = Config::try_from(&test).unwrap(); 731 732 let actual: Test = config.try_deserialize().unwrap(); 733 assert_eq!(test, actual); 734 } 735 736 #[test] test_nest()737 fn test_nest() { 738 let val = serde_json::json! { { 739 "top": { 740 "num": 1, 741 "array": [2], 742 "nested": [[3,4]], 743 "deep": [{ 744 "yes": true, 745 }], 746 "mixed": [ 747 { "boolish": false, }, 748 42, 749 ["hi"], 750 { "inner": 66 }, 751 23, 752 ], 753 } 754 } }; 755 let config = Config::try_from(&val).unwrap(); 756 let output: serde_json::Value = config.try_deserialize().unwrap(); 757 assert_eq!(val, output); 758 } 759 } 760