changelog shortlog graph tags branches changeset files revisions annotate raw help

Mercurial > core / rust/lib/sxp/src/ser.rs

changeset 698: 96958d3eb5b0
parent: 0ccbbd142694
author: Richard Westhaver <ellis@rwest.io>
date: Fri, 04 Oct 2024 22:04:59 -0400
permissions: -rw-r--r--
description: fixes 
     1 //! ser.rs --- SXP Serializer
     2 use crate::{
     3   err::ErrorCode,
     4   fmt::{DefaultFormatter, WriteFormatter},
     5   tok::{format_escaped_str, format_escaped_str_contents},
     6   Error, Result,
     7 };
     8 use core::{
     9   fmt::{self, Display},
    10   num::FpCategory,
    11 };
    12 use serde::ser::{self, Impossible, Serialize};
    13 use std::io::{self, Write};
    14 
    15 #[inline]
    16 pub fn to_writer<W: Write, S: ?Sized + Serialize>(
    17   writer: W,
    18   value: &S,
    19 ) -> Result<()> {
    20   let mut ser = Serializer::new(writer);
    21   value.serialize(&mut ser)
    22 }
    23 
    24 /// Serialize the given data structure as a canonical SXP byte vector.
    25 #[inline]
    26 pub fn to_vec<S: ?Sized + Serialize>(value: &S) -> Result<Vec<u8>> {
    27   let mut writer = Vec::with_capacity(128);
    28   e!(to_writer(&mut writer, value));
    29   Ok(writer)
    30 }
    31 
    32 #[inline]
    33 pub fn to_string<S: ?Sized + Serialize>(value: &S) -> Result<String> {
    34   let mut writer = Vec::new(); // TODO: with-capacity 128? bench
    35   to_writer(&mut writer, value)?;
    36   // We then check that the serialized string is the same as what we expect
    37   let string = unsafe { String::from_utf8_unchecked(writer) };
    38   Ok(string)
    39 }
    40 
    41 pub struct Serializer<W, F = DefaultFormatter> {
    42   writer: W,
    43   formatter: F,
    44 }
    45 
    46 impl<W: Write> Serializer<W> {
    47   #[inline]
    48   fn new(writer: W) -> Self {
    49     Serializer::with_formatter(writer, DefaultFormatter)
    50   }
    51 }
    52 
    53 impl<W: Write, F: WriteFormatter> Serializer<W, F> {
    54   fn with_formatter(writer: W, formatter: F) -> Self {
    55     Serializer { writer, formatter }
    56   }
    57   #[inline]
    58   pub fn into_inner(self) -> W {
    59     self.writer
    60   }
    61   #[inline]
    62   pub fn serialize_symbol(&mut self, value: &str) -> Result<()> {
    63     self
    64       .formatter
    65       .write_symbol(&mut self.writer, value)
    66       .map_err(Error::io)
    67   }
    68 }
    69 
    70 // impl<'a, W:Write> Serializer<W, PrettyFormatter<'a>> {...}
    71 
    72 impl<'ser, W: Write, F: WriteFormatter> serde::ser::Serializer
    73   for &'ser mut Serializer<W, F>
    74 {
    75   type Ok = (); // could be usize for bytes written
    76   type Error = Error;
    77   type SerializeSeq = Seq<'ser, W, F>;
    78   type SerializeTuple = Seq<'ser, W, F>;
    79   type SerializeTupleStruct = Seq<'ser, W, F>;
    80   type SerializeTupleVariant = Seq<'ser, W, F>;
    81   type SerializeMap = Seq<'ser, W, F>;
    82   type SerializeStruct = Seq<'ser, W, F>;
    83   type SerializeStructVariant = Seq<'ser, W, F>;
    84   // TODO
    85   fn serialize_bool(self, v: bool) -> Result<()> {
    86     self
    87       .formatter
    88       .write_bool(&mut self.writer, v)
    89       .map_err(Error::io)
    90   }
    91   #[inline]
    92   fn serialize_i8(self, value: i8) -> Result<()> {
    93     self
    94       .formatter
    95       .write_i8(&mut self.writer, value)
    96       .map_err(Error::io)
    97   }
    98 
    99   #[inline]
   100   fn serialize_i16(self, value: i16) -> Result<()> {
   101     self
   102       .formatter
   103       .write_i16(&mut self.writer, value)
   104       .map_err(Error::io)
   105   }
   106 
   107   #[inline]
   108   fn serialize_i32(self, value: i32) -> Result<()> {
   109     self
   110       .formatter
   111       .write_i32(&mut self.writer, value)
   112       .map_err(Error::io)
   113   }
   114 
   115   #[inline]
   116   fn serialize_i64(self, value: i64) -> Result<()> {
   117     self
   118       .formatter
   119       .write_i64(&mut self.writer, value)
   120       .map_err(Error::io)
   121   }
   122 
   123   fn serialize_i128(self, value: i128) -> Result<()> {
   124     self
   125       .formatter
   126       .write_i128(&mut self.writer, value)
   127       .map_err(Error::io)
   128   }
   129 
   130   #[inline]
   131   fn serialize_u8(self, value: u8) -> Result<()> {
   132     self
   133       .formatter
   134       .write_u8(&mut self.writer, value)
   135       .map_err(Error::io)
   136   }
   137 
   138   #[inline]
   139   fn serialize_u16(self, value: u16) -> Result<()> {
   140     self
   141       .formatter
   142       .write_u16(&mut self.writer, value)
   143       .map_err(Error::io)
   144   }
   145 
   146   #[inline]
   147   fn serialize_u32(self, value: u32) -> Result<()> {
   148     self
   149       .formatter
   150       .write_u32(&mut self.writer, value)
   151       .map_err(Error::io)
   152   }
   153 
   154   #[inline]
   155   fn serialize_u64(self, value: u64) -> Result<()> {
   156     self
   157       .formatter
   158       .write_u64(&mut self.writer, value)
   159       .map_err(Error::io)
   160   }
   161 
   162   fn serialize_u128(self, value: u128) -> Result<()> {
   163     self
   164       .formatter
   165       .write_u128(&mut self.writer, value)
   166       .map_err(Error::io)
   167   }
   168 
   169   #[inline]
   170   fn serialize_f32(self, value: f32) -> Result<()> {
   171     match value.classify() {
   172       // TODO
   173       FpCategory::Nan | FpCategory::Infinite => self
   174         .formatter
   175         .write_nil(&mut self.writer)
   176         .map_err(Error::io),
   177       _ => self
   178         .formatter
   179         .write_f32(&mut self.writer, value)
   180         .map_err(Error::io),
   181     }
   182   }
   183   #[inline]
   184   fn serialize_f64(self, value: f64) -> Result<()> {
   185     match value.classify() {
   186       FpCategory::Nan | FpCategory::Infinite => self
   187         .formatter
   188         .write_nil(&mut self.writer)
   189         .map_err(Error::io),
   190       _ => self
   191         .formatter
   192         .write_f64(&mut self.writer, value)
   193         .map_err(Error::io),
   194     }
   195   }
   196   #[inline]
   197   fn serialize_char(self, value: char) -> Result<()> {
   198     // A char encoded as UTF-8 takes 4 bytes at most.
   199     let mut buf = [0; 4];
   200     self.serialize_str(value.encode_utf8(&mut buf))
   201   }
   202   #[inline]
   203   fn serialize_str(self, value: &str) -> Result<()> {
   204     format_escaped_str(&mut self.writer, &mut self.formatter, value)
   205       .map_err(Error::io)
   206   }
   207   #[inline]
   208   fn serialize_bytes(self, value: &[u8]) -> Result<()> {
   209     use serde::ser::SerializeSeq;
   210     let mut seq = e!(self.serialize_seq(Some(value.len())));
   211     for byte in value {
   212       e!(seq.serialize_element(byte));
   213     }
   214     seq.end()
   215   }
   216   #[inline]
   217   fn serialize_unit(self) -> Result<()> {
   218     self
   219       .formatter
   220       .write_nil(&mut self.writer)
   221       .map_err(Error::io)
   222   }
   223   #[inline]
   224   fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
   225     self.serialize_unit()
   226   }
   227 
   228   #[inline]
   229   fn serialize_unit_variant(
   230     self,
   231     _name: &'static str,
   232     _variant_index: u32,
   233     variant: &'static str,
   234   ) -> Result<()> {
   235     self.serialize_symbol(variant)
   236   }
   237 
   238   /// Serialize newtypes without an object wrapper.
   239   #[inline]
   240   fn serialize_newtype_struct<T>(
   241     self,
   242     _name: &'static str,
   243     value: &T,
   244   ) -> Result<()>
   245   where
   246     T: ?Sized + Serialize,
   247   {
   248     value.serialize(self)
   249   }
   250 
   251   #[inline]
   252   fn serialize_newtype_variant<T>(
   253     self,
   254     _name: &'static str,
   255     _variant_index: u32,
   256     variant: &'static str,
   257     value: &T,
   258   ) -> Result<()>
   259   where
   260     T: ?Sized + Serialize,
   261   {
   262     e!(self
   263       .formatter
   264       .begin_list(&mut self.writer)
   265       .map_err(Error::io));
   266     e!(self.serialize_symbol(variant));
   267     // e!(self
   268     //     .formatter
   269     //     .end_object_key(&mut self.writer)
   270     //     .map_err(|e| e.into()));
   271     // e!(self
   272     //     .formatter
   273     //     .begin_object_value(&mut self.writer)
   274     //     .map_err(|e| e.into()));
   275     e!(self
   276       .formatter
   277       .begin_list_element(&mut self.writer, false)
   278       .map_err(Error::io));
   279     e!(value.serialize(&mut *self));
   280     // e!(self
   281     //     .formatter
   282     //     .end_object_value(&mut self.writer)
   283     //     .map_err(|e| e.into()));
   284     self.formatter.end_list(&mut self.writer).map_err(Error::io)
   285   }
   286 
   287   #[inline]
   288   fn serialize_none(self) -> Result<()> {
   289     self.serialize_unit()
   290   }
   291 
   292   #[inline]
   293   fn serialize_some<T>(self, value: &T) -> Result<()>
   294   where
   295     T: ?Sized + Serialize,
   296   {
   297     value.serialize(self)
   298   }
   299 
   300   #[inline]
   301   fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
   302     // TODO: impl nil for seq of 0 length?
   303     e!(self
   304       .formatter
   305       .begin_list(&mut self.writer)
   306       .map_err(Error::io));
   307     if len == Some(0) {
   308       e!(self.formatter.end_list(&mut self.writer).map_err(Error::io));
   309       Ok(Seq {
   310         ser: self,
   311         state: State::Nil,
   312       })
   313     } else {
   314       Ok(Seq {
   315         ser: self,
   316         state: State::Car,
   317       })
   318     }
   319   }
   320 
   321   #[inline]
   322   fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
   323     self.serialize_seq(Some(len))
   324   }
   325 
   326   #[inline]
   327   fn serialize_tuple_struct(
   328     self,
   329     _name: &'static str,
   330     len: usize,
   331   ) -> Result<Self::SerializeTupleStruct> {
   332     self.serialize_seq(Some(len))
   333   }
   334 
   335   #[inline]
   336   fn serialize_tuple_variant(
   337     self,
   338     _name: &'static str,
   339     _variant_index: u32,
   340     variant: &'static str,
   341     len: usize,
   342   ) -> Result<Self::SerializeTupleVariant> {
   343     e!(self
   344       .formatter
   345       .begin_list(&mut self.writer)
   346       .map_err(Error::io));
   347     e!(self.serialize_symbol(variant));
   348     // e!(self
   349     //     .formatter
   350     //     .end_object_key(&mut self.writer)
   351     //     .map_err(|e| e.into()));
   352     // e!(self
   353     //     .formatter
   354     //     .begin_object_value(&mut self.writer)
   355     //     .map_err(|e| e.into()));
   356     e!(self
   357       .formatter
   358       .begin_list_element(&mut self.writer, false)
   359       .map_err(Error::io));
   360     self.serialize_seq(Some(len))
   361   }
   362 
   363   #[inline]
   364   fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
   365     e!(self
   366       .formatter
   367       .begin_list(&mut self.writer)
   368       .map_err(Error::io));
   369     if len == Some(0) {
   370       e!(self.formatter.end_list(&mut self.writer).map_err(Error::io));
   371       Ok(Seq {
   372         ser: self,
   373         state: State::Nil,
   374       })
   375     } else {
   376       Ok(Seq {
   377         ser: self,
   378         state: State::Car,
   379       })
   380     }
   381   }
   382 
   383   // TODO: include struct name?
   384   #[inline]
   385   fn serialize_struct(
   386     self,
   387     _name: &'static str,
   388     len: usize,
   389   ) -> Result<Self::SerializeStruct> {
   390     self.serialize_map(Some(len))
   391   }
   392 
   393   #[inline]
   394   fn serialize_struct_variant(
   395     self,
   396     _name: &'static str,
   397     _variant_index: u32,
   398     variant: &'static str,
   399     len: usize,
   400   ) -> Result<Self::SerializeStructVariant> {
   401     e!(self
   402       .formatter
   403       .begin_list(&mut self.writer)
   404       .map_err(Error::io));
   405     e!(self.serialize_symbol(variant));
   406     e!(self
   407       .formatter
   408       .begin_list_element(&mut self.writer, false)
   409       .map_err(Error::io));
   410     // e!(self
   411     //     .formatter
   412     //     .end_object_key(&mut self.writer)
   413     //     .map_err(|e| e.into()));
   414     // e!(self
   415     //     .formatter
   416     //     .begin_object_value(&mut self.writer)
   417     //     .map_err(|e| e.into()));
   418     self.serialize_map(Some(len))
   419   }
   420 
   421   fn collect_str<T>(self, value: &T) -> Result<()>
   422   where
   423     T: ?Sized + Display,
   424   {
   425     use self::fmt::Write;
   426 
   427     struct Adapter<'ser, W: 'ser, F: 'ser> {
   428       writer: &'ser mut W,
   429       formatter: &'ser mut F,
   430       error: Option<io::Error>,
   431     }
   432 
   433     impl<'ser, W, F> Write for Adapter<'ser, W, F>
   434     where
   435       W: io::Write,
   436       F: WriteFormatter,
   437     {
   438       fn write_str(&mut self, s: &str) -> fmt::Result {
   439         debug_assert!(self.error.is_none());
   440         match format_escaped_str_contents(self.writer, self.formatter, s) {
   441           Ok(()) => Ok(()),
   442           Err(err) => {
   443             self.error = Some(err);
   444             Err(fmt::Error)
   445           }
   446         }
   447       }
   448     }
   449 
   450     e!(self
   451       .formatter
   452       .begin_string(&mut self.writer)
   453       .map_err(Error::io));
   454     {
   455       let mut adapter = Adapter {
   456         writer: &mut self.writer,
   457         formatter: &mut self.formatter,
   458         error: None,
   459       };
   460       match write!(adapter, "{}", value) {
   461         Ok(()) => debug_assert!(adapter.error.is_none()),
   462         Err(_) => {
   463           return Err(Error::io(
   464             adapter.error.expect("there should be an error"),
   465           ));
   466         }
   467       }
   468     }
   469     self
   470       .formatter
   471       .end_string(&mut self.writer)
   472       .map_err(Error::io)
   473   }
   474 }
   475 
   476 // Not public API. Should be pub(crate).
   477 #[doc(hidden)]
   478 #[derive(Eq, PartialEq)]
   479 pub enum State {
   480   Nil,
   481   Car,
   482   Cdr,
   483 }
   484 
   485 pub struct Seq<'a, W: 'a, F: 'a> {
   486   ser: &'a mut Serializer<W, F>,
   487   state: State,
   488 }
   489 
   490 impl<'ser, W: Write, F: WriteFormatter> ser::SerializeSeq for Seq<'ser, W, F> {
   491   type Ok = ();
   492   type Error = Error;
   493   #[inline]
   494   fn serialize_element<T: ?Sized + Serialize>(
   495     &mut self,
   496     value: &T,
   497   ) -> Result<()> {
   498     let ser = &mut self.ser;
   499     e!(ser
   500       .formatter
   501       .begin_list_element(&mut ser.writer, self.state == State::Car)
   502       .map_err(Error::io));
   503     self.state = State::Cdr;
   504     e!(value.serialize(&mut **ser));
   505     ser
   506       .formatter
   507       .end_list_element(&mut ser.writer)
   508       .map_err(Error::io)
   509   }
   510   #[inline]
   511   fn end(self) -> Result<()> {
   512     match self.state {
   513       State::Nil => Ok(()),
   514       _ => self
   515         .ser
   516         .formatter
   517         .end_list(&mut self.ser.writer)
   518         .map_err(Error::io),
   519     }
   520   }
   521 }
   522 
   523 impl<'ser, W: Write, F: WriteFormatter> ser::SerializeTuple
   524   for Seq<'ser, W, F>
   525 {
   526   type Ok = ();
   527   type Error = Error;
   528   #[inline]
   529   fn serialize_element<S: ?Sized + Serialize>(
   530     &mut self,
   531     value: &S,
   532   ) -> Result<()> {
   533     ser::SerializeSeq::serialize_element(self, value)
   534   }
   535   #[inline]
   536   fn end(self) -> Result<()> {
   537     ser::SerializeSeq::end(self)
   538   }
   539 }
   540 
   541 impl<'a, W, F> ser::SerializeTupleStruct for Seq<'a, W, F>
   542 where
   543   W: io::Write,
   544   F: WriteFormatter,
   545 {
   546   type Ok = ();
   547   type Error = Error;
   548 
   549   #[inline]
   550   fn serialize_field<T>(&mut self, value: &T) -> Result<()>
   551   where
   552     T: ?Sized + Serialize,
   553   {
   554     ser::SerializeSeq::serialize_element(self, value)
   555   }
   556 
   557   #[inline]
   558   fn end(self) -> Result<()> {
   559     match self.state {
   560       State::Nil => Ok(()),
   561       _ => self
   562         .ser
   563         .formatter
   564         .end_list(&mut self.ser.writer)
   565         .map_err(Error::io),
   566     }?;
   567     self
   568       .ser
   569       .formatter
   570       .end_list(&mut self.ser.writer)
   571       .map_err(Error::io)
   572   }
   573 }
   574 
   575 impl<'a, W, F> ser::SerializeTupleVariant for Seq<'a, W, F>
   576 where
   577   W: io::Write,
   578   F: WriteFormatter,
   579 {
   580   type Ok = ();
   581   type Error = Error;
   582 
   583   #[inline]
   584   fn serialize_field<T>(&mut self, value: &T) -> Result<()>
   585   where
   586     T: ?Sized + Serialize,
   587   {
   588     ser::SerializeSeq::serialize_element(self, value)
   589   }
   590 
   591   //  TODO 2023-07-09: this don't feel right
   592   #[inline]
   593   fn end(self) -> Result<()> {
   594     e!(self
   595       .ser
   596       .formatter
   597       .end_list(&mut self.ser.writer)
   598       .map_err(Error::io));
   599     ser::SerializeSeq::end(self)
   600   }
   601 }
   602 
   603 impl<'a, W, F> ser::SerializeMap for Seq<'a, W, F>
   604 where
   605   W: io::Write,
   606   F: WriteFormatter,
   607 {
   608   type Ok = ();
   609   type Error = Error;
   610 
   611   #[inline]
   612   fn serialize_key<T>(&mut self, key: &T) -> Result<()>
   613   where
   614     T: ?Sized + Serialize,
   615   {
   616     let ser = &mut self.ser;
   617     e!(ser
   618       .formatter
   619       .begin_list_element(&mut ser.writer, self.state == State::Car)
   620       .map_err(Error::io));
   621     self.state = State::Cdr;
   622     e!(ser.formatter.begin_key(&mut ser.writer).map_err(Error::io));
   623     key.serialize(SymbolSerializer(*ser))
   624   }
   625 
   626   #[inline]
   627   fn serialize_value<T>(&mut self, value: &T) -> Result<()>
   628   where
   629     T: ?Sized + Serialize,
   630   {
   631     let ser = &mut self.ser;
   632     e!(ser
   633       .formatter
   634       .begin_list_element(&mut ser.writer, false)
   635       .map_err(Error::io));
   636     e!(value.serialize(&mut **ser));
   637     ser
   638       .formatter
   639       .end_list_element(&mut ser.writer)
   640       .map_err(Error::io)
   641   }
   642 
   643   #[inline]
   644   fn end(self) -> Result<()> {
   645     self
   646       .ser
   647       .formatter
   648       .end_list(&mut self.ser.writer)
   649       .map_err(Error::io)
   650   }
   651 }
   652 
   653 impl<'a, W, F> ser::SerializeStruct for Seq<'a, W, F>
   654 where
   655   W: io::Write,
   656   F: WriteFormatter,
   657 {
   658   type Ok = ();
   659   type Error = Error;
   660 
   661   #[inline]
   662   fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
   663   where
   664     T: ?Sized + Serialize,
   665   {
   666     ser::SerializeMap::serialize_entry(self, key, value)
   667   }
   668 
   669   #[inline]
   670   fn end(self) -> Result<()> {
   671     ser::SerializeMap::end(self)
   672   }
   673 }
   674 
   675 impl<'a, W, F> ser::SerializeStructVariant for Seq<'a, W, F>
   676 where
   677   W: io::Write,
   678   F: WriteFormatter,
   679 {
   680   type Ok = ();
   681   type Error = Error;
   682 
   683   #[inline]
   684   fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
   685   where
   686     T: ?Sized + Serialize,
   687   {
   688     e!(self
   689       .ser
   690       .formatter
   691       .begin_key(&mut self.ser.writer)
   692       .map_err(Error::io));
   693     e!(self.ser.serialize_symbol(key));
   694     e!(self
   695       .ser
   696       .formatter
   697       .begin_list_element(&mut self.ser.writer, false)
   698       .map_err(Error::io));
   699     value.serialize(&mut *self.ser)
   700     //ser::SerializeMap::serialize_entry(self, key, value)
   701   }
   702   #[inline]
   703   fn end(self) -> Result<()> {
   704     match self.state {
   705       State::Nil => (),
   706       _ => e!(self
   707         .ser
   708         .formatter
   709         .end_list(&mut self.ser.writer)
   710         .map_err(Error::io)),
   711     };
   712     self
   713       .ser
   714       .formatter
   715       .end_list(&mut self.ser.writer)
   716       .map_err(Error::io)
   717     // ser::SerializeMap::end(self)
   718   }
   719 }
   720 
   721 fn key_sym_error() -> Error {
   722   Error::syntax(ErrorCode::KeyMustBeASymbol, 0, 0)
   723 }
   724 
   725 struct SymbolSerializer<'a, W: 'a, F: 'a>(&'a mut Serializer<W, F>);
   726 
   727 impl<'a, W, F> ser::Serializer for SymbolSerializer<'a, W, F>
   728 where
   729   W: io::Write,
   730   F: WriteFormatter,
   731 {
   732   type Ok = ();
   733   type Error = Error;
   734 
   735   #[inline]
   736   fn serialize_str(self, value: &str) -> Result<()> {
   737     self.0.serialize_symbol(value)
   738   }
   739   #[inline]
   740   fn serialize_unit_variant(
   741     self,
   742     _name: &'static str,
   743     _variant_index: u32,
   744     variant: &'static str,
   745   ) -> Result<()> {
   746     self.0.serialize_str(variant)
   747   }
   748 
   749   #[inline]
   750   fn serialize_newtype_struct<T>(
   751     self,
   752     _name: &'static str,
   753     value: &T,
   754   ) -> Result<()>
   755   where
   756     T: ?Sized + Serialize,
   757   {
   758     value.serialize(self)
   759   }
   760 
   761   type SerializeSeq = Impossible<(), Error>;
   762   type SerializeTuple = Impossible<(), Error>;
   763   type SerializeTupleStruct = Impossible<(), Error>;
   764   type SerializeTupleVariant = Impossible<(), Error>;
   765   type SerializeMap = Impossible<(), Error>;
   766   type SerializeStruct = Impossible<(), Error>;
   767   type SerializeStructVariant = Impossible<(), Error>;
   768 
   769   fn serialize_bool(self, _value: bool) -> Result<()> {
   770     Err(key_sym_error())
   771   }
   772 
   773   fn serialize_i8(self, value: i8) -> Result<()> {
   774     e!(self
   775       .0
   776       .formatter
   777       .begin_string(&mut self.0.writer)
   778       .map_err(Error::io));
   779     e!(self
   780       .0
   781       .formatter
   782       .write_i8(&mut self.0.writer, value)
   783       .map_err(Error::io));
   784     self
   785       .0
   786       .formatter
   787       .end_string(&mut self.0.writer)
   788       .map_err(Error::io)
   789   }
   790 
   791   fn serialize_i16(self, value: i16) -> Result<()> {
   792     e!(self
   793       .0
   794       .formatter
   795       .begin_string(&mut self.0.writer)
   796       .map_err(Error::io));
   797     e!(self
   798       .0
   799       .formatter
   800       .write_i16(&mut self.0.writer, value)
   801       .map_err(Error::io));
   802     self
   803       .0
   804       .formatter
   805       .end_string(&mut self.0.writer)
   806       .map_err(Error::io)
   807   }
   808 
   809   fn serialize_i32(self, value: i32) -> Result<()> {
   810     e!(self
   811       .0
   812       .formatter
   813       .begin_string(&mut self.0.writer)
   814       .map_err(Error::io));
   815     e!(self
   816       .0
   817       .formatter
   818       .write_i32(&mut self.0.writer, value)
   819       .map_err(Error::io));
   820     self
   821       .0
   822       .formatter
   823       .end_string(&mut self.0.writer)
   824       .map_err(Error::io)
   825   }
   826 
   827   fn serialize_i64(self, value: i64) -> Result<()> {
   828     e!(self
   829       .0
   830       .formatter
   831       .begin_string(&mut self.0.writer)
   832       .map_err(Error::io));
   833     e!(self
   834       .0
   835       .formatter
   836       .write_i64(&mut self.0.writer, value)
   837       .map_err(Error::io));
   838     self
   839       .0
   840       .formatter
   841       .end_string(&mut self.0.writer)
   842       .map_err(Error::io)
   843   }
   844 
   845   fn serialize_i128(self, value: i128) -> Result<()> {
   846     e!(self
   847       .0
   848       .formatter
   849       .begin_string(&mut self.0.writer)
   850       .map_err(Error::io));
   851     e!(self
   852       .0
   853       .formatter
   854       .write_i128(&mut self.0.writer, value)
   855       .map_err(Error::io));
   856     self
   857       .0
   858       .formatter
   859       .end_string(&mut self.0.writer)
   860       .map_err(Error::io)
   861   }
   862 
   863   fn serialize_u8(self, value: u8) -> Result<()> {
   864     e!(self
   865       .0
   866       .formatter
   867       .begin_string(&mut self.0.writer)
   868       .map_err(Error::io));
   869     e!(self
   870       .0
   871       .formatter
   872       .write_u8(&mut self.0.writer, value)
   873       .map_err(Error::io));
   874     self
   875       .0
   876       .formatter
   877       .end_string(&mut self.0.writer)
   878       .map_err(Error::io)
   879   }
   880 
   881   fn serialize_u16(self, value: u16) -> Result<()> {
   882     e!(self
   883       .0
   884       .formatter
   885       .begin_string(&mut self.0.writer)
   886       .map_err(Error::io));
   887     e!(self
   888       .0
   889       .formatter
   890       .write_u16(&mut self.0.writer, value)
   891       .map_err(Error::io));
   892     self
   893       .0
   894       .formatter
   895       .end_string(&mut self.0.writer)
   896       .map_err(Error::io)
   897   }
   898 
   899   fn serialize_u32(self, value: u32) -> Result<()> {
   900     e!(self
   901       .0
   902       .formatter
   903       .begin_string(&mut self.0.writer)
   904       .map_err(Error::io));
   905     e!(self
   906       .0
   907       .formatter
   908       .write_u32(&mut self.0.writer, value)
   909       .map_err(Error::io));
   910     self
   911       .0
   912       .formatter
   913       .end_string(&mut self.0.writer)
   914       .map_err(Error::io)
   915   }
   916 
   917   fn serialize_u64(self, value: u64) -> Result<()> {
   918     e!(self
   919       .0
   920       .formatter
   921       .begin_string(&mut self.0.writer)
   922       .map_err(Error::io));
   923     e!(self
   924       .0
   925       .formatter
   926       .write_u64(&mut self.0.writer, value)
   927       .map_err(Error::io));
   928     self
   929       .0
   930       .formatter
   931       .end_string(&mut self.0.writer)
   932       .map_err(Error::io)
   933   }
   934 
   935   fn serialize_u128(self, value: u128) -> Result<()> {
   936     e!(self
   937       .0
   938       .formatter
   939       .begin_string(&mut self.0.writer)
   940       .map_err(Error::io));
   941     e!(self
   942       .0
   943       .formatter
   944       .write_u128(&mut self.0.writer, value)
   945       .map_err(Error::io));
   946     self
   947       .0
   948       .formatter
   949       .end_string(&mut self.0.writer)
   950       .map_err(Error::io)
   951   }
   952 
   953   fn serialize_f32(self, _value: f32) -> Result<()> {
   954     Err(key_sym_error())
   955   }
   956 
   957   fn serialize_f64(self, _value: f64) -> Result<()> {
   958     Err(key_sym_error())
   959   }
   960 
   961   fn serialize_char(self, value: char) -> Result<()> {
   962     self.0.serialize_str(&value.to_string())
   963   }
   964 
   965   fn serialize_bytes(self, _value: &[u8]) -> Result<()> {
   966     Err(key_sym_error())
   967   }
   968 
   969   fn serialize_unit(self) -> Result<()> {
   970     Err(key_sym_error())
   971   }
   972 
   973   fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
   974     Err(key_sym_error())
   975   }
   976 
   977   fn serialize_newtype_variant<T>(
   978     self,
   979     _name: &'static str,
   980     _variant_index: u32,
   981     _variant: &'static str,
   982     _value: &T,
   983   ) -> Result<()>
   984   where
   985     T: ?Sized + Serialize,
   986   {
   987     Err(key_sym_error())
   988   }
   989 
   990   fn serialize_none(self) -> Result<()> {
   991     Err(key_sym_error())
   992   }
   993 
   994   fn serialize_some<T>(self, value: &T) -> Result<()>
   995   where
   996     T: ?Sized + Serialize,
   997   {
   998     value.serialize(self)
   999   }
  1000 
  1001   fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
  1002     Err(key_sym_error())
  1003   }
  1004 
  1005   fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
  1006     Err(key_sym_error())
  1007   }
  1008 
  1009   fn serialize_tuple_struct(
  1010     self,
  1011     _name: &'static str,
  1012     _len: usize,
  1013   ) -> Result<Self::SerializeTupleStruct> {
  1014     Err(key_sym_error())
  1015   }
  1016 
  1017   fn serialize_tuple_variant(
  1018     self,
  1019     _name: &'static str,
  1020     _variant_index: u32,
  1021     _variant: &'static str,
  1022     _len: usize,
  1023   ) -> Result<Self::SerializeTupleVariant> {
  1024     Err(key_sym_error())
  1025   }
  1026 
  1027   fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
  1028     Err(key_sym_error())
  1029   }
  1030 
  1031   fn serialize_struct(
  1032     self,
  1033     _name: &'static str,
  1034     _len: usize,
  1035   ) -> Result<Self::SerializeStruct> {
  1036     Err(key_sym_error())
  1037   }
  1038 
  1039   fn serialize_struct_variant(
  1040     self,
  1041     _name: &'static str,
  1042     _variant_index: u32,
  1043     _variant: &'static str,
  1044     _len: usize,
  1045   ) -> Result<Self::SerializeStructVariant> {
  1046     Err(key_sym_error())
  1047   }
  1048 
  1049   fn collect_str<T>(self, value: &T) -> Result<()>
  1050   where
  1051     T: ?Sized + Display,
  1052   {
  1053     self.0.collect_str(value)
  1054   }
  1055 }