Skip to content

Commit 19cf429

Browse files
philipch07philipch07
committed
some progress but unsure how to continue
1 parent f287422 commit 19cf429

File tree

2 files changed

+110
-84
lines changed

2 files changed

+110
-84
lines changed

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

Lines changed: 109 additions & 76 deletions
Original file line numberDiff line numberDiff line change
@@ -12,27 +12,6 @@ mod stream;
1212

1313
pub use stream::*;
1414

15-
#[cfg(feature = "serde")]
16-
#[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
17-
macro_rules! impl_de_number {
18-
($deserializser_fn:ident, $visit_fn:ident) => {
19-
fn $deserializser_fn<V>(self, visitor: V) -> Result<V::Value, Self::Error>
20-
where
21-
V: serde::de::Visitor<'de>,
22-
{
23-
if let Some(Amf0Marker::Number) = self.next_marker {
24-
// must make sure the marker is a number so we don't error out
25-
let value = self.decode_number()?;
26-
if let Some(value) = ::num_traits::cast(value) {
27-
return visitor.$visit_fn(value);
28-
}
29-
}
30-
31-
self.deserialize_any(visitor)
32-
}
33-
};
34-
}
35-
3615
/// Deserialize a value from a given [`bytes::Buf`].
3716
pub fn from_buf<'de, T>(buf: impl bytes::Buf) -> crate::Result<T>
3817
where
@@ -63,14 +42,35 @@ where
6342
Ok(value)
6443
}
6544

45+
#[cfg(feature = "serde")]
46+
#[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
47+
macro_rules! impl_de_number {
48+
($deserializser_fn:ident, $visit_fn:ident) => {
49+
fn $deserializser_fn<V>(self, visitor: V) -> Result<V::Value, Self::Error>
50+
where
51+
V: serde::de::Visitor<'de>,
52+
{
53+
if let Some(Amf0Marker::Number) = self.next_marker {
54+
// must make sure the marker is a number so we don't error out
55+
let value = self.decode_number()?;
56+
if let Some(value) = ::num_traits::cast(value) {
57+
return visitor.$visit_fn(value);
58+
}
59+
}
60+
61+
self.deserialize_any(visitor)
62+
}
63+
};
64+
}
65+
6666
impl<'de, R> serde::de::Deserializer<'de> for &mut Amf0Decoder<R>
6767
where
6868
R: ZeroCopyReader<'de>,
6969
{
7070
type Error = Amf0Error;
7171

7272
serde::forward_to_deserialize_any! {
73-
f64
73+
f64 ignored_any
7474
}
7575

7676
impl_de_number!(deserialize_i8, visit_i8);
@@ -112,47 +112,62 @@ where
112112
where
113113
V: serde::de::Visitor<'de>,
114114
{
115-
// TODO: check everything before calling decode
116-
let value = self.decode_boolean()?;
117-
visitor.visit_bool(value)
115+
if let Some(Amf0Marker::Boolean) = self.next_marker {
116+
let value = self.decode_boolean()?;
117+
return visitor.visit_bool(value);
118+
}
119+
self.deserialize_any(visitor)
118120
}
119121

120-
fn deserialize_char<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
122+
fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
121123
where
122124
V: serde::de::Visitor<'de>,
123125
{
124-
// should we still error here?
125-
Err(Amf0Error::CharNotSupported)
126+
// should we still error here? original line below
127+
// Err(Amf0Error::CharNotSupported)
128+
self.deserialize_any(visitor)
126129
}
127130

128131
fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
129132
where
130133
V: serde::de::Visitor<'de>,
131134
{
132-
let value = self.decode_string()?;
133-
value.into_deserializer().deserialize_string(visitor)
135+
if let Some(Amf0Marker::String) = self.next_marker {
136+
let value = self.decode_string()?;
137+
return value.into_deserializer().deserialize_string(visitor);
138+
}
139+
self.deserialize_any(visitor)
134140
}
135141

136142
fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
137143
where
138144
V: serde::de::Visitor<'de>,
139145
{
140-
let value = self.decode_string()?;
141-
value.into_deserializer().deserialize_str(visitor)
146+
if let Some(Amf0Marker::String) = self.next_marker {
147+
let value = self.decode_string()?;
148+
return value.into_deserializer().deserialize_str(visitor);
149+
}
150+
self.deserialize_any(visitor)
142151
}
143152

144153
fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
145154
where
146155
V: serde::de::Visitor<'de>,
147156
{
148-
self.deserialize_seq(visitor)
157+
if let Some(Amf0Marker::StrictArray) = self.next_marker {
158+
return self.deserialize_seq(visitor);
159+
}
160+
self.deserialize_any(visitor)
149161
}
150162

151163
fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
152164
where
153165
V: serde::de::Visitor<'de>,
154166
{
155-
self.deserialize_seq(visitor)
167+
if let Some(Amf0Marker::StrictArray) = self.next_marker {
168+
return self.deserialize_seq(visitor);
169+
}
170+
self.deserialize_any(visitor)
156171
}
157172

158173
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
@@ -174,79 +189,97 @@ where
174189
where
175190
V: serde::de::Visitor<'de>,
176191
{
177-
self.decode_null()?;
178-
visitor.visit_unit()
192+
if let Some(Amf0Marker::Null | Amf0Marker::Undefined) = self.next_marker {
193+
self.decode_null()?;
194+
return visitor.visit_unit();
195+
}
196+
self.deserialize_any(visitor)
179197
}
180198

181199
fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value, Self::Error>
182200
where
183201
V: serde::de::Visitor<'de>,
184202
{
185-
self.deserialize_unit(visitor)
203+
if let Some(Amf0Marker::Null | Amf0Marker::Undefined) = self.next_marker {
204+
return self.deserialize_unit(visitor);
205+
}
206+
self.deserialize_any(visitor)
186207
}
187208

188209
fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value, Self::Error>
189210
where
190211
V: serde::de::Visitor<'de>,
191212
{
192-
if name == stream::MULTI_VALUE_NEW_TYPE {
193-
visitor.visit_seq(MultiValueDe { de: self })
194-
} else {
195-
visitor.visit_newtype_struct(self)
213+
match (self.next_marker, name) {
214+
(Some(Amf0Marker::StrictArray), stream::MULTI_VALUE_NEW_TYPE) => visitor.visit_seq(MultiValueDe { de: self }),
215+
_ => visitor.visit_newtype_struct(self),
196216
}
197217
}
198218

199219
fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
200220
where
201221
V: serde::de::Visitor<'de>,
202222
{
203-
let size = self.decode_strict_array_header()? as usize;
223+
if let Some(Amf0Marker::StrictArray) = self.next_marker {
224+
let size = self.decode_strict_array_header()? as usize;
204225

205-
visitor.visit_seq(StrictArray {
206-
de: self,
207-
remaining: size,
208-
})
226+
return visitor.visit_seq(StrictArray {
227+
de: self,
228+
remaining: size,
229+
});
230+
}
231+
self.deserialize_any(visitor)
209232
}
210233

211-
fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
234+
fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
212235
where
213236
V: serde::de::Visitor<'de>,
214237
{
215-
let size = self.decode_strict_array_header()? as usize;
216-
217-
if len != size {
218-
return Err(Amf0Error::WrongArrayLength {
219-
expected: len,
220-
got: size,
238+
if let Some(Amf0Marker::StrictArray) = self.next_marker {
239+
let size = self.decode_strict_array_header()? as usize;
240+
241+
// there used to be this check, but we shouldn't error from deserializing...
242+
// if len != size {
243+
// return Err(Amf0Error::WrongArrayLength {
244+
// expected: len,
245+
// got: size,
246+
// });
247+
// }
248+
249+
return visitor.visit_seq(StrictArray {
250+
de: self,
251+
remaining: size,
221252
});
222253
}
223-
224-
visitor.visit_seq(StrictArray {
225-
de: self,
226-
remaining: size,
227-
})
254+
self.deserialize_any(visitor)
228255
}
229256

230257
fn deserialize_tuple_struct<V>(self, _name: &'static str, len: usize, visitor: V) -> Result<V::Value, Self::Error>
231258
where
232259
V: serde::de::Visitor<'de>,
233260
{
234-
self.deserialize_tuple(len, visitor)
261+
if let Some(Amf0Marker::StrictArray) = self.next_marker {
262+
return self.deserialize_tuple(len, visitor);
263+
}
264+
self.deserialize_any(visitor)
235265
}
236266

237267
fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
238268
where
239269
V: serde::de::Visitor<'de>,
240270
{
241-
let header = self.decode_object_header()?;
242-
243-
match header {
244-
ObjectHeader::Object | ObjectHeader::TypedObject { .. } => visitor.visit_map(Object { de: self }),
245-
ObjectHeader::EcmaArray { size } => visitor.visit_map(EcmaArray {
246-
de: self,
247-
remaining: size as usize,
248-
}),
271+
if let Some(Amf0Marker::Object) = self.next_marker {
272+
let header = self.decode_object_header()?;
273+
274+
return match header {
275+
ObjectHeader::Object | ObjectHeader::TypedObject { .. } => visitor.visit_map(Object { de: self }),
276+
ObjectHeader::EcmaArray { size } => visitor.visit_map(EcmaArray {
277+
de: self,
278+
remaining: size as usize,
279+
}),
280+
};
249281
}
282+
self.deserialize_any(visitor)
250283
}
251284

252285
fn deserialize_struct<V>(
@@ -258,7 +291,10 @@ where
258291
where
259292
V: serde::de::Visitor<'de>,
260293
{
261-
self.deserialize_map(visitor)
294+
if let Some(Amf0Marker::Object) = self.next_marker {
295+
return self.deserialize_map(visitor);
296+
}
297+
self.deserialize_any(visitor)
262298
}
263299

264300
fn deserialize_enum<V>(
@@ -270,21 +306,18 @@ where
270306
where
271307
V: serde::de::Visitor<'de>,
272308
{
309+
// what marker would this have?
273310
visitor.visit_enum(Enum { de: self })
274311
}
275312

276313
fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
277314
where
278315
V: serde::de::Visitor<'de>,
279316
{
280-
let s = self.decode_string()?;
281-
s.into_deserializer().deserialize_identifier(visitor)
282-
}
283-
284-
fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
285-
where
286-
V: serde::de::Visitor<'de>,
287-
{
317+
if let Some(Amf0Marker::String | Amf0Marker::LongString) = self.next_marker {
318+
let s = self.decode_string()?;
319+
return s.into_deserializer().deserialize_identifier(visitor);
320+
}
288321
self.deserialize_any(visitor)
289322
}
290323
}

‎crates/amf0/src/value.rs‎

Lines changed: 1 addition & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -307,7 +307,7 @@ impl<'de, 'a: 'de> serde::Deserializer<'de> for &'a Amf0Value<'de> {
307307
serde::forward_to_deserialize_any! {
308308
bool f64 char str string unit
309309
seq map newtype_struct tuple
310-
struct enum identifier
310+
struct enum ignored_any identifier
311311
}
312312

313313
impl_de_number!(deserialize_i8, visit_i8);
@@ -366,13 +366,6 @@ impl<'de, 'a: 'de> serde::Deserializer<'de> for &'a Amf0Value<'de> {
366366
self.deserialize_tuple(len, visitor)
367367
}
368368

369-
fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
370-
where
371-
V: serde::de::Visitor<'de>,
372-
{
373-
self.deserialize_any(visitor)
374-
}
375-
376369
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
377370
where
378371
V: serde::de::Visitor<'de>,

0 commit comments

Comments
 (0)