toml/
ser.rs

1//! Serializing Rust structures into TOML.
2//!
3//! This module contains all the Serde support for serializing Rust structures
4//! into TOML documents (as strings). Note that some top-level functions here
5//! are also provided at the top of the crate.
6
7/// Serialize the given data structure as a String of TOML.
8///
9/// Serialization can fail if `T`'s implementation of `Serialize` decides to
10/// fail, if `T` contains a map with non-string keys, or if `T` attempts to
11/// serialize an unsupported datatype such as an enum, tuple, or tuple struct.
12///
13/// To serialize TOML values, instead of documents, see [`ValueSerializer`].
14///
15/// # Examples
16///
17/// ```
18/// use serde::Serialize;
19///
20/// #[derive(Serialize)]
21/// struct Config {
22///     database: Database,
23/// }
24///
25/// #[derive(Serialize)]
26/// struct Database {
27///     ip: String,
28///     port: Vec<u16>,
29///     connection_max: u32,
30///     enabled: bool,
31/// }
32///
33/// let config = Config {
34///     database: Database {
35///         ip: "192.168.1.1".to_string(),
36///         port: vec![8001, 8002, 8003],
37///         connection_max: 5000,
38///         enabled: false,
39///     },
40/// };
41///
42/// let toml = toml::to_string(&config).unwrap();
43/// println!("{}", toml)
44/// ```
45#[cfg(feature = "display")]
46pub fn to_string<T: ?Sized>(value: &T) -> Result<String, Error>
47where
48    T: serde::ser::Serialize,
49{
50    let mut output = String::new();
51    let serializer = Serializer::new(&mut output);
52    value.serialize(serializer)?;
53    Ok(output)
54}
55
56/// Serialize the given data structure as a "pretty" String of TOML.
57///
58/// This is identical to `to_string` except the output string has a more
59/// "pretty" output. See `Serializer::pretty` for more details.
60///
61/// To serialize TOML values, instead of documents, see [`ValueSerializer`].
62#[cfg(feature = "display")]
63pub fn to_string_pretty<T: ?Sized>(value: &T) -> Result<String, Error>
64where
65    T: serde::ser::Serialize,
66{
67    let mut output = String::new();
68    let serializer = Serializer::pretty(&mut output);
69    value.serialize(serializer)?;
70    Ok(output)
71}
72
73/// Errors that can occur when serializing a type.
74#[derive(Debug, Clone, PartialEq, Eq)]
75pub struct Error {
76    pub(crate) inner: crate::edit::ser::Error,
77}
78
79impl Error {
80    pub(crate) fn new(inner: impl std::fmt::Display) -> Self {
81        Self {
82            inner: crate::edit::ser::Error::Custom(inner.to_string()),
83        }
84    }
85
86    #[cfg(feature = "display")]
87    pub(crate) fn wrap(inner: crate::edit::ser::Error) -> Self {
88        Self { inner }
89    }
90
91    pub(crate) fn unsupported_type(t: Option<&'static str>) -> Self {
92        Self {
93            inner: crate::edit::ser::Error::UnsupportedType(t),
94        }
95    }
96
97    pub(crate) fn unsupported_none() -> Self {
98        Self {
99            inner: crate::edit::ser::Error::UnsupportedNone,
100        }
101    }
102
103    pub(crate) fn key_not_string() -> Self {
104        Self {
105            inner: crate::edit::ser::Error::KeyNotString,
106        }
107    }
108}
109
110impl serde::ser::Error for Error {
111    fn custom<T>(msg: T) -> Self
112    where
113        T: std::fmt::Display,
114    {
115        Error::new(msg)
116    }
117}
118
119impl std::fmt::Display for Error {
120    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
121        self.inner.fmt(f)
122    }
123}
124
125impl std::error::Error for Error {}
126
127/// Serialization for TOML documents.
128///
129/// This structure implements serialization support for TOML to serialize an
130/// arbitrary type to TOML. Note that the TOML format does not support all
131/// datatypes in Rust, such as enums, tuples, and tuple structs. These types
132/// will generate an error when serialized.
133///
134/// Currently a serializer always writes its output to an in-memory `String`,
135/// which is passed in when creating the serializer itself.
136///
137/// To serialize TOML values, instead of documents, see [`ValueSerializer`].
138#[non_exhaustive]
139#[cfg(feature = "display")]
140pub struct Serializer<'d> {
141    dst: &'d mut String,
142    settings: crate::fmt::DocumentFormatter,
143}
144
145#[cfg(feature = "display")]
146impl<'d> Serializer<'d> {
147    /// Creates a new serializer which will emit TOML into the buffer provided.
148    ///
149    /// The serializer can then be used to serialize a type after which the data
150    /// will be present in `dst`.
151    pub fn new(dst: &'d mut String) -> Self {
152        Self {
153            dst,
154            settings: Default::default(),
155        }
156    }
157
158    /// Apply a default "pretty" policy to the document
159    pub fn pretty(dst: &'d mut String) -> Self {
160        let mut ser = Serializer::new(dst);
161        ser.settings.multiline_array = true;
162        ser
163    }
164
165    #[doc(hidden)]
166    #[deprecated(
167        since = "0.6.0",
168        note = "string behavior is now automatic; for greater control deserialize to `toml_edit::Document` and use `toml_edit::visit_mut::VisitorMut`"
169    )]
170    pub fn pretty_string(&mut self, _value: bool) -> &mut Self {
171        self
172    }
173
174    #[doc(hidden)]
175    #[deprecated(
176        since = "0.6.0",
177        note = "string behavior is now automatic; for greater control deserialize to `toml_edit::Document` and use `toml_edit::visit_mut::VisitorMut`"
178    )]
179    pub fn pretty_string_literal(&mut self, _value: bool) -> &mut Self {
180        self
181    }
182
183    #[doc(hidden)]
184    #[deprecated(
185        since = "0.6.0",
186        note = "this is bundled in with `pretty`; for greater control deserialize to `toml_edit::Document` and use `toml_edit::visit_mut::VisitorMut`"
187    )]
188    pub fn pretty_array(&mut self, _value: bool) -> &mut Self {
189        self
190    }
191
192    #[doc(hidden)]
193    #[deprecated(
194        since = "0.6.0",
195        note = "this is bundled in with `pretty`; for greater control deserialize to `toml_edit::Document` and use `toml_edit::visit_mut::VisitorMut`"
196    )]
197    pub fn pretty_array_indent(&mut self, _value: usize) -> &mut Self {
198        self
199    }
200
201    #[doc(hidden)]
202    #[deprecated(
203        since = "0.6.0",
204        note = "this is bundled in with `pretty`; for greater control deserialize to `toml_edit::Document` and use `toml_edit::visit_mut::VisitorMut`"
205    )]
206    pub fn pretty_array_trailing_comma(&mut self, _value: bool) -> &mut Self {
207        self
208    }
209}
210
211#[cfg(feature = "display")]
212impl<'d> serde::ser::Serializer for Serializer<'d> {
213    type Ok = ();
214    type Error = Error;
215    type SerializeSeq = SerializeDocumentArray<'d>;
216    type SerializeTuple = SerializeDocumentArray<'d>;
217    type SerializeTupleStruct = SerializeDocumentArray<'d>;
218    type SerializeTupleVariant = SerializeDocumentArray<'d>;
219    type SerializeMap = SerializeDocumentTable<'d>;
220    type SerializeStruct = SerializeDocumentTable<'d>;
221    type SerializeStructVariant = serde::ser::Impossible<Self::Ok, Self::Error>;
222
223    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
224        write_document(
225            self.dst,
226            self.settings,
227            toml_edit::ser::ValueSerializer::new().serialize_bool(v),
228        )
229    }
230
231    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
232        write_document(
233            self.dst,
234            self.settings,
235            toml_edit::ser::ValueSerializer::new().serialize_i8(v),
236        )
237    }
238
239    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
240        write_document(
241            self.dst,
242            self.settings,
243            toml_edit::ser::ValueSerializer::new().serialize_i16(v),
244        )
245    }
246
247    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
248        write_document(
249            self.dst,
250            self.settings,
251            toml_edit::ser::ValueSerializer::new().serialize_i32(v),
252        )
253    }
254
255    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
256        write_document(
257            self.dst,
258            self.settings,
259            toml_edit::ser::ValueSerializer::new().serialize_i64(v),
260        )
261    }
262
263    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
264        write_document(
265            self.dst,
266            self.settings,
267            toml_edit::ser::ValueSerializer::new().serialize_u8(v),
268        )
269    }
270
271    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
272        write_document(
273            self.dst,
274            self.settings,
275            toml_edit::ser::ValueSerializer::new().serialize_u16(v),
276        )
277    }
278
279    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
280        write_document(
281            self.dst,
282            self.settings,
283            toml_edit::ser::ValueSerializer::new().serialize_u32(v),
284        )
285    }
286
287    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
288        write_document(
289            self.dst,
290            self.settings,
291            toml_edit::ser::ValueSerializer::new().serialize_u64(v),
292        )
293    }
294
295    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
296        write_document(
297            self.dst,
298            self.settings,
299            toml_edit::ser::ValueSerializer::new().serialize_f32(v),
300        )
301    }
302
303    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
304        write_document(
305            self.dst,
306            self.settings,
307            toml_edit::ser::ValueSerializer::new().serialize_f64(v),
308        )
309    }
310
311    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
312        write_document(
313            self.dst,
314            self.settings,
315            toml_edit::ser::ValueSerializer::new().serialize_char(v),
316        )
317    }
318
319    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
320        write_document(
321            self.dst,
322            self.settings,
323            toml_edit::ser::ValueSerializer::new().serialize_str(v),
324        )
325    }
326
327    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
328        write_document(
329            self.dst,
330            self.settings,
331            toml_edit::ser::ValueSerializer::new().serialize_bytes(v),
332        )
333    }
334
335    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
336        write_document(
337            self.dst,
338            self.settings,
339            toml_edit::ser::ValueSerializer::new().serialize_none(),
340        )
341    }
342
343    fn serialize_some<T: ?Sized>(self, v: &T) -> Result<Self::Ok, Self::Error>
344    where
345        T: serde::ser::Serialize,
346    {
347        write_document(
348            self.dst,
349            self.settings,
350            toml_edit::ser::ValueSerializer::new().serialize_some(v),
351        )
352    }
353
354    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
355        write_document(
356            self.dst,
357            self.settings,
358            toml_edit::ser::ValueSerializer::new().serialize_unit(),
359        )
360    }
361
362    fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
363        write_document(
364            self.dst,
365            self.settings,
366            toml_edit::ser::ValueSerializer::new().serialize_unit_struct(name),
367        )
368    }
369
370    fn serialize_unit_variant(
371        self,
372        name: &'static str,
373        variant_index: u32,
374        variant: &'static str,
375    ) -> Result<Self::Ok, Self::Error> {
376        write_document(
377            self.dst,
378            self.settings,
379            toml_edit::ser::ValueSerializer::new().serialize_unit_variant(
380                name,
381                variant_index,
382                variant,
383            ),
384        )
385    }
386
387    fn serialize_newtype_struct<T: ?Sized>(
388        self,
389        name: &'static str,
390        v: &T,
391    ) -> Result<Self::Ok, Self::Error>
392    where
393        T: serde::ser::Serialize,
394    {
395        write_document(
396            self.dst,
397            self.settings,
398            toml_edit::ser::ValueSerializer::new().serialize_newtype_struct(name, v),
399        )
400    }
401
402    fn serialize_newtype_variant<T: ?Sized>(
403        self,
404        name: &'static str,
405        variant_index: u32,
406        variant: &'static str,
407        value: &T,
408    ) -> Result<Self::Ok, Self::Error>
409    where
410        T: serde::ser::Serialize,
411    {
412        write_document(
413            self.dst,
414            self.settings,
415            toml_edit::ser::ValueSerializer::new().serialize_newtype_variant(
416                name,
417                variant_index,
418                variant,
419                value,
420            ),
421        )
422    }
423
424    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
425        let ser = toml_edit::ser::ValueSerializer::new()
426            .serialize_seq(len)
427            .map_err(Error::wrap)?;
428        let ser = SerializeDocumentArray::new(self, ser);
429        Ok(ser)
430    }
431
432    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
433        self.serialize_seq(Some(len))
434    }
435
436    fn serialize_tuple_struct(
437        self,
438        _name: &'static str,
439        len: usize,
440    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
441        self.serialize_seq(Some(len))
442    }
443
444    fn serialize_tuple_variant(
445        self,
446        _name: &'static str,
447        _variant_index: u32,
448        _variant: &'static str,
449        len: usize,
450    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
451        self.serialize_seq(Some(len))
452    }
453
454    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
455        let ser = toml_edit::ser::ValueSerializer::new()
456            .serialize_map(len)
457            .map_err(Error::wrap)?;
458        let ser = SerializeDocumentTable::new(self, ser);
459        Ok(ser)
460    }
461
462    fn serialize_struct(
463        self,
464        _name: &'static str,
465        len: usize,
466    ) -> Result<Self::SerializeStruct, Self::Error> {
467        self.serialize_map(Some(len))
468    }
469
470    fn serialize_struct_variant(
471        self,
472        name: &'static str,
473        _variant_index: u32,
474        _variant: &'static str,
475        _len: usize,
476    ) -> Result<Self::SerializeStructVariant, Self::Error> {
477        Err(Error::unsupported_type(Some(name)))
478    }
479}
480
481/// Serialization for TOML [values][crate::Value].
482///
483/// This structure implements serialization support for TOML to serialize an
484/// arbitrary type to TOML. Note that the TOML format does not support all
485/// datatypes in Rust, such as enums, tuples, and tuple structs. These types
486/// will generate an error when serialized.
487///
488/// Currently a serializer always writes its output to an in-memory `String`,
489/// which is passed in when creating the serializer itself.
490///
491/// # Examples
492///
493/// ```
494/// use serde::Serialize;
495///
496/// #[derive(Serialize)]
497/// struct Config {
498///     database: Database,
499/// }
500///
501/// #[derive(Serialize)]
502/// struct Database {
503///     ip: String,
504///     port: Vec<u16>,
505///     connection_max: u32,
506///     enabled: bool,
507/// }
508///
509/// let config = Config {
510///     database: Database {
511///         ip: "192.168.1.1".to_string(),
512///         port: vec![8001, 8002, 8003],
513///         connection_max: 5000,
514///         enabled: false,
515///     },
516/// };
517///
518/// let mut value = String::new();
519/// serde::Serialize::serialize(
520///     &config,
521///     toml::ser::ValueSerializer::new(&mut value)
522/// ).unwrap();
523/// println!("{}", value)
524/// ```
525#[non_exhaustive]
526#[cfg(feature = "display")]
527pub struct ValueSerializer<'d> {
528    dst: &'d mut String,
529}
530
531#[cfg(feature = "display")]
532impl<'d> ValueSerializer<'d> {
533    /// Creates a new serializer which will emit TOML into the buffer provided.
534    ///
535    /// The serializer can then be used to serialize a type after which the data
536    /// will be present in `dst`.
537    pub fn new(dst: &'d mut String) -> Self {
538        Self { dst }
539    }
540}
541
542#[cfg(feature = "display")]
543impl<'d> serde::ser::Serializer for ValueSerializer<'d> {
544    type Ok = ();
545    type Error = Error;
546    type SerializeSeq = SerializeValueArray<'d>;
547    type SerializeTuple = SerializeValueArray<'d>;
548    type SerializeTupleStruct = SerializeValueArray<'d>;
549    type SerializeTupleVariant = SerializeValueArray<'d>;
550    type SerializeMap = SerializeValueTable<'d>;
551    type SerializeStruct = SerializeValueTable<'d>;
552    type SerializeStructVariant = serde::ser::Impossible<Self::Ok, Self::Error>;
553
554    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
555        write_value(
556            self.dst,
557            toml_edit::ser::ValueSerializer::new().serialize_bool(v),
558        )
559    }
560
561    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
562        write_value(
563            self.dst,
564            toml_edit::ser::ValueSerializer::new().serialize_i8(v),
565        )
566    }
567
568    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
569        write_value(
570            self.dst,
571            toml_edit::ser::ValueSerializer::new().serialize_i16(v),
572        )
573    }
574
575    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
576        write_value(
577            self.dst,
578            toml_edit::ser::ValueSerializer::new().serialize_i32(v),
579        )
580    }
581
582    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
583        write_value(
584            self.dst,
585            toml_edit::ser::ValueSerializer::new().serialize_i64(v),
586        )
587    }
588
589    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
590        write_value(
591            self.dst,
592            toml_edit::ser::ValueSerializer::new().serialize_u8(v),
593        )
594    }
595
596    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
597        write_value(
598            self.dst,
599            toml_edit::ser::ValueSerializer::new().serialize_u16(v),
600        )
601    }
602
603    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
604        write_value(
605            self.dst,
606            toml_edit::ser::ValueSerializer::new().serialize_u32(v),
607        )
608    }
609
610    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
611        write_value(
612            self.dst,
613            toml_edit::ser::ValueSerializer::new().serialize_u64(v),
614        )
615    }
616
617    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
618        write_value(
619            self.dst,
620            toml_edit::ser::ValueSerializer::new().serialize_f32(v),
621        )
622    }
623
624    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
625        write_value(
626            self.dst,
627            toml_edit::ser::ValueSerializer::new().serialize_f64(v),
628        )
629    }
630
631    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
632        write_value(
633            self.dst,
634            toml_edit::ser::ValueSerializer::new().serialize_char(v),
635        )
636    }
637
638    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
639        write_value(
640            self.dst,
641            toml_edit::ser::ValueSerializer::new().serialize_str(v),
642        )
643    }
644
645    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
646        write_value(
647            self.dst,
648            toml_edit::ser::ValueSerializer::new().serialize_bytes(v),
649        )
650    }
651
652    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
653        write_value(
654            self.dst,
655            toml_edit::ser::ValueSerializer::new().serialize_none(),
656        )
657    }
658
659    fn serialize_some<T: ?Sized>(self, v: &T) -> Result<Self::Ok, Self::Error>
660    where
661        T: serde::ser::Serialize,
662    {
663        write_value(
664            self.dst,
665            toml_edit::ser::ValueSerializer::new().serialize_some(v),
666        )
667    }
668
669    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
670        write_value(
671            self.dst,
672            toml_edit::ser::ValueSerializer::new().serialize_unit(),
673        )
674    }
675
676    fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
677        write_value(
678            self.dst,
679            toml_edit::ser::ValueSerializer::new().serialize_unit_struct(name),
680        )
681    }
682
683    fn serialize_unit_variant(
684        self,
685        name: &'static str,
686        variant_index: u32,
687        variant: &'static str,
688    ) -> Result<Self::Ok, Self::Error> {
689        write_value(
690            self.dst,
691            toml_edit::ser::ValueSerializer::new().serialize_unit_variant(
692                name,
693                variant_index,
694                variant,
695            ),
696        )
697    }
698
699    fn serialize_newtype_struct<T: ?Sized>(
700        self,
701        name: &'static str,
702        v: &T,
703    ) -> Result<Self::Ok, Self::Error>
704    where
705        T: serde::ser::Serialize,
706    {
707        write_value(
708            self.dst,
709            toml_edit::ser::ValueSerializer::new().serialize_newtype_struct(name, v),
710        )
711    }
712
713    fn serialize_newtype_variant<T: ?Sized>(
714        self,
715        name: &'static str,
716        variant_index: u32,
717        variant: &'static str,
718        value: &T,
719    ) -> Result<Self::Ok, Self::Error>
720    where
721        T: serde::ser::Serialize,
722    {
723        write_value(
724            self.dst,
725            toml_edit::ser::ValueSerializer::new().serialize_newtype_variant(
726                name,
727                variant_index,
728                variant,
729                value,
730            ),
731        )
732    }
733
734    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
735        let ser = toml_edit::ser::ValueSerializer::new()
736            .serialize_seq(len)
737            .map_err(Error::wrap)?;
738        let ser = SerializeValueArray::new(self, ser);
739        Ok(ser)
740    }
741
742    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
743        self.serialize_seq(Some(len))
744    }
745
746    fn serialize_tuple_struct(
747        self,
748        _name: &'static str,
749        len: usize,
750    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
751        self.serialize_seq(Some(len))
752    }
753
754    fn serialize_tuple_variant(
755        self,
756        _name: &'static str,
757        _variant_index: u32,
758        _variant: &'static str,
759        len: usize,
760    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
761        self.serialize_seq(Some(len))
762    }
763
764    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
765        let ser = toml_edit::ser::ValueSerializer::new()
766            .serialize_map(len)
767            .map_err(Error::wrap)?;
768        let ser = SerializeValueTable::new(self, ser);
769        Ok(ser)
770    }
771
772    fn serialize_struct(
773        self,
774        _name: &'static str,
775        len: usize,
776    ) -> Result<Self::SerializeStruct, Self::Error> {
777        self.serialize_map(Some(len))
778    }
779
780    fn serialize_struct_variant(
781        self,
782        name: &'static str,
783        _variant_index: u32,
784        _variant: &'static str,
785        _len: usize,
786    ) -> Result<Self::SerializeStructVariant, Self::Error> {
787        Err(Error::unsupported_type(Some(name)))
788    }
789}
790
791#[cfg(feature = "display")]
792use internal::*;
793
794#[cfg(feature = "display")]
795mod internal {
796    use super::*;
797
798    use crate::fmt::DocumentFormatter;
799
800    type InnerSerializeDocumentSeq =
801        <toml_edit::ser::ValueSerializer as serde::Serializer>::SerializeSeq;
802
803    #[doc(hidden)]
804    pub struct SerializeDocumentArray<'d> {
805        inner: InnerSerializeDocumentSeq,
806        dst: &'d mut String,
807        settings: DocumentFormatter,
808    }
809
810    impl<'d> SerializeDocumentArray<'d> {
811        pub(crate) fn new(ser: Serializer<'d>, inner: InnerSerializeDocumentSeq) -> Self {
812            Self {
813                inner,
814                dst: ser.dst,
815                settings: ser.settings,
816            }
817        }
818    }
819
820    impl<'d> serde::ser::SerializeSeq for SerializeDocumentArray<'d> {
821        type Ok = ();
822        type Error = Error;
823
824        fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
825        where
826            T: serde::ser::Serialize,
827        {
828            self.inner.serialize_element(value).map_err(Error::wrap)
829        }
830
831        fn end(self) -> Result<Self::Ok, Self::Error> {
832            write_document(self.dst, self.settings, self.inner.end())
833        }
834    }
835
836    impl<'d> serde::ser::SerializeTuple for SerializeDocumentArray<'d> {
837        type Ok = ();
838        type Error = Error;
839
840        fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
841        where
842            T: serde::ser::Serialize,
843        {
844            self.inner.serialize_element(value).map_err(Error::wrap)
845        }
846
847        fn end(self) -> Result<Self::Ok, Self::Error> {
848            write_document(self.dst, self.settings, self.inner.end())
849        }
850    }
851
852    impl<'d> serde::ser::SerializeTupleVariant for SerializeDocumentArray<'d> {
853        type Ok = ();
854        type Error = Error;
855
856        fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
857        where
858            T: serde::ser::Serialize,
859        {
860            self.inner.serialize_field(value).map_err(Error::wrap)
861        }
862
863        fn end(self) -> Result<Self::Ok, Self::Error> {
864            write_document(self.dst, self.settings, self.inner.end())
865        }
866    }
867
868    impl<'d> serde::ser::SerializeTupleStruct for SerializeDocumentArray<'d> {
869        type Ok = ();
870        type Error = Error;
871
872        fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
873        where
874            T: serde::ser::Serialize,
875        {
876            self.inner.serialize_field(value).map_err(Error::wrap)
877        }
878
879        fn end(self) -> Result<Self::Ok, Self::Error> {
880            write_document(self.dst, self.settings, self.inner.end())
881        }
882    }
883
884    type InnerSerializeDocumentTable =
885        <toml_edit::ser::ValueSerializer as serde::Serializer>::SerializeMap;
886
887    #[doc(hidden)]
888    pub struct SerializeDocumentTable<'d> {
889        inner: InnerSerializeDocumentTable,
890        dst: &'d mut String,
891        settings: DocumentFormatter,
892    }
893
894    impl<'d> SerializeDocumentTable<'d> {
895        pub(crate) fn new(ser: Serializer<'d>, inner: InnerSerializeDocumentTable) -> Self {
896            Self {
897                inner,
898                dst: ser.dst,
899                settings: ser.settings,
900            }
901        }
902    }
903
904    impl<'d> serde::ser::SerializeMap for SerializeDocumentTable<'d> {
905        type Ok = ();
906        type Error = Error;
907
908        fn serialize_key<T: ?Sized>(&mut self, input: &T) -> Result<(), Self::Error>
909        where
910            T: serde::ser::Serialize,
911        {
912            self.inner.serialize_key(input).map_err(Error::wrap)
913        }
914
915        fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
916        where
917            T: serde::ser::Serialize,
918        {
919            self.inner.serialize_value(value).map_err(Error::wrap)
920        }
921
922        fn end(self) -> Result<Self::Ok, Self::Error> {
923            write_document(self.dst, self.settings, self.inner.end())
924        }
925    }
926
927    impl<'d> serde::ser::SerializeStruct for SerializeDocumentTable<'d> {
928        type Ok = ();
929        type Error = Error;
930
931        fn serialize_field<T: ?Sized>(
932            &mut self,
933            key: &'static str,
934            value: &T,
935        ) -> Result<(), Self::Error>
936        where
937            T: serde::ser::Serialize,
938        {
939            self.inner.serialize_field(key, value).map_err(Error::wrap)
940        }
941
942        fn end(self) -> Result<Self::Ok, Self::Error> {
943            write_document(self.dst, self.settings, self.inner.end())
944        }
945    }
946
947    pub(crate) fn write_document(
948        dst: &mut String,
949        mut settings: DocumentFormatter,
950        value: Result<toml_edit::Value, crate::edit::ser::Error>,
951    ) -> Result<(), Error> {
952        use std::fmt::Write;
953
954        let value = value.map_err(Error::wrap)?;
955        let mut table = match toml_edit::Item::Value(value).into_table() {
956            Ok(i) => i,
957            Err(_) => {
958                return Err(Error::unsupported_type(None));
959            }
960        };
961
962        use toml_edit::visit_mut::VisitMut as _;
963        settings.visit_table_mut(&mut table);
964
965        let doc: toml_edit::Document = table.into();
966        write!(dst, "{}", doc).unwrap();
967
968        Ok(())
969    }
970
971    type InnerSerializeValueSeq =
972        <toml_edit::ser::ValueSerializer as serde::Serializer>::SerializeSeq;
973
974    #[doc(hidden)]
975    pub struct SerializeValueArray<'d> {
976        inner: InnerSerializeValueSeq,
977        dst: &'d mut String,
978    }
979
980    impl<'d> SerializeValueArray<'d> {
981        pub(crate) fn new(ser: ValueSerializer<'d>, inner: InnerSerializeValueSeq) -> Self {
982            Self {
983                inner,
984                dst: ser.dst,
985            }
986        }
987    }
988
989    impl<'d> serde::ser::SerializeSeq for SerializeValueArray<'d> {
990        type Ok = ();
991        type Error = Error;
992
993        fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
994        where
995            T: serde::ser::Serialize,
996        {
997            self.inner.serialize_element(value).map_err(Error::wrap)
998        }
999
1000        fn end(self) -> Result<Self::Ok, Self::Error> {
1001            write_value(self.dst, self.inner.end())
1002        }
1003    }
1004
1005    impl<'d> serde::ser::SerializeTuple for SerializeValueArray<'d> {
1006        type Ok = ();
1007        type Error = Error;
1008
1009        fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
1010        where
1011            T: serde::ser::Serialize,
1012        {
1013            self.inner.serialize_element(value).map_err(Error::wrap)
1014        }
1015
1016        fn end(self) -> Result<Self::Ok, Self::Error> {
1017            write_value(self.dst, self.inner.end())
1018        }
1019    }
1020
1021    impl<'d> serde::ser::SerializeTupleVariant for SerializeValueArray<'d> {
1022        type Ok = ();
1023        type Error = Error;
1024
1025        fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
1026        where
1027            T: serde::ser::Serialize,
1028        {
1029            self.inner.serialize_field(value).map_err(Error::wrap)
1030        }
1031
1032        fn end(self) -> Result<Self::Ok, Self::Error> {
1033            write_value(self.dst, self.inner.end())
1034        }
1035    }
1036
1037    impl<'d> serde::ser::SerializeTupleStruct for SerializeValueArray<'d> {
1038        type Ok = ();
1039        type Error = Error;
1040
1041        fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
1042        where
1043            T: serde::ser::Serialize,
1044        {
1045            self.inner.serialize_field(value).map_err(Error::wrap)
1046        }
1047
1048        fn end(self) -> Result<Self::Ok, Self::Error> {
1049            write_value(self.dst, self.inner.end())
1050        }
1051    }
1052
1053    type InnerSerializeValueTable =
1054        <toml_edit::ser::ValueSerializer as serde::Serializer>::SerializeMap;
1055
1056    #[doc(hidden)]
1057    pub struct SerializeValueTable<'d> {
1058        inner: InnerSerializeValueTable,
1059        dst: &'d mut String,
1060    }
1061
1062    impl<'d> SerializeValueTable<'d> {
1063        pub(crate) fn new(ser: ValueSerializer<'d>, inner: InnerSerializeValueTable) -> Self {
1064            Self {
1065                inner,
1066                dst: ser.dst,
1067            }
1068        }
1069    }
1070
1071    impl<'d> serde::ser::SerializeMap for SerializeValueTable<'d> {
1072        type Ok = ();
1073        type Error = Error;
1074
1075        fn serialize_key<T: ?Sized>(&mut self, input: &T) -> Result<(), Self::Error>
1076        where
1077            T: serde::ser::Serialize,
1078        {
1079            self.inner.serialize_key(input).map_err(Error::wrap)
1080        }
1081
1082        fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
1083        where
1084            T: serde::ser::Serialize,
1085        {
1086            self.inner.serialize_value(value).map_err(Error::wrap)
1087        }
1088
1089        fn end(self) -> Result<Self::Ok, Self::Error> {
1090            write_value(self.dst, self.inner.end())
1091        }
1092    }
1093
1094    impl<'d> serde::ser::SerializeStruct for SerializeValueTable<'d> {
1095        type Ok = ();
1096        type Error = Error;
1097
1098        fn serialize_field<T: ?Sized>(
1099            &mut self,
1100            key: &'static str,
1101            value: &T,
1102        ) -> Result<(), Self::Error>
1103        where
1104            T: serde::ser::Serialize,
1105        {
1106            self.inner.serialize_field(key, value).map_err(Error::wrap)
1107        }
1108
1109        fn end(self) -> Result<Self::Ok, Self::Error> {
1110            write_value(self.dst, self.inner.end())
1111        }
1112    }
1113
1114    pub(crate) fn write_value(
1115        dst: &mut String,
1116        value: Result<toml_edit::Value, crate::edit::ser::Error>,
1117    ) -> Result<(), Error> {
1118        use std::fmt::Write;
1119
1120        let value = value.map_err(Error::wrap)?;
1121
1122        write!(dst, "{}", value).unwrap();
1123
1124        Ok(())
1125    }
1126}
1127
1128#[doc(hidden)]
1129#[deprecated(
1130    since = "0.6.0",
1131    note = "`tables_last` is no longer needed; things just work"
1132)]
1133pub fn tables_last<'a, I, K, V, S>(data: &'a I, serializer: S) -> Result<S::Ok, S::Error>
1134where
1135    &'a I: IntoIterator<Item = (K, V)>,
1136    K: serde::ser::Serialize,
1137    V: serde::ser::Serialize,
1138    S: serde::ser::Serializer,
1139{
1140    use serde::ser::SerializeMap;
1141
1142    let mut map = serializer.serialize_map(None)?;
1143    for (k, v) in data {
1144        map.serialize_entry(&k, &v)?;
1145    }
1146    map.end()
1147}
toml/ser.rs

toml/
ser.rs
