1use crate::data_owned_reader::DataOwnedReader;
2use crate::{Data, DataReader};
3use anyhow::Result;
4use serde::{Deserialize, Serialize};
5
6impl Data {
10 #[cfg(all(feature = "rmp", not(feature = "json"), not(feature = "data")))]
11 #[inline]
12 pub fn pack_from<T: Serialize>(value: T) -> Result<Data> {
13 Ok(rmp_serde::encode::to_vec(&value)?.into())
14 }
15
16 #[cfg(all(feature = "rmp", not(feature = "json"), not(feature = "data")))]
17 #[inline]
18 pub fn pack_serialize<T: Serialize>(&mut self, value: T) -> Result<()> {
19 self.mode = 1;
20 let bak = self.len();
21 if self.serde_serialize(&value).is_err() {
22 self.truncate(bak);
23 self.mode = 0;
24 let buff = rmp_serde::encode::to_vec(&value)?;
25 self.write_fixed(buff);
26 }
27 Ok(())
28 }
29
30 #[cfg(all(feature = "json", feature = "rmp"))]
31 #[inline]
32 pub fn pack_from<T: Serialize>(value: T) -> Result<Data> {
33 Ok(serde_json::to_vec(&value)?.into())
34 }
35
36 #[cfg(all(feature = "json", feature = "rmp"))]
37 #[inline]
38 pub fn pack_serialize<T: Serialize>(&mut self, value: T) -> Result<()> {
39 self.mode = 1;
40 let bak = self.len();
41 if self.serde_serialize(&value).is_err() {
42 self.truncate(bak);
43 self.mode = 0;
44 let buff = serde_json::to_vec(&value)?;
45 self.write_fixed(buff);
46 }
47 self.mode = 0;
48 Ok(())
49 }
50
51 #[cfg(all(feature = "rmp", feature = "data"))]
52 #[inline]
53 pub fn pack_from<T: Serialize>(value: T) -> Result<Data> {
54 let mut data = Data::new();
55 data.pack_serialize(value)?;
56 Ok(data)
57 }
58
59 #[cfg(all(feature = "rmp", feature = "data"))]
60 #[inline]
61 pub fn pack_serialize<T: Serialize>(&mut self, value: T) -> Result<()> {
62 self.mode = 0;
63 self.serde_serialize(&value)?;
64 Ok(())
65 }
66}
67
68impl<'de, 'a: 'de> DataReader<'a> {
69 #[cfg(all(feature = "rmp", not(feature = "json"), not(feature = "data")))]
70 #[inline]
71 pub fn pack_to<'b, T: Deserialize<'de>>(&'b mut self) -> Result<T> {
72 Ok(rmp_serde::decode::from_slice(self.buff)?)
73 }
74
75 #[cfg(all(feature = "rmp", not(feature = "json"), not(feature = "data")))]
76 #[inline]
77 pub fn pack_deserialize<'b, T: Deserialize<'de>>(&'b mut self) -> Result<T> {
78 let mut check_buff = DataReader::from(self.buff);
79 check_buff.mode = 1;
80 match check_buff.serde_deserialize() {
81 Ok(value) => {
82 self.reload(check_buff.buff, check_buff.original_len);
83 Ok(value)
84 }
85 Err(_) => {
86 let buff = self.read_fixed_buf()?;
87 Ok(rmp_serde::decode::from_slice(buff)?)
88 }
89 }
90 }
91
92 #[cfg(all(feature = "json", feature = "rmp"))]
93 #[inline]
94 pub fn pack_to<'b, T: Deserialize<'de>>(&'b mut self) -> Result<T> {
95 Ok(serde_json::from_slice(self.buff)?)
96 }
97
98 #[cfg(all(feature = "json", feature = "rmp"))]
99 #[inline]
100 pub fn pack_deserialize<'b, T: Deserialize<'de>>(&'b mut self) -> Result<T> {
101 let mut check_buff = DataReader::from(self.buff);
102 check_buff.mode = 1;
103 match check_buff.serde_deserialize() {
104 Ok(value) => {
105 self.reload(check_buff.buff, check_buff.original_len);
106 Ok(value)
107 }
108 Err(_) => {
109 let buff = self.read_fixed_buf()?;
110 Ok(serde_json::from_slice(buff)?)
111 }
112 }
113 }
114
115 #[cfg(all(feature = "data", feature = "rmp"))]
116 #[inline]
117 pub fn pack_to<'b, T: Deserialize<'de>>(&'b mut self) -> Result<T> {
118 let mut rdata = DataReader::from(self.buff);
119 Ok(rdata.serde_deserialize()?)
120 }
121
122 #[cfg(all(feature = "data", feature = "rmp"))]
123 #[inline]
124 pub fn pack_deserialize<'b, T: Deserialize<'de>>(&'b mut self) -> Result<T> {
125 let mut check_buff = DataReader::from(self.buff);
126 check_buff.mode = 0;
127 let value = check_buff.serde_deserialize()?;
128 self.reload(check_buff.buff, check_buff.original_len);
129 Ok(value)
130 }
131}
132
133impl DataOwnedReader {
134 #[cfg(all(feature = "rmp", not(feature = "json"), not(feature = "data")))]
135 #[inline]
136 pub fn pack_to<'a, T: Deserialize<'a>>(&'a mut self) -> Result<T> {
137 Ok(rmp_serde::decode::from_slice(self)?)
138 }
139
140 #[cfg(all(feature = "rmp", not(feature = "json"), not(feature = "data")))]
141 #[inline]
142 pub fn pack_deserialize<'a, T: Deserialize<'a>>(&'a mut self) -> Result<T> {
143 let mut dr = DataReader::from(&self.inner[self.offset..]);
144 dr.mode = 1;
145 match dr.serde_deserialize() {
146 Ok(value) => {
147 self.offset += dr.offset();
148 Ok(value)
149 }
150 Err(_) => {
151 dr = DataReader::from(&self.inner[self.offset..]);
152 let buff = dr.read_fixed_buf()?;
153 self.offset += dr.offset();
154 Ok(rmp_serde::decode::from_slice(buff)?)
155 }
156 }
157 }
158
159 #[cfg(all(feature = "rmp", feature = "json"))]
160 #[inline]
161 pub fn pack_to<'a, T: Deserialize<'a>>(&'a mut self) -> Result<T> {
162 Ok(serde_json::from_slice(self)?)
163 }
164
165 #[cfg(all(feature = "rmp", feature = "json"))]
166 #[inline]
167 pub fn pack_deserialize<'a, T: Deserialize<'a>>(&'a mut self) -> Result<T> {
168 let mut dr = DataReader::from(&self.inner[self.offset..]);
169 dr.mode = 1;
170 match dr.serde_deserialize() {
171 Ok(value) => {
172 self.offset += dr.offset();
173 Ok(value)
174 }
175 Err(_) => {
176 dr = DataReader::from(&self.inner[self.offset..]);
177 let buff = dr.read_fixed_buf()?;
178 self.offset += dr.offset();
179 Ok(serde_json::from_slice(buff)?)
180 }
181 }
182 }
183
184 #[cfg(all(feature = "rmp", feature = "data"))]
185 #[inline]
186 pub fn pack_to<'a, T: Deserialize<'a>>(&'a mut self) -> Result<T> {
187 let mut rdata = DataReader::from(self);
188 Ok(rdata.serde_deserialize()?)
189 }
190
191 #[cfg(all(feature = "rmp", feature = "data"))]
192 #[inline]
193 pub fn pack_deserialize<'a, T: Deserialize<'a>>(&'a mut self) -> Result<T> {
194 let mut dr = DataReader::from(&self.inner[self.offset..]);
195 dr.mode = 0;
196 let value = dr.serde_deserialize()?;
197 self.offset += dr.offset();
198 Ok(value)
199 }
200}