Skip to content

Commit a1a6f63

Browse files
TroyKomodoTroyKomodo
committed
small cleanup
1 parent ec7901d commit a1a6f63

File tree

2 files changed

+63
-148
lines changed

2 files changed

+63
-148
lines changed

‎crates/amf0/src/de/mod.rs‎

Lines changed: 47 additions & 128 deletions
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,7 @@ use scuffle_bytes_util::zero_copy::ZeroCopyReader;
66
use serde::de::{EnumAccess, IntoDeserializer, MapAccess, SeqAccess, VariantAccess};
77

88
use crate::decoder::{Amf0Decoder, ObjectHeader};
9-
use crate::{Amf0Error, Amf0Marker};
9+
use crate::{Amf0Error, Amf0Marker, Amf0Value};
1010

1111
mod stream;
1212

@@ -71,6 +71,8 @@ where
7171

7272
serde::forward_to_deserialize_any! {
7373
tuple tuple_struct ignored_any identifier
74+
str string seq map unit unit_struct bool
75+
f64 struct
7476
}
7577

7678
impl_de_number!(deserialize_i8, visit_i8);
@@ -91,59 +93,36 @@ where
9193

9294
impl_de_number!(deserialize_f32, visit_f32);
9395

94-
fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
95-
where
96-
V: serde::de::Visitor<'de>,
97-
{
98-
if let Amf0Marker::Number | Amf0Marker::Date = self.peek_marker()? {
99-
visitor.visit_f64(self.decode_number()?)
100-
} else {
101-
self.deserialize_any(visitor)
102-
}
103-
}
104-
105-
fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
96+
fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
10697
where
10798
V: serde::de::Visitor<'de>,
10899
{
109-
if let Amf0Marker::String | Amf0Marker::LongString | Amf0Marker::XmlDocument = self.peek_marker()? {
110-
let value = self.decode_string()?;
111-
value.into_deserializer().deserialize_any(visitor)
100+
if let Amf0Marker::StrictArray = self.peek_marker()? {
101+
let array = self.decode_strict_array()?;
102+
match array
103+
.iter()
104+
.map(|a| match a {
105+
Amf0Value::Number(n) => num_traits::cast(*n).ok_or(()),
106+
_ => Err(()),
107+
})
108+
.collect::<Result<_, _>>()
109+
{
110+
Ok(buf) => visitor.visit_byte_buf(buf),
111+
Err(()) => Amf0Value::Array(array).deserialize_any(visitor),
112+
}
112113
} else {
113114
self.deserialize_any(visitor)
114115
}
115116
}
116117

117-
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
118-
where
119-
V: serde::de::Visitor<'de>,
120-
{
121-
let marker = self.peek_marker()?;
122-
123-
match marker {
124-
Amf0Marker::Boolean => self.deserialize_bool(visitor),
125-
Amf0Marker::Number | Amf0Marker::Date => self.deserialize_f64(visitor),
126-
Amf0Marker::String | Amf0Marker::LongString | Amf0Marker::XmlDocument => self.deserialize_str(visitor),
127-
Amf0Marker::Null | Amf0Marker::Undefined => self.deserialize_unit(visitor),
128-
Amf0Marker::Object | Amf0Marker::TypedObject | Amf0Marker::EcmaArray => self.deserialize_map(visitor),
129-
Amf0Marker::StrictArray => self.deserialize_seq(visitor),
130-
_ => Err(Amf0Error::UnsupportedMarker(marker)),
131-
}
132-
}
133-
134-
fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
118+
fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
135119
where
136120
V: serde::de::Visitor<'de>,
137121
{
138-
if let Amf0Marker::Boolean = self.peek_marker()? {
139-
let value = self.decode_boolean()?;
140-
visitor.visit_bool(value)
141-
} else {
142-
self.deserialize_any(visitor)
143-
}
122+
self.deserialize_byte_buf(visitor)
144123
}
145124

146-
fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
125+
fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
147126
where
148127
V: serde::de::Visitor<'de>,
149128
{
@@ -155,32 +134,38 @@ where
155134
}
156135
}
157136

158-
fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
137+
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
159138
where
160139
V: serde::de::Visitor<'de>,
161140
{
162-
self.deserialize_string(visitor)
163-
}
141+
let marker = self.peek_marker()?;
164142

165-
fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
166-
where
167-
V: serde::de::Visitor<'de>,
168-
{
169-
if let Amf0Marker::StrictArray = self.peek_marker()? {
170-
self.deserialize_seq(visitor)
171-
} else {
172-
self.deserialize_any(visitor)
173-
}
174-
}
143+
match marker {
144+
Amf0Marker::Boolean => visitor.visit_bool(self.decode_boolean()?),
145+
Amf0Marker::Number | Amf0Marker::Date => visitor.visit_f64(self.decode_number()?),
146+
Amf0Marker::String | Amf0Marker::LongString | Amf0Marker::XmlDocument => {
147+
self.decode_string()?.into_deserializer().deserialize_any(visitor)
148+
}
149+
Amf0Marker::Null | Amf0Marker::Undefined => visitor.visit_unit(),
150+
Amf0Marker::Object | Amf0Marker::TypedObject | Amf0Marker::EcmaArray => {
151+
let header = self.decode_object_header()?;
152+
match header {
153+
ObjectHeader::Object | ObjectHeader::TypedObject { .. } => visitor.visit_map(Object { de: self }),
154+
ObjectHeader::EcmaArray { size } => visitor.visit_map(EcmaArray {
155+
de: self,
156+
remaining: size as usize,
157+
}),
158+
}
159+
}
160+
Amf0Marker::StrictArray => {
161+
let size = self.decode_strict_array_header()? as usize;
175162

176-
fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
177-
where
178-
V: serde::de::Visitor<'de>,
179-
{
180-
if let Amf0Marker::StrictArray = self.peek_marker()? {
181-
self.deserialize_seq(visitor)
182-
} else {
183-
self.deserialize_any(visitor)
163+
visitor.visit_seq(StrictArray {
164+
de: self,
165+
remaining: size,
166+
})
167+
}
168+
_ => Err(Amf0Error::UnsupportedMarker(marker)),
184169
}
185170
}
186171

@@ -196,25 +181,6 @@ where
196181
}
197182
}
198183

199-
fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
200-
where
201-
V: serde::de::Visitor<'de>,
202-
{
203-
if let Amf0Marker::Null | Amf0Marker::Undefined = self.peek_marker()? {
204-
self.decode_null()?;
205-
visitor.visit_unit()
206-
} else {
207-
self.deserialize_any(visitor)
208-
}
209-
}
210-
211-
fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value, Self::Error>
212-
where
213-
V: serde::de::Visitor<'de>,
214-
{
215-
self.deserialize_unit(visitor)
216-
}
217-
218184
fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value, Self::Error>
219185
where
220186
V: serde::de::Visitor<'de>,
@@ -226,53 +192,6 @@ where
226192
}
227193
}
228194

229-
fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
230-
where
231-
V: serde::de::Visitor<'de>,
232-
{
233-
if let Amf0Marker::StrictArray = self.peek_marker()? {
234-
let size = self.decode_strict_array_header()? as usize;
235-
236-
visitor.visit_seq(StrictArray {
237-
de: self,
238-
remaining: size,
239-
})
240-
} else {
241-
self.deserialize_any(visitor)
242-
}
243-
}
244-
245-
fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
246-
where
247-
V: serde::de::Visitor<'de>,
248-
{
249-
if let Amf0Marker::Object | Amf0Marker::TypedObject | Amf0Marker::EcmaArray = self.peek_marker()? {
250-
let header = self.decode_object_header()?;
251-
252-
match header {
253-
ObjectHeader::Object | ObjectHeader::TypedObject { .. } => visitor.visit_map(Object { de: self }),
254-
ObjectHeader::EcmaArray { size } => visitor.visit_map(EcmaArray {
255-
de: self,
256-
remaining: size as usize,
257-
}),
258-
}
259-
} else {
260-
self.deserialize_any(visitor)
261-
}
262-
}
263-
264-
fn deserialize_struct<V>(
265-
self,
266-
_name: &'static str,
267-
_fields: &'static [&'static str],
268-
visitor: V,
269-
) -> Result<V::Value, Self::Error>
270-
where
271-
V: serde::de::Visitor<'de>,
272-
{
273-
self.deserialize_map(visitor)
274-
}
275-
276195
fn deserialize_enum<V>(
277196
self,
278197
_name: &'static str,

‎crates/amf0/src/value.rs‎

Lines changed: 16 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -292,6 +292,7 @@ macro_rules! impl_deserializer {
292292
bool f64 str string unit
293293
seq map newtype_struct tuple
294294
struct enum ignored_any identifier
295+
unit_struct tuple_struct
295296
}
296297

297298
impl_de_number!(deserialize_i8, visit_i8);
@@ -337,7 +338,21 @@ macro_rules! impl_deserializer {
337338
where
338339
V: serde::de::Visitor<'de>,
339340
{
340-
self.deserialize_seq(visitor)
341+
if let Amf0Value::Array(a) = &self {
342+
match a
343+
.iter()
344+
.map(|a| match a {
345+
Amf0Value::Number(n) => num_traits::cast(*n).ok_or(()),
346+
_ => Err(()),
347+
})
348+
.collect::<Result<_, _>>()
349+
{
350+
Ok(buf) => visitor.visit_byte_buf(buf),
351+
Err(()) => self.deserialize_any(visitor),
352+
}
353+
} else {
354+
self.deserialize_any(visitor)
355+
}
341356
}
342357

343358
fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
@@ -347,25 +362,6 @@ macro_rules! impl_deserializer {
347362
self.deserialize_seq(visitor)
348363
}
349364

350-
fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value, Self::Error>
351-
where
352-
V: serde::de::Visitor<'de>,
353-
{
354-
self.deserialize_unit(visitor)
355-
}
356-
357-
fn deserialize_tuple_struct<V>(
358-
self,
359-
_name: &'static str,
360-
len: usize,
361-
visitor: V,
362-
) -> Result<V::Value, Self::Error>
363-
where
364-
V: serde::de::Visitor<'de>,
365-
{
366-
self.deserialize_tuple(len, visitor)
367-
}
368-
369365
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
370366
where
371367
V: serde::de::Visitor<'de>,

0 commit comments

Comments
 (0)