Skip to content

Commit 74652e6

Browse files
canorizcanoriz
committed
WIP: ai makes it work, check
1 parent ab1f538 commit 74652e6

4 files changed

Lines changed: 623 additions & 60 deletions

File tree

‎src/de.rs‎

Lines changed: 70 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -263,6 +263,62 @@ impl<'a> Deserializer<read::SliceRead<'a>> {
263263
}
264264
}
265265

266+
impl<'de, R: Read<'de>> Deserializer<R> {
267+
// #[cfg(feature = "raw_value")]
268+
fn deserialize_raw_value<V>(&mut self, visitor: V) -> Result<V::Value>
269+
where
270+
V: de::Visitor<'de>,
271+
{
272+
self.read.begin_raw_buffering();
273+
self.ignore_value()?;
274+
self.read.end_raw_buffering(visitor)
275+
}
276+
277+
fn ignore_value(&mut self) -> Result<()> {
278+
match self.parse_peek()? {
279+
b'0'..=b'9' => {
280+
self.buf.clear();
281+
self.read.parse_byte_str(&mut self.buf)?;
282+
Ok(())
283+
}
284+
b'i' => {
285+
self.parse_next()?;
286+
self.parse_integer()?;
287+
Ok(())
288+
}
289+
b'l' => {
290+
self.parse_next()?;
291+
loop {
292+
if self.parse_peek()? == b'e' {
293+
self.parse_next()?;
294+
break;
295+
}
296+
self.ignore_value()?;
297+
}
298+
Ok(())
299+
}
300+
b'd' => {
301+
self.parse_next()?;
302+
loop {
303+
if self.parse_peek()? == b'e' {
304+
self.parse_next()?;
305+
break;
306+
}
307+
308+
self.buf.clear();
309+
self.read.parse_byte_str(&mut self.buf)?;
310+
self.ignore_value()?;
311+
}
312+
Ok(())
313+
}
314+
_ => Err(Error::new(
315+
ErrorKind::ExpectedSomeValue,
316+
self.read.byte_offset(),
317+
)),
318+
}
319+
}
320+
}
321+
266322
impl<'de, R: Read<'de>> de::Deserializer<'de> for &mut Deserializer<R> {
267323
type Error = Error;
268324

@@ -393,10 +449,16 @@ impl<'de, R: Read<'de>> de::Deserializer<'de> for &mut Deserializer<R> {
393449
}
394450

395451
#[inline]
396-
fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
452+
fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value>
397453
where
398454
V: de::Visitor<'de>,
399455
{
456+
// #[cfg(feature = "raw_value")]
457+
if name == crate::raw::TOKEN {
458+
return self.deserialize_raw_value(visitor);
459+
}
460+
461+
let _ = name;
400462
visitor.visit_newtype_struct(self)
401463
}
402464

@@ -481,10 +543,16 @@ where
481543
}
482544

483545
#[inline]
484-
fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
546+
fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value>
485547
where
486548
V: de::Visitor<'de>,
487549
{
550+
// #[cfg(feature = "raw_value")]
551+
if name == crate::raw::TOKEN {
552+
return self.de.deserialize_raw_value(visitor);
553+
}
554+
555+
let _ = name;
488556
visitor.visit_newtype_struct(self)
489557
}
490558

‎src/lib.rs‎

Lines changed: 9 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -105,26 +105,29 @@ extern crate alloc;
105105
#[macro_use]
106106
extern crate serde;
107107

108+
mod bipaddr;
108109
mod bstring;
109110
mod de;
110111
mod error;
111-
mod bipaddr;
112112

113113
pub mod read;
114114
pub mod write;
115115

116+
// #[cfg(feature = "raw_value")]
117+
mod raw;
118+
116119
mod ser;
117120
pub mod value;
118121

122+
#[doc(inline)]
123+
pub use bipaddr::ByteIpAddr;
119124
#[doc(inline)]
120125
pub use bstring::ByteString;
121126
#[doc(inline)]
122127
pub use de::{from_slice, Deserializer};
123128
#[doc(inline)]
124129
pub use error::{Error, ErrorKind, Result};
125130
#[doc(inline)]
126-
pub use bipaddr::ByteIpAddr;
127-
#[doc(inline)]
128131
pub use value::{from_value, to_value, Value};
129132

130133
#[doc(inline)]
@@ -137,3 +140,6 @@ pub use ser::{to_vec, Serializer};
137140
#[doc(inline)]
138141
#[cfg(feature = "std")]
139142
pub use de::from_reader;
143+
144+
// #[cfg(feature = "raw_value")]
145+
pub use raw::RawValue;

‎src/read.rs‎

Lines changed: 87 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,9 @@ use alloc::vec::Vec;
99
#[cfg(feature = "std")]
1010
use std::{io, vec::Vec};
1111

12+
// #[cfg(feature = "raw_value")]
13+
use {crate::raw::OwnedRawDeserializer, serde::de::Visitor};
14+
1215
/// A reference to borrowed data.
1316
///
1417
/// The variant determines if the slice comes from a long lived source (e.g. an
@@ -125,6 +128,21 @@ pub trait Read<'a> {
125128
/// - malformatted input
126129
/// - end of file
127130
fn parse_raw_dict<'b>(&'b mut self, buf: &'b mut Vec<u8>) -> Result<Ref<'a, 'b, [u8]>>;
131+
132+
/// Switch raw buffering mode on.
133+
///
134+
/// This is used when deserializing `RawValue`.
135+
// #[cfg(feature = "raw_value")]
136+
#[doc(hidden)]
137+
fn begin_raw_buffering(&mut self);
138+
139+
/// Switch raw buffering mode off and provides the raw buffered data to the
140+
/// given visitor.
141+
// #[cfg(feature = "raw_value")]
142+
#[doc(hidden)]
143+
fn end_raw_buffering<V>(&mut self, visitor: V) -> Result<V::Value>
144+
where
145+
V: Visitor<'a>;
128146
}
129147

130148
/// A wrapper to implement this crate's [Read] trait for [`std::io::Read`] trait implementations.
@@ -138,6 +156,9 @@ where
138156
iter: io::Bytes<R>,
139157
peeked_byte: Option<u8>,
140158
byte_offset: usize,
159+
160+
// #[cfg(feature = "raw_value")]
161+
raw_buffer: Option<Vec<u8>>,
141162
}
142163

143164
#[cfg(feature = "std")]
@@ -157,6 +178,9 @@ where
157178
iter: reader.bytes(),
158179
peeked_byte: None,
159180
byte_offset: 0,
181+
182+
// #[cfg(feature = "raw_value")]
183+
raw_buffer: None,
160184
}
161185
}
162186
}
@@ -170,11 +194,23 @@ where
170194
fn next(&mut self) -> Option<Result<u8>> {
171195
match self.peeked_byte.take() {
172196
Some(b) => {
197+
// #[cfg(feature = "raw_value")]
198+
{
199+
if let Some(buf) = &mut self.raw_buffer {
200+
buf.push(b);
201+
}
202+
}
173203
self.byte_offset += 1;
174204
Some(Ok(b))
175205
}
176206
None => match self.iter.next() {
177207
Some(Ok(b)) => {
208+
// #[cfg(feature = "raw_value")]
209+
{
210+
if let Some(buf) = &mut self.raw_buffer {
211+
buf.push(b);
212+
}
213+
}
178214
self.byte_offset += 1;
179215
Some(Ok(b))
180216
}
@@ -402,6 +438,22 @@ where
402438
}
403439
}
404440
}
441+
442+
// #[cfg(feature = "raw_value")]
443+
fn begin_raw_buffering(&mut self) {
444+
self.raw_buffer = Some(Vec::new());
445+
}
446+
447+
// #[cfg(feature = "raw_value")]
448+
fn end_raw_buffering<V>(&mut self, visitor: V) -> Result<V::Value>
449+
where
450+
V: Visitor<'a>,
451+
{
452+
let raw = self.raw_buffer.take().unwrap();
453+
visitor.visit_map(OwnedRawDeserializer {
454+
raw_value: Some(raw),
455+
})
456+
}
405457
}
406458

407459
/// A wrapper to implement this crate's [Read] trait for byte slices.
@@ -410,6 +462,9 @@ where
410462
pub struct SliceRead<'a> {
411463
slice: &'a [u8],
412464
byte_offset: usize,
465+
466+
// #[cfg(feature = "raw_value")]
467+
raw_buffer: Option<Vec<u8>>,
413468
}
414469

415470
impl<'a> SliceRead<'a> {
@@ -419,6 +474,9 @@ impl<'a> SliceRead<'a> {
419474
SliceRead {
420475
slice,
421476
byte_offset: 0,
477+
478+
// #[cfg(feature = "raw_value")]
479+
raw_buffer: None,
422480
}
423481
}
424482
}
@@ -428,6 +486,12 @@ impl<'a> Read<'a> for SliceRead<'a> {
428486
fn next(&mut self) -> Option<Result<u8>> {
429487
if self.byte_offset < self.slice.len() {
430488
let b = self.slice[self.byte_offset];
489+
// #[cfg(feature = "raw_value")]
490+
{
491+
if let Some(buf) = &mut self.raw_buffer {
492+
buf.push(b);
493+
}
494+
}
431495
self.byte_offset += 1;
432496
Some(Ok(b))
433497
} else {
@@ -484,6 +548,13 @@ impl<'a> Read<'a> for SliceRead<'a> {
484548
));
485549
}
486550

551+
// #[cfg(feature = "raw_value")]
552+
{
553+
if let Some(buf) = &mut self.raw_buffer {
554+
buf.extend_from_slice(&self.slice[start_idx..self.byte_offset]);
555+
}
556+
}
557+
487558
Ok(Ref::Source(&self.slice[start_idx..self.byte_offset]))
488559
}
489560

@@ -648,4 +719,20 @@ impl<'a> Read<'a> for SliceRead<'a> {
648719
}
649720
}
650721
}
722+
723+
// #[cfg(feature = "raw_value")]
724+
fn begin_raw_buffering(&mut self) {
725+
self.raw_buffer = Some(Vec::new());
726+
}
727+
728+
// #[cfg(feature = "raw_value")]
729+
fn end_raw_buffering<V>(&mut self, visitor: V) -> Result<V::Value>
730+
where
731+
V: Visitor<'a>,
732+
{
733+
let raw = self.raw_buffer.take().unwrap();
734+
visitor.visit_map(OwnedRawDeserializer {
735+
raw_value: Some(raw),
736+
})
737+
}
651738
}

0 commit comments

Comments
 (0)