1 use crate::{ 2 errors::{serialize::DeError, Error}, 3 events::{BytesEnd, BytesStart, Event}, 4 se::Serializer, 5 }; 6 use serde::ser::{self, Serialize}; 7 use std::io::Write; 8 9 /// An implementation of `SerializeMap` for serializing to XML. 10 pub struct Map<'w, W> 11 where 12 W: 'w + Write, 13 { 14 parent: &'w mut Serializer<W>, 15 } 16 17 impl<'w, W> Map<'w, W> 18 where 19 W: 'w + Write, 20 { 21 /// Create a new Map new(parent: &'w mut Serializer<W>) -> Map<'w, W>22 pub fn new(parent: &'w mut Serializer<W>) -> Map<'w, W> { 23 Map { parent } 24 } 25 } 26 27 impl<'w, W> ser::SerializeMap for Map<'w, W> 28 where 29 W: 'w + Write, 30 { 31 type Ok = (); 32 type Error = DeError; 33 serialize_key<T: ?Sized + Serialize>(&mut self, _: &T) -> Result<(), DeError>34 fn serialize_key<T: ?Sized + Serialize>(&mut self, _: &T) -> Result<(), DeError> { 35 Err(DeError::Unsupported( 36 "impossible to serialize the key on its own, please use serialize_entry()", 37 )) 38 } 39 serialize_value<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), DeError>40 fn serialize_value<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), DeError> { 41 value.serialize(&mut *self.parent) 42 } 43 end(self) -> Result<Self::Ok, DeError>44 fn end(self) -> Result<Self::Ok, DeError> { 45 Ok(()) 46 } 47 serialize_entry<K: ?Sized + Serialize, V: ?Sized + Serialize>( &mut self, key: &K, value: &V, ) -> Result<(), DeError>48 fn serialize_entry<K: ?Sized + Serialize, V: ?Sized + Serialize>( 49 &mut self, 50 key: &K, 51 value: &V, 52 ) -> Result<(), DeError> { 53 // TODO: Is it possible to ensure our key is never a composite type? 54 // Anything which isn't a "primitive" would lead to malformed XML here... 55 write!(self.parent.writer.inner(), "<").map_err(Error::Io)?; 56 key.serialize(&mut *self.parent)?; 57 write!(self.parent.writer.inner(), ">").map_err(Error::Io)?; 58 59 value.serialize(&mut *self.parent)?; 60 61 write!(self.parent.writer.inner(), "</").map_err(Error::Io)?; 62 key.serialize(&mut *self.parent)?; 63 write!(self.parent.writer.inner(), ">").map_err(Error::Io)?; 64 Ok(()) 65 } 66 } 67 68 /// An implementation of `SerializeStruct` for serializing to XML. 69 pub struct Struct<'w, W> 70 where 71 W: 'w + Write, 72 { 73 parent: &'w mut Serializer<W>, 74 name: &'w str, 75 } 76 77 impl<'w, W> Struct<'w, W> 78 where 79 W: 'w + Write, 80 { 81 /// Create a new `Struct` new(parent: &'w mut Serializer<W>, name: &'w str) -> Struct<'w, W>82 pub fn new(parent: &'w mut Serializer<W>, name: &'w str) -> Struct<'w, W> { 83 Struct { parent, name } 84 } 85 } 86 87 impl<'w, W> ser::SerializeStruct for Struct<'w, W> 88 where 89 W: 'w + Write, 90 { 91 type Ok = (); 92 type Error = DeError; 93 serialize_field<T: ?Sized + Serialize>( &mut self, key: &'static str, value: &T, ) -> Result<(), DeError>94 fn serialize_field<T: ?Sized + Serialize>( 95 &mut self, 96 key: &'static str, 97 value: &T, 98 ) -> Result<(), DeError> { 99 let key = key.as_bytes(); 100 self.parent 101 .writer 102 .write_event(Event::Start(BytesStart::borrowed_name(key)))?; 103 value.serialize(&mut *self.parent)?; 104 self.parent 105 .writer 106 .write_event(Event::End(BytesEnd::borrowed(key)))?; 107 Ok(()) 108 } 109 end(self) -> Result<Self::Ok, DeError>110 fn end(self) -> Result<Self::Ok, DeError> { 111 self.parent 112 .writer 113 .write_event(Event::End(BytesEnd::borrowed(self.name.as_bytes())))?; 114 Ok(()) 115 } 116 } 117 118 /// An implementation of `SerializeSeq' for serializing to XML. 119 pub struct Seq<'w, W> 120 where 121 W: 'w + Write, 122 { 123 parent: &'w mut Serializer<W>, 124 } 125 126 impl<'w, W> Seq<'w, W> 127 where 128 W: 'w + Write, 129 { 130 /// Create a new `Seq` new(parent: &'w mut Serializer<W>) -> Seq<'w, W>131 pub fn new(parent: &'w mut Serializer<W>) -> Seq<'w, W> { 132 Seq { parent } 133 } 134 } 135 136 impl<'w, W> ser::SerializeSeq for Seq<'w, W> 137 where 138 W: 'w + Write, 139 { 140 type Ok = (); 141 type Error = DeError; 142 serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error> where T: Serialize,143 fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error> 144 where 145 T: Serialize, 146 { 147 value.serialize(&mut *self.parent)?; 148 Ok(()) 149 } 150 end(self) -> Result<Self::Ok, Self::Error>151 fn end(self) -> Result<Self::Ok, Self::Error> { 152 Ok(()) 153 } 154 } 155