1use std::io;
4
5use serde::{de, ser};
6use serde_derive::{Deserialize, Serialize};
7
8use crate::{
9 de::Deserializer,
10 error::{Result, SpannedResult},
11 extensions::Extensions,
12 ser::{PrettyConfig, Serializer},
13};
14
15#[derive(Clone, Debug, Serialize, Deserialize)]
31#[serde(default)]
32#[non_exhaustive]
33pub struct Options {
34 pub default_extensions: Extensions,
42 pub recursion_limit: Option<usize>,
48}
49
50impl Default for Options {
51 fn default() -> Self {
52 Self {
53 default_extensions: Extensions::empty(),
54 recursion_limit: Some(128),
55 }
56 }
57}
58
59impl Options {
60 #[must_use]
61 pub fn with_default_extension(mut self, default_extension: Extensions) -> Self {
63 self.default_extensions |= default_extension;
64 self
65 }
66
67 #[must_use]
68 pub fn without_default_extension(mut self, default_extension: Extensions) -> Self {
70 self.default_extensions &= !default_extension;
71 self
72 }
73
74 #[must_use]
75 pub fn with_recursion_limit(mut self, recursion_limit: usize) -> Self {
77 self.recursion_limit = Some(recursion_limit);
78 self
79 }
80
81 #[must_use]
82 pub fn without_recursion_limit(mut self) -> Self {
87 self.recursion_limit = None;
88 self
89 }
90}
91
92impl Options {
93 pub fn from_reader<R, T>(&self, mut rdr: R) -> SpannedResult<T>
96 where
97 R: io::Read,
98 T: de::DeserializeOwned,
99 {
100 let mut bytes = Vec::new();
101 rdr.read_to_end(&mut bytes)?;
102
103 self.from_bytes(&bytes)
104 }
105
106 pub fn from_str<'a, T>(&self, s: &'a str) -> SpannedResult<T>
109 where
110 T: de::Deserialize<'a>,
111 {
112 self.from_bytes(s.as_bytes())
113 }
114
115 pub fn from_bytes<'a, T>(&self, s: &'a [u8]) -> SpannedResult<T>
118 where
119 T: de::Deserialize<'a>,
120 {
121 self.from_bytes_seed(s, std::marker::PhantomData)
122 }
123
124 pub fn from_reader_seed<R, S, T>(&self, mut rdr: R, seed: S) -> SpannedResult<T>
128 where
129 R: io::Read,
130 S: for<'a> de::DeserializeSeed<'a, Value = T>,
131 {
132 let mut bytes = Vec::new();
133 rdr.read_to_end(&mut bytes)?;
134
135 self.from_bytes_seed(&bytes, seed)
136 }
137
138 pub fn from_str_seed<'a, S, T>(&self, s: &'a str, seed: S) -> SpannedResult<T>
142 where
143 S: de::DeserializeSeed<'a, Value = T>,
144 {
145 self.from_bytes_seed(s.as_bytes(), seed)
146 }
147
148 pub fn from_bytes_seed<'a, S, T>(&self, s: &'a [u8], seed: S) -> SpannedResult<T>
152 where
153 S: de::DeserializeSeed<'a, Value = T>,
154 {
155 let mut deserializer = Deserializer::from_bytes_with_options(s, self.clone())?;
156
157 let value = seed
158 .deserialize(&mut deserializer)
159 .map_err(|e| deserializer.span_error(e))?;
160
161 deserializer.end().map_err(|e| deserializer.span_error(e))?;
162
163 Ok(value)
164 }
165
166 pub fn to_writer<W, T>(&self, writer: W, value: &T) -> Result<()>
172 where
173 W: io::Write,
174 T: ?Sized + ser::Serialize,
175 {
176 let mut s = Serializer::with_options(writer, None, self.clone())?;
177 value.serialize(&mut s)
178 }
179
180 pub fn to_writer_pretty<W, T>(&self, writer: W, value: &T, config: PrettyConfig) -> Result<()>
182 where
183 W: io::Write,
184 T: ?Sized + ser::Serialize,
185 {
186 let mut s = Serializer::with_options(writer, Some(config), self.clone())?;
187 value.serialize(&mut s)
188 }
189
190 pub fn to_string<T>(&self, value: &T) -> Result<String>
196 where
197 T: ?Sized + ser::Serialize,
198 {
199 let mut output = Vec::new();
200 let mut s = Serializer::with_options(&mut output, None, self.clone())?;
201 value.serialize(&mut s)?;
202 Ok(String::from_utf8(output).expect("Ron should be utf-8"))
203 }
204
205 pub fn to_string_pretty<T>(&self, value: &T, config: PrettyConfig) -> Result<String>
207 where
208 T: ?Sized + ser::Serialize,
209 {
210 let mut output = Vec::new();
211 let mut s = Serializer::with_options(&mut output, Some(config), self.clone())?;
212 value.serialize(&mut s)?;
213 Ok(String::from_utf8(output).expect("Ron should be utf-8"))
214 }
215}