serde_name/
ser_adapter.rs

1// Copyright (c) Facebook, Inc. and its affiliates
2// SPDX-License-Identifier: MIT OR Apache-2.0
3
4use serde::Serialize;
5
6/// An adapter for `serde::ser::Serializer` implementations that lets you override the
7/// name of the top-level container.
8pub struct SerializeNameAdapter<S> {
9    inner: S,
10    name: &'static str,
11}
12
13impl<S> SerializeNameAdapter<S> {
14    pub fn new(inner: S, name: &'static str) -> Self {
15        Self { inner, name }
16    }
17}
18
19macro_rules! declare_serialize {
20    ($method:ident, $type:ty) => {
21        fn $method(self, content: $type) -> Result<Self::Ok, Self::Error> {
22            self.inner.$method(content)
23        }
24    };
25}
26
27impl<S> serde::ser::Serializer for SerializeNameAdapter<S>
28where
29    S: serde::ser::Serializer,
30{
31    type Ok = S::Ok;
32    type Error = S::Error;
33    type SerializeSeq = S::SerializeSeq;
34    type SerializeTuple = S::SerializeTuple;
35    type SerializeTupleStruct = S::SerializeTupleStruct;
36    type SerializeTupleVariant = S::SerializeTupleVariant;
37    type SerializeMap = S::SerializeMap;
38    type SerializeStruct = S::SerializeStruct;
39    type SerializeStructVariant = S::SerializeStructVariant;
40
41    declare_serialize!(serialize_bool, bool);
42    declare_serialize!(serialize_i8, i8);
43    declare_serialize!(serialize_i16, i16);
44    declare_serialize!(serialize_i32, i32);
45    declare_serialize!(serialize_i64, i64);
46    declare_serialize!(serialize_i128, i128);
47    declare_serialize!(serialize_u8, u8);
48    declare_serialize!(serialize_u16, u16);
49    declare_serialize!(serialize_u32, u32);
50    declare_serialize!(serialize_u64, u64);
51    declare_serialize!(serialize_u128, u128);
52    declare_serialize!(serialize_f32, f32);
53    declare_serialize!(serialize_f64, f64);
54    declare_serialize!(serialize_char, char);
55    declare_serialize!(serialize_str, &str);
56    declare_serialize!(serialize_bytes, &[u8]);
57
58    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
59        self.inner.serialize_none()
60    }
61
62    fn serialize_some<T>(self, content: &T) -> Result<Self::Ok, Self::Error>
63    where
64        T: ?Sized + Serialize,
65    {
66        self.inner.serialize_some(content)
67    }
68
69    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
70        self.inner.serialize_unit()
71    }
72
73    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
74        self.inner.serialize_unit_struct(self.name)
75    }
76
77    fn serialize_unit_variant(
78        self,
79        _name: &'static str,
80        variant_index: u32,
81        variant_name: &'static str,
82    ) -> Result<Self::Ok, Self::Error> {
83        self.inner
84            .serialize_unit_variant(self.name, variant_index, variant_name)
85    }
86
87    fn serialize_newtype_struct<T>(
88        self,
89        _name: &'static str,
90        content: &T,
91    ) -> Result<Self::Ok, Self::Error>
92    where
93        T: ?Sized + Serialize,
94    {
95        self.inner.serialize_newtype_struct(self.name, content)
96    }
97
98    fn serialize_newtype_variant<T>(
99        self,
100        _name: &'static str,
101        variant_index: u32,
102        variant_name: &'static str,
103        content: &T,
104    ) -> Result<Self::Ok, Self::Error>
105    where
106        T: ?Sized + Serialize,
107    {
108        self.inner
109            .serialize_newtype_variant(self.name, variant_index, variant_name, content)
110    }
111
112    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
113        self.inner.serialize_seq(len)
114    }
115
116    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
117        self.inner.serialize_tuple(len)
118    }
119
120    fn serialize_tuple_struct(
121        self,
122        _name: &'static str,
123        len: usize,
124    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
125        self.inner.serialize_tuple_struct(self.name, len)
126    }
127
128    fn serialize_tuple_variant(
129        self,
130        _name: &'static str,
131        variant_index: u32,
132        variant_name: &'static str,
133        len: usize,
134    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
135        self.inner
136            .serialize_tuple_variant(self.name, variant_index, variant_name, len)
137    }
138
139    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
140        self.inner.serialize_map(len)
141    }
142
143    fn serialize_struct(
144        self,
145        _name: &'static str,
146        len: usize,
147    ) -> Result<Self::SerializeStruct, Self::Error> {
148        self.inner.serialize_struct(self.name, len)
149    }
150
151    fn serialize_struct_variant(
152        self,
153        _name: &'static str,
154        variant_index: u32,
155        variant_name: &'static str,
156        len: usize,
157    ) -> Result<Self::SerializeStructVariant, Self::Error> {
158        self.inner
159            .serialize_struct_variant(self.name, variant_index, variant_name, len)
160    }
161
162    fn is_human_readable(&self) -> bool {
163        self.inner.is_human_readable()
164    }
165}
serde_name/ser_adapter.rs

serde_name/
ser_adapter.rs
