| // Copyright 2017 Serde Developers |
| // |
| // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or |
| // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license |
| // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your |
| // option. This file may not be copied, modified, or distributed |
| // except according to those terms. |
| |
| use std::prelude::v1::*; |
| use serde::ser::Impossible; |
| use serde::{self, Serialize}; |
| |
| use error::{Error, ErrorCode}; |
| use map::Map; |
| use number::Number; |
| use value::{to_value, Value}; |
| |
| #[cfg(feature = "arbitrary_precision")] |
| use serde::ser; |
| |
| #[cfg(feature = "arbitrary_precision")] |
| use number::{SERDE_STRUCT_FIELD_NAME, SERDE_STRUCT_NAME}; |
| |
| impl Serialize for Value { |
| #[inline] |
| fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> |
| where |
| S: ::serde::Serializer, |
| { |
| match *self { |
| Value::Null => serializer.serialize_unit(), |
| Value::Bool(b) => serializer.serialize_bool(b), |
| Value::Number(ref n) => n.serialize(serializer), |
| Value::String(ref s) => serializer.serialize_str(s), |
| Value::Array(ref v) => v.serialize(serializer), |
| Value::Object(ref m) => { |
| use serde::ser::SerializeMap; |
| let mut map = try!(serializer.serialize_map(Some(m.len()))); |
| for (k, v) in m { |
| try!(map.serialize_key(k)); |
| try!(map.serialize_value(v)); |
| } |
| map.end() |
| } |
| } |
| } |
| } |
| |
| pub struct Serializer; |
| |
| impl serde::Serializer for Serializer { |
| type Ok = Value; |
| type Error = Error; |
| |
| type SerializeSeq = SerializeVec; |
| type SerializeTuple = SerializeVec; |
| type SerializeTupleStruct = SerializeVec; |
| type SerializeTupleVariant = SerializeTupleVariant; |
| type SerializeMap = SerializeMap; |
| type SerializeStruct = SerializeMap; |
| type SerializeStructVariant = SerializeStructVariant; |
| |
| #[inline] |
| fn serialize_bool(self, value: bool) -> Result<Value, Error> { |
| Ok(Value::Bool(value)) |
| } |
| |
| #[inline] |
| fn serialize_i8(self, value: i8) -> Result<Value, Error> { |
| self.serialize_i64(value as i64) |
| } |
| |
| #[inline] |
| fn serialize_i16(self, value: i16) -> Result<Value, Error> { |
| self.serialize_i64(value as i64) |
| } |
| |
| #[inline] |
| fn serialize_i32(self, value: i32) -> Result<Value, Error> { |
| self.serialize_i64(value as i64) |
| } |
| |
| fn serialize_i64(self, value: i64) -> Result<Value, Error> { |
| Ok(Value::Number(value.into())) |
| } |
| |
| #[inline] |
| fn serialize_u8(self, value: u8) -> Result<Value, Error> { |
| self.serialize_u64(value as u64) |
| } |
| |
| #[inline] |
| fn serialize_u16(self, value: u16) -> Result<Value, Error> { |
| self.serialize_u64(value as u64) |
| } |
| |
| #[inline] |
| fn serialize_u32(self, value: u32) -> Result<Value, Error> { |
| self.serialize_u64(value as u64) |
| } |
| |
| #[inline] |
| fn serialize_u64(self, value: u64) -> Result<Value, Error> { |
| Ok(Value::Number(value.into())) |
| } |
| |
| #[inline] |
| fn serialize_f32(self, value: f32) -> Result<Value, Error> { |
| self.serialize_f64(value as f64) |
| } |
| |
| #[inline] |
| fn serialize_f64(self, value: f64) -> Result<Value, Error> { |
| Ok(Number::from_f64(value).map_or(Value::Null, Value::Number)) |
| } |
| |
| #[inline] |
| fn serialize_char(self, value: char) -> Result<Value, Error> { |
| let mut s = String::new(); |
| s.push(value); |
| self.serialize_str(&s) |
| } |
| |
| #[inline] |
| fn serialize_str(self, value: &str) -> Result<Value, Error> { |
| Ok(Value::String(value.to_owned())) |
| } |
| |
| fn serialize_bytes(self, value: &[u8]) -> Result<Value, Error> { |
| let vec = value.iter().map(|&b| Value::Number(b.into())).collect(); |
| Ok(Value::Array(vec)) |
| } |
| |
| #[inline] |
| fn serialize_unit(self) -> Result<Value, Error> { |
| Ok(Value::Null) |
| } |
| |
| #[inline] |
| fn serialize_unit_struct(self, _name: &'static str) -> Result<Value, Error> { |
| self.serialize_unit() |
| } |
| |
| #[inline] |
| fn serialize_unit_variant( |
| self, |
| _name: &'static str, |
| _variant_index: u32, |
| variant: &'static str, |
| ) -> Result<Value, Error> { |
| self.serialize_str(variant) |
| } |
| |
| #[inline] |
| fn serialize_newtype_struct<T: ?Sized>( |
| self, |
| _name: &'static str, |
| value: &T, |
| ) -> Result<Value, Error> |
| where |
| T: Serialize, |
| { |
| value.serialize(self) |
| } |
| |
| fn serialize_newtype_variant<T: ?Sized>( |
| self, |
| _name: &'static str, |
| _variant_index: u32, |
| variant: &'static str, |
| value: &T, |
| ) -> Result<Value, Error> |
| where |
| T: Serialize, |
| { |
| let mut values = Map::new(); |
| values.insert(String::from(variant), try!(to_value(&value))); |
| Ok(Value::Object(values)) |
| } |
| |
| #[inline] |
| fn serialize_none(self) -> Result<Value, Error> { |
| self.serialize_unit() |
| } |
| |
| #[inline] |
| fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Value, Error> |
| where |
| T: Serialize, |
| { |
| value.serialize(self) |
| } |
| |
| fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Error> { |
| Ok(SerializeVec { |
| vec: Vec::with_capacity(len.unwrap_or(0)), |
| }) |
| } |
| |
| fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Error> { |
| self.serialize_seq(Some(len)) |
| } |
| |
| fn serialize_tuple_struct( |
| self, |
| _name: &'static str, |
| len: usize, |
| ) -> Result<Self::SerializeTupleStruct, Error> { |
| self.serialize_seq(Some(len)) |
| } |
| |
| fn serialize_tuple_variant( |
| self, |
| _name: &'static str, |
| _variant_index: u32, |
| variant: &'static str, |
| len: usize, |
| ) -> Result<Self::SerializeTupleVariant, Error> { |
| Ok(SerializeTupleVariant { |
| name: String::from(variant), |
| vec: Vec::with_capacity(len), |
| }) |
| } |
| |
| fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Error> { |
| Ok(SerializeMap::Map { |
| map: Map::new(), |
| next_key: None, |
| }) |
| } |
| |
| #[cfg(not(feature = "arbitrary_precision"))] |
| fn serialize_struct( |
| self, |
| _name: &'static str, |
| len: usize, |
| ) -> Result<Self::SerializeStruct, Error> { |
| self.serialize_map(Some(len)) |
| } |
| |
| #[cfg(feature = "arbitrary_precision")] |
| fn serialize_struct( |
| self, |
| name: &'static str, |
| len: usize, |
| ) -> Result<Self::SerializeStruct, Error> { |
| if name == SERDE_STRUCT_NAME { |
| Ok(SerializeMap::Number { out_value: None }) |
| } else { |
| self.serialize_map(Some(len)) |
| } |
| } |
| |
| fn serialize_struct_variant( |
| self, |
| _name: &'static str, |
| _variant_index: u32, |
| variant: &'static str, |
| _len: usize, |
| ) -> Result<Self::SerializeStructVariant, Error> { |
| Ok(SerializeStructVariant { |
| name: String::from(variant), |
| map: Map::new(), |
| }) |
| } |
| } |
| |
| pub struct SerializeVec { |
| vec: Vec<Value>, |
| } |
| |
| pub struct SerializeTupleVariant { |
| name: String, |
| vec: Vec<Value>, |
| } |
| |
| pub enum SerializeMap { |
| Map { |
| map: Map<String, Value>, |
| next_key: Option<String>, |
| }, |
| #[cfg(feature = "arbitrary_precision")] |
| Number { out_value: Option<Value> }, |
| } |
| |
| pub struct SerializeStructVariant { |
| name: String, |
| map: Map<String, Value>, |
| } |
| |
| impl serde::ser::SerializeSeq for SerializeVec { |
| type Ok = Value; |
| type Error = Error; |
| |
| fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error> |
| where |
| T: Serialize, |
| { |
| self.vec.push(try!(to_value(&value))); |
| Ok(()) |
| } |
| |
| fn end(self) -> Result<Value, Error> { |
| Ok(Value::Array(self.vec)) |
| } |
| } |
| |
| impl serde::ser::SerializeTuple for SerializeVec { |
| type Ok = Value; |
| type Error = Error; |
| |
| fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error> |
| where |
| T: Serialize, |
| { |
| serde::ser::SerializeSeq::serialize_element(self, value) |
| } |
| |
| fn end(self) -> Result<Value, Error> { |
| serde::ser::SerializeSeq::end(self) |
| } |
| } |
| |
| impl serde::ser::SerializeTupleStruct for SerializeVec { |
| type Ok = Value; |
| type Error = Error; |
| |
| fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error> |
| where |
| T: Serialize, |
| { |
| serde::ser::SerializeSeq::serialize_element(self, value) |
| } |
| |
| fn end(self) -> Result<Value, Error> { |
| serde::ser::SerializeSeq::end(self) |
| } |
| } |
| |
| impl serde::ser::SerializeTupleVariant for SerializeTupleVariant { |
| type Ok = Value; |
| type Error = Error; |
| |
| fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error> |
| where |
| T: Serialize, |
| { |
| self.vec.push(try!(to_value(&value))); |
| Ok(()) |
| } |
| |
| fn end(self) -> Result<Value, Error> { |
| let mut object = Map::new(); |
| |
| object.insert(self.name, Value::Array(self.vec)); |
| |
| Ok(Value::Object(object)) |
| } |
| } |
| |
| impl serde::ser::SerializeMap for SerializeMap { |
| type Ok = Value; |
| type Error = Error; |
| |
| fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Error> |
| where |
| T: Serialize, |
| { |
| match *self { |
| SerializeMap::Map { |
| ref mut next_key, .. |
| } => { |
| *next_key = Some(try!(key.serialize(MapKeySerializer))); |
| Ok(()) |
| } |
| #[cfg(feature = "arbitrary_precision")] |
| SerializeMap::Number { .. } => unreachable!(), |
| } |
| } |
| |
| fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Error> |
| where |
| T: Serialize, |
| { |
| match *self { |
| SerializeMap::Map { |
| ref mut map, |
| ref mut next_key, |
| } => { |
| let key = next_key.take(); |
| // Panic because this indicates a bug in the program rather than an |
| // expected failure. |
| let key = key.expect("serialize_value called before serialize_key"); |
| map.insert(key, try!(to_value(&value))); |
| Ok(()) |
| } |
| #[cfg(feature = "arbitrary_precision")] |
| SerializeMap::Number { .. } => unreachable!(), |
| } |
| } |
| |
| fn end(self) -> Result<Value, Error> { |
| match self { |
| SerializeMap::Map { map, .. } => Ok(Value::Object(map)), |
| #[cfg(feature = "arbitrary_precision")] |
| SerializeMap::Number { .. } => unreachable!(), |
| } |
| } |
| } |
| |
| struct MapKeySerializer; |
| |
| fn key_must_be_a_string() -> Error { |
| Error::syntax(ErrorCode::KeyMustBeAString, 0, 0) |
| } |
| |
| impl serde::Serializer for MapKeySerializer { |
| type Ok = String; |
| type Error = Error; |
| |
| type SerializeSeq = Impossible<String, Error>; |
| type SerializeTuple = Impossible<String, Error>; |
| type SerializeTupleStruct = Impossible<String, Error>; |
| type SerializeTupleVariant = Impossible<String, Error>; |
| type SerializeMap = Impossible<String, Error>; |
| type SerializeStruct = Impossible<String, Error>; |
| type SerializeStructVariant = Impossible<String, Error>; |
| |
| #[inline] |
| fn serialize_unit_variant( |
| self, |
| _name: &'static str, |
| _variant_index: u32, |
| variant: &'static str, |
| ) -> Result<Self::Ok, Self::Error> { |
| Ok(variant.to_owned()) |
| } |
| |
| #[inline] |
| fn serialize_newtype_struct<T: ?Sized>( |
| self, |
| _name: &'static str, |
| value: &T, |
| ) -> Result<Self::Ok, Self::Error> |
| where |
| T: Serialize, |
| { |
| value.serialize(self) |
| } |
| |
| fn serialize_bool(self, _value: bool) -> Result<Self::Ok, Self::Error> { |
| Err(key_must_be_a_string()) |
| } |
| |
| fn serialize_i8(self, value: i8) -> Result<Self::Ok, Self::Error> { |
| Ok(value.to_string()) |
| } |
| |
| fn serialize_i16(self, value: i16) -> Result<Self::Ok, Self::Error> { |
| Ok(value.to_string()) |
| } |
| |
| fn serialize_i32(self, value: i32) -> Result<Self::Ok, Self::Error> { |
| Ok(value.to_string()) |
| } |
| |
| fn serialize_i64(self, value: i64) -> Result<Self::Ok, Self::Error> { |
| Ok(value.to_string()) |
| } |
| |
| fn serialize_u8(self, value: u8) -> Result<Self::Ok, Self::Error> { |
| Ok(value.to_string()) |
| } |
| |
| fn serialize_u16(self, value: u16) -> Result<Self::Ok, Self::Error> { |
| Ok(value.to_string()) |
| } |
| |
| fn serialize_u32(self, value: u32) -> Result<Self::Ok, Self::Error> { |
| Ok(value.to_string()) |
| } |
| |
| fn serialize_u64(self, value: u64) -> Result<Self::Ok, Self::Error> { |
| Ok(value.to_string()) |
| } |
| |
| fn serialize_f32(self, _value: f32) -> Result<Self::Ok, Self::Error> { |
| Err(key_must_be_a_string()) |
| } |
| |
| fn serialize_f64(self, _value: f64) -> Result<Self::Ok, Self::Error> { |
| Err(key_must_be_a_string()) |
| } |
| |
| #[inline] |
| fn serialize_char(self, value: char) -> Result<Self::Ok, Self::Error> { |
| Ok({ |
| let mut s = String::new(); |
| s.push(value); |
| s |
| }) |
| } |
| |
| #[inline] |
| fn serialize_str(self, value: &str) -> Result<Self::Ok, Self::Error> { |
| Ok(value.to_owned()) |
| } |
| |
| fn serialize_bytes(self, _value: &[u8]) -> Result<Self::Ok, Self::Error> { |
| Err(key_must_be_a_string()) |
| } |
| |
| fn serialize_unit(self) -> Result<Self::Ok, Self::Error> { |
| Err(key_must_be_a_string()) |
| } |
| |
| fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> { |
| Err(key_must_be_a_string()) |
| } |
| |
| fn serialize_newtype_variant<T: ?Sized>( |
| self, |
| _name: &'static str, |
| _variant_index: u32, |
| _variant: &'static str, |
| _value: &T, |
| ) -> Result<Self::Ok, Self::Error> |
| where |
| T: Serialize, |
| { |
| Err(key_must_be_a_string()) |
| } |
| |
| fn serialize_none(self) -> Result<Self::Ok, Self::Error> { |
| Err(key_must_be_a_string()) |
| } |
| |
| fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<Self::Ok, Self::Error> |
| where |
| T: Serialize, |
| { |
| Err(key_must_be_a_string()) |
| } |
| |
| fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> { |
| Err(key_must_be_a_string()) |
| } |
| |
| fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> { |
| Err(key_must_be_a_string()) |
| } |
| |
| fn serialize_tuple_struct( |
| self, |
| _name: &'static str, |
| _len: usize, |
| ) -> Result<Self::SerializeTupleStruct, Self::Error> { |
| Err(key_must_be_a_string()) |
| } |
| |
| fn serialize_tuple_variant( |
| self, |
| _name: &'static str, |
| _variant_index: u32, |
| _variant: &'static str, |
| _len: usize, |
| ) -> Result<Self::SerializeTupleVariant, Self::Error> { |
| Err(key_must_be_a_string()) |
| } |
| |
| fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> { |
| Err(key_must_be_a_string()) |
| } |
| |
| fn serialize_struct( |
| self, |
| _name: &'static str, |
| _len: usize, |
| ) -> Result<Self::SerializeStruct, Self::Error> { |
| Err(key_must_be_a_string()) |
| } |
| |
| fn serialize_struct_variant( |
| self, |
| _name: &'static str, |
| _variant_index: u32, |
| _variant: &'static str, |
| _len: usize, |
| ) -> Result<Self::SerializeStructVariant, Self::Error> { |
| Err(key_must_be_a_string()) |
| } |
| } |
| |
| impl serde::ser::SerializeStruct for SerializeMap { |
| type Ok = Value; |
| type Error = Error; |
| |
| fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Error> |
| where |
| T: Serialize, |
| { |
| match *self { |
| SerializeMap::Map { .. } => { |
| try!(serde::ser::SerializeMap::serialize_key(self, key)); |
| serde::ser::SerializeMap::serialize_value(self, value) |
| } |
| #[cfg(feature = "arbitrary_precision")] |
| SerializeMap::Number { ref mut out_value } => { |
| if key == SERDE_STRUCT_FIELD_NAME { |
| *out_value = Some(value.serialize(NumberValueEmitter)?); |
| Ok(()) |
| } else { |
| Err(invalid_number()) |
| } |
| } |
| } |
| } |
| |
| fn end(self) -> Result<Value, Error> { |
| match self { |
| SerializeMap::Map { .. } => serde::ser::SerializeMap::end(self), |
| #[cfg(feature = "arbitrary_precision")] |
| SerializeMap::Number { out_value, .. } => { |
| Ok(out_value.expect("number value was not emitted")) |
| } |
| } |
| } |
| } |
| |
| impl serde::ser::SerializeStructVariant for SerializeStructVariant { |
| type Ok = Value; |
| type Error = Error; |
| |
| fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Error> |
| where |
| T: Serialize, |
| { |
| self.map.insert(String::from(key), try!(to_value(&value))); |
| Ok(()) |
| } |
| |
| fn end(self) -> Result<Value, Error> { |
| let mut object = Map::new(); |
| |
| object.insert(self.name, Value::Object(self.map)); |
| |
| Ok(Value::Object(object)) |
| } |
| } |
| |
| #[cfg(feature = "arbitrary_precision")] |
| struct NumberValueEmitter; |
| |
| #[cfg(feature = "arbitrary_precision")] |
| fn invalid_number() -> Error { |
| Error::syntax(ErrorCode::InvalidNumber, 0, 0) |
| } |
| |
| #[cfg(feature = "arbitrary_precision")] |
| impl ser::Serializer for NumberValueEmitter { |
| type Ok = Value; |
| type Error = Error; |
| |
| type SerializeSeq = Impossible<Value, Error>; |
| type SerializeTuple = Impossible<Value, Error>; |
| type SerializeTupleStruct = Impossible<Value, Error>; |
| type SerializeTupleVariant = Impossible<Value, Error>; |
| type SerializeMap = Impossible<Value, Error>; |
| type SerializeStruct = Impossible<Value, Error>; |
| type SerializeStructVariant = Impossible<Value, Error>; |
| |
| fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> { |
| Err(invalid_number()) |
| } |
| |
| fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> { |
| Err(invalid_number()) |
| } |
| |
| fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> { |
| Err(invalid_number()) |
| } |
| |
| fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> { |
| Err(invalid_number()) |
| } |
| |
| fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> { |
| Err(invalid_number()) |
| } |
| |
| fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> { |
| Err(invalid_number()) |
| } |
| |
| fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> { |
| Err(invalid_number()) |
| } |
| |
| fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> { |
| Err(invalid_number()) |
| } |
| |
| fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> { |
| Err(invalid_number()) |
| } |
| |
| fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> { |
| Err(invalid_number()) |
| } |
| |
| fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> { |
| Err(invalid_number()) |
| } |
| |
| fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> { |
| Err(invalid_number()) |
| } |
| |
| fn serialize_str(self, value: &str) -> Result<Self::Ok, Self::Error> { |
| let n = try!(value.to_owned().parse()); |
| Ok(Value::Number(n)) |
| } |
| |
| fn serialize_bytes(self, _value: &[u8]) -> Result<Self::Ok, Self::Error> { |
| Err(invalid_number()) |
| } |
| |
| fn serialize_none(self) -> Result<Self::Ok, Self::Error> { |
| Err(invalid_number()) |
| } |
| |
| fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<Self::Ok, Self::Error> |
| where |
| T: Serialize, |
| { |
| Err(invalid_number()) |
| } |
| |
| fn serialize_unit(self) -> Result<Self::Ok, Self::Error> { |
| Err(invalid_number()) |
| } |
| |
| fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> { |
| Err(invalid_number()) |
| } |
| |
| fn serialize_unit_variant( |
| self, |
| _name: &'static str, |
| _variant_index: u32, |
| _variant: &'static str, |
| ) -> Result<Self::Ok, Self::Error> { |
| Err(invalid_number()) |
| } |
| |
| fn serialize_newtype_struct<T: ?Sized>( |
| self, |
| _name: &'static str, |
| _value: &T, |
| ) -> Result<Self::Ok, Self::Error> |
| where |
| T: Serialize, |
| { |
| Err(invalid_number()) |
| } |
| |
| fn serialize_newtype_variant<T: ?Sized>( |
| self, |
| _name: &'static str, |
| _variant_index: u32, |
| _variant: &'static str, |
| _value: &T, |
| ) -> Result<Self::Ok, Self::Error> |
| where |
| T: Serialize, |
| { |
| Err(invalid_number()) |
| } |
| |
| fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> { |
| Err(invalid_number()) |
| } |
| |
| fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> { |
| Err(invalid_number()) |
| } |
| |
| fn serialize_tuple_struct( |
| self, |
| _name: &'static str, |
| _len: usize, |
| ) -> Result<Self::SerializeTupleStruct, Self::Error> { |
| Err(invalid_number()) |
| } |
| |
| fn serialize_tuple_variant( |
| self, |
| _name: &'static str, |
| _variant_index: u32, |
| _variant: &'static str, |
| _len: usize, |
| ) -> Result<Self::SerializeTupleVariant, Self::Error> { |
| Err(invalid_number()) |
| } |
| |
| fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> { |
| Err(invalid_number()) |
| } |
| |
| fn serialize_struct( |
| self, |
| _name: &'static str, |
| _len: usize, |
| ) -> Result<Self::SerializeStruct, Self::Error> { |
| Err(invalid_number()) |
| } |
| |
| fn serialize_struct_variant( |
| self, |
| _name: &'static str, |
| _variant_index: u32, |
| _variant: &'static str, |
| _len: usize, |
| ) -> Result<Self::SerializeStructVariant, Self::Error> { |
| Err(invalid_number()) |
| } |
| } |