1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

use super::SizeHint;

use bytes::{Buf, BufMut, Bytes, BytesMut};

/// Conversion from a `BufStream`.
///
/// By implementing `FromBufStream` for a type, you define how it will be
/// created from a buf stream. This is common for types which describe byte
/// storage of some kind.
///
/// `FromBufStream` is rarely called explicitly, and it is instead used through
/// `BufStream`'s `collect` method.
pub trait FromBufStream {
    /// Type that is used to build `Self` while the `BufStream` is being
    /// consumed.
    type Builder;

    /// Create a new, empty, builder. The provided `hint` can be used to inform
    /// reserving capacity.
    fn builder(hint: &SizeHint) -> Self::Builder;

    /// Extend the builder with the `Buf`.
    ///
    /// This method is called whenever a new `Buf` value is obtained from the
    /// buf stream.
    fn extend<T: Buf>(builder: &mut Self::Builder, buf: &mut T);

    /// Finalize the building of `Self`.
    ///
    /// Called once the buf stream is fully consumed.
    fn build(builder: Self::Builder) -> Self;
}

impl FromBufStream for Vec<u8> {
    type Builder = Vec<u8>;

    fn builder(hint: &SizeHint) -> Vec<u8> {
        Vec::with_capacity(hint.lower())
    }

    fn extend<T: Buf>(builder: &mut Self, buf: &mut T) {
        builder.put(buf);
    }

    fn build(builder: Self) -> Self {
        builder
    }
}

impl FromBufStream for Bytes {
    type Builder = BytesMut;

    fn builder(hint: &SizeHint) -> BytesMut {
        BytesMut::with_capacity(hint.lower())
    }

    fn extend<T: Buf>(builder: &mut Self::Builder, buf: &mut T) {
        builder.put(buf);
    }

    fn build(builder: Self::Builder) -> Self {
        builder.freeze()
    }
}