dyer/component/
body.rs

1//! Contains some data structure that related to the content of HTTP
2//!
3//! NOTE that it is [Bytes] based, not all data structure supported
4//!
5use crate::component::utils;
6use core::ops::Deref;
7use hyper::body::{Buf, Bytes};
8use serde::de::{self, MapAccess, SeqAccess, Visitor};
9use serde::{ser::SerializeSeq, Deserialize, Deserializer, Serialize, Serializer};
10use std::collections::vec_deque::{Iter, IterMut};
11use std::marker::PhantomData;
12use std::ops::DerefMut;
13use std::{borrow::Cow, collections::VecDeque, str};
14use std::{
15    fmt,
16    hash::{Hash, Hasher},
17};
18
19/// series of [Bytes] that receives from network or to be sent
20///
21/// NOTE that it is not continous buffer
22///
23#[derive(Serialize, Clone, Default, Deserialize, fmt::Debug)]
24pub struct Body {
25    pub(crate) inner: VecDeque<Chunk>,
26}
27
28/// the types that make a [Chunk]
29#[derive(fmt::Debug, Clone)]
30pub enum Kind {
31    Byte,
32    Str,
33    String,
34    Ref8,
35    Vec8,
36    Custom,
37}
38
39/// A [Bytes] that with its origin type
40///
41/// `Kind` is used when serializing
42///
43#[derive(fmt::Debug, Clone)]
44pub struct Chunk(Bytes, Kind);
45
46impl Chunk {
47    pub fn new() -> Self {
48        Self(Bytes::new(), Kind::Byte)
49    }
50
51    pub fn inner(self) -> Bytes {
52        self.0
53    }
54}
55
56impl Deref for Chunk {
57    type Target = [u8];
58    fn deref(&self) -> &Self::Target {
59        &self.0
60    }
61}
62
63impl DerefMut for Chunk {
64    fn deref_mut(&mut self) -> &mut Self::Target {
65        unsafe { std::slice::from_raw_parts_mut(self.0.as_ptr() as *mut u8, self.0.len()) }
66    }
67}
68
69impl Buf for Body {
70    #[inline]
71    fn remaining(&self) -> usize {
72        self.inner.iter().map(|buf| buf.0.remaining()).sum()
73    }
74
75    #[inline]
76    fn chunk(&self) -> &[u8] {
77        self.inner.front().map(|b| &*b.0).unwrap_or_default()
78    }
79
80    #[inline]
81    fn advance(&mut self, mut cnt: usize) {
82        while cnt > 0 {
83            {
84                let front = &mut self.inner[0].0;
85                let rem = front.remaining();
86                if rem > cnt {
87                    front.advance(cnt);
88                    return;
89                } else {
90                    front.advance(rem);
91                    cnt -= rem;
92                }
93            }
94            self.inner.pop_front();
95        }
96    }
97
98    /*
99     *#[inline]
100     *fn bytes_vectored<'t>(&'t self, dst: &mut [IoSlice<'t>]) -> usize {
101     *    if dst.is_empty() {
102     *        return 0;
103     *    }
104     *    let mut vecs = 0;
105     *    for buf in &self.inner {
106     *        vecs += buf.0.bytes_vectored(&mut dst[vecs..]);
107     *        if vecs == dst.len() {
108     *            break;
109     *        }
110     *    }
111     *    vecs
112     *}
113     */
114}
115
116impl Hash for Body {
117    fn hash<H: Hasher>(&self, state: &mut H) {
118        for bt in &self.inner {
119            bt.0.hash(state);
120        }
121    }
122}
123
124impl Body {
125    pub fn new(chunk: Bytes) -> Self {
126        let chunk = Chunk(chunk, Kind::Byte);
127        let mut inner = VecDeque::new();
128        inner.push_back(chunk);
129        Self { inner }
130    }
131
132    pub fn empty() -> Self {
133        Self {
134            inner: VecDeque::new(),
135        }
136    }
137
138    pub fn is_empty(&self) -> bool {
139        self.inner.is_empty()
140    }
141
142    pub fn len(&self) -> usize {
143        self.inner.iter().map(|buf| buf.0.remaining()).sum()
144    }
145
146    pub fn push_back(&mut self, chunk: Chunk) {
147        self.inner.push_back(chunk);
148    }
149
150    pub fn push_front(&mut self, chunk: Chunk) {
151        self.inner.push_front(chunk);
152    }
153
154    pub fn map<F: FnMut(&mut VecDeque<Chunk>)>(&mut self, mut f: F) {
155        f(&mut self.inner)
156    }
157
158    pub fn merge<F: FnMut(&mut VecDeque<Chunk>) -> Bytes>(&mut self, mut f: F) -> Bytes {
159        f(&mut self.inner)
160    }
161
162    /// consume the body and extend the body with other body then return the result
163    pub fn get_merged(&self, other: Option<&'_ Body>) -> Body {
164        let l = if other.is_some() {
165            other.as_ref().unwrap().len()
166        } else {
167            0
168        };
169        let len = self.len() + l;
170        let mut v = VecDeque::with_capacity(len);
171        for item in self.inner.iter() {
172            v.push_back(Chunk::from(&item.0));
173        }
174        if other.is_some() {
175            for item in other.unwrap().inner.iter() {
176                v.push_back(Chunk::from(&item.0));
177            }
178        }
179        Body { inner: v }
180    }
181
182    pub fn extend<I: IntoIterator<Item = Chunk>>(&mut self, iter: I) {
183        self.inner.extend(iter);
184    }
185
186    pub fn iter(&self) -> Iter<'_, Chunk> {
187        self.inner.iter()
188    }
189
190    pub fn iter_mut(&mut self) -> IterMut<'_, Chunk> {
191        self.inner.iter_mut()
192    }
193
194    pub fn into_inner(self) -> VecDeque<Chunk> {
195        self.inner
196    }
197
198    pub fn get(&self, index: usize) -> Option<&Chunk> {
199        self.inner.get(index)
200    }
201
202    pub fn get_mut(&mut self, index: usize) -> Option<&mut Chunk> {
203        self.inner.get_mut(index)
204    }
205
206    pub fn swap(&mut self, i: usize, j: usize) {
207        self.inner.swap(i, j);
208    }
209
210    pub fn bytes(&self) -> Vec<u8> {
211        self.inner
212            .iter()
213            .flat_map(|chunk| chunk.0.slice(0..))
214            .collect()
215        //vec![]
216    }
217}
218
219#[test]
220fn test_bytes() {
221    let mut body = Body::from("Hello ");
222    body.extend([Chunk::from("World!")]);
223    assert_eq!(body.bytes()[..], b"Hello World!"[..]);
224}
225
226/*
227 *use std::iter::FromIterator;
228 *
229 *impl<'b, I> From<I> for Body
230 *where
231 *    I: std::iter::IntoIterator<Item = Chunk>,
232 *{
233 *    fn from(iter: I) -> Body {
234 *        Body {
235 *            inner: VecDeque::from_iter(iter),
236 *        }
237 *    }
238 *}
239 */
240
241impl From<Bytes> for Body {
242    fn from(chunk: Bytes) -> Body {
243        if chunk.is_empty() {
244            Body::empty()
245        } else {
246            Body::new(chunk)
247        }
248    }
249}
250
251/// Customized Visitor when deserializing
252///
253/// Note that only a few data type supported
254/////////////////// Chunk Deserializer ///////////////////
255pub struct ChunkVisitor {
256    _t: PhantomData<fn() -> Chunk>,
257}
258
259impl ChunkVisitor {
260    pub fn new() -> Self {
261        ChunkVisitor { _t: PhantomData }
262    }
263}
264
265impl<'de> Visitor<'de> for ChunkVisitor {
266    type Value = Chunk;
267
268    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
269        formatter.write_str("Chunk")
270    }
271
272    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
273    where
274        E: de::Error,
275    {
276        //let b = unsafe { v as *const [u8] as *const Bytes };
277        let s = utils::slice(v.as_ptr(), v.len());
278        Ok(Chunk(Bytes::from(s), Kind::Byte))
279    }
280
281    fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>
282    where
283        E: de::Error,
284    {
285        self.visit_bytes(v)
286    }
287
288    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
289    where
290        E: de::Error,
291    {
292        let s = utils::slice(v.as_ptr(), v.len());
293        Ok(Chunk(Bytes::from(s), Kind::Vec8))
294    }
295
296    fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
297    where
298        E: de::Error,
299    {
300        let s = utils::slice(s.as_ptr(), s.len());
301        Ok(Chunk(Bytes::from(s), Kind::Str))
302    }
303
304    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
305    where
306        E: de::Error,
307    {
308        let s = utils::slice(v.as_ptr(), v.len());
309        Ok(Chunk(Bytes::from(s), Kind::String))
310    }
311
312    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
313    where
314        A: SeqAccess<'de>,
315    {
316        let mut buf: Vec<u8> = Vec::with_capacity(seq.size_hint().unwrap_or(0));
317        while let Some(e) = seq.next_element()? {
318            //debug_assert!(e as u8);
319            buf.push(e);
320        }
321        Ok(Chunk(Bytes::from(buf), Kind::Vec8))
322
323        //Err(de::Error::invalid_type(de::Unexpected::Seq, &self))
324    }
325
326    fn visit_map<M>(self, access: M) -> Result<Self::Value, M::Error>
327    where
328        M: MapAccess<'de>,
329    {
330        let _ = access;
331        Err(de::Error::invalid_type(de::Unexpected::Map, &self))
332    }
333}
334
335impl<'de, 'b> Deserialize<'de> for Chunk {
336    fn deserialize<D>(d: D) -> Result<Self, D::Error>
337    where
338        D: Deserializer<'de>,
339    {
340        d.deserialize_any(ChunkVisitor::new())
341    }
342}
343
344impl Serialize for Chunk {
345    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
346    where
347        S: Serializer,
348    {
349        match self.1 {
350            Kind::Str | Kind::String => {
351                let v = str::from_utf8(&self.0[..]).unwrap();
352
353                s.serialize_str(v)
354            }
355            Kind::Ref8 | Kind::Vec8 => {
356                let mut ser = s.serialize_seq(Some(self.0.len())).unwrap();
357                for e in self.0.iter() {
358                    ser.serialize_element(e)?;
359                }
360                ser.end()
361            }
362            Kind::Byte => s.serialize_bytes(&self.0),
363            // Kind::Custom is not available so far
364            _ => unreachable!(),
365        }
366    }
367}
368
369/*
370 *impl<S: Serialize> From<S> for Chunk {
371 *    fn from(s: S) -> Chunk {
372 *        let ss = serde_json::to_vec(&s).unwrap();
373 *        Chunk::from(&ss)
374 *    }
375 *}
376 *
377 *impl<S: for<'d> Deserialize<'d>> Into<S> for Chunk {
378 *    fn into(self) -> S {
379 *        serde_json::from_slice::<S>(&self.0).unwrap()
380 *    }
381 *}
382 */
383
384use std::io::BufReader;
385impl<R> From<BufReader<R>> for Chunk {
386    fn from(buf: BufReader<R>) -> Chunk {
387        let buf = buf.buffer();
388        let s = utils::slice(buf.as_ptr(), buf.len());
389        Chunk(Bytes::from(s), Kind::Byte)
390    }
391}
392
393impl From<&Bytes> for Chunk {
394    fn from(buf: &Bytes) -> Chunk {
395        let s = utils::slice(buf.as_ptr(), buf.len());
396        Chunk(Bytes::from(s), Kind::Byte)
397    }
398}
399
400impl From<Vec<u8>> for Chunk {
401    fn from(u8s: Vec<u8>) -> Chunk {
402        Chunk(Bytes::from(u8s), Kind::Vec8)
403    }
404}
405
406impl From<&[u8]> for Chunk {
407    fn from(u8s: &[u8]) -> Chunk {
408        let s = utils::slice(u8s.as_ptr(), u8s.len());
409        Chunk(Bytes::from(s), Kind::Ref8)
410    }
411}
412
413impl<'b> From<Cow<'b, [u8]>> for Chunk {
414    fn from(cow: Cow<'b, [u8]>) -> Chunk {
415        match cow {
416            Cow::Borrowed(e) => Chunk(Bytes::from(utils::slice(e.as_ptr(), e.len())), Kind::Ref8),
417            Cow::Owned(e) => Chunk(Bytes::from(e), Kind::Ref8),
418        }
419    }
420}
421
422impl From<String> for Chunk {
423    fn from(s: String) -> Chunk {
424        Chunk(Bytes::from(s), Kind::String)
425    }
426}
427
428impl<'b> From<&'b str> for Chunk {
429    fn from(slice: &'b str) -> Chunk {
430        Chunk(
431            Bytes::from(utils::slice(slice.as_ptr(), slice.len())),
432            Kind::Str,
433        )
434    }
435}
436
437impl<'b> From<Cow<'b, str>> for Chunk {
438    fn from(cow: Cow<'b, str>) -> Chunk {
439        match cow {
440            Cow::Borrowed(e) => Chunk(Bytes::from(utils::slice(e.as_ptr(), e.len())), Kind::Ref8),
441            Cow::Owned(e) => Chunk(Bytes::from(e), Kind::Ref8),
442        }
443    }
444}
445
446impl From<Vec<u8>> for Body {
447    fn from(u8s: Vec<u8>) -> Body {
448        let mut inner = VecDeque::new();
449        inner.push_back(Chunk(Bytes::from(u8s), Kind::Vec8));
450        Body { inner }
451    }
452}
453
454impl<'b> From<&'b [u8]> for Body {
455    fn from(u8s: &'b [u8]) -> Body {
456        let mut inner = VecDeque::new();
457        inner.push_back(Chunk(
458            Bytes::from(utils::slice(u8s.as_ptr(), u8s.len())),
459            Kind::Ref8,
460        ));
461        Body { inner }
462    }
463}
464
465impl<'b> From<Cow<'b, [u8]>> for Body {
466    fn from(cow: Cow<'b, [u8]>) -> Body {
467        let mut inner = VecDeque::new();
468        match cow {
469            Cow::Borrowed(e) => {
470                inner.push_back(Chunk(
471                    Bytes::from(utils::slice(e.as_ptr(), e.len())),
472                    Kind::Ref8,
473                ));
474            }
475            Cow::Owned(e) => {
476                inner.push_back(Chunk(Bytes::from(e), Kind::Ref8));
477            }
478        }
479        Body { inner }
480    }
481}
482
483impl From<String> for Body {
484    fn from(s: String) -> Body {
485        let mut inner = VecDeque::new();
486        inner.push_back(Chunk(Bytes::from(s), Kind::String));
487        Body { inner }
488    }
489}
490
491impl<'b> From<&'b str> for Body {
492    fn from(slice: &'b str) -> Body {
493        let mut inner = VecDeque::new();
494        inner.push_back(Chunk(
495            Bytes::from(utils::slice(slice.as_ptr(), slice.len())),
496            Kind::Str,
497        ));
498        Body { inner }
499    }
500}
501
502impl<'b> From<Cow<'b, str>> for Body {
503    fn from(cow: Cow<'b, str>) -> Body {
504        match cow {
505            Cow::Borrowed(e) => Body::from(e),
506            Cow::Owned(e) => Body::from(e),
507        }
508    }
509}
dyer/component/body.rs

dyer/component/
body.rs
