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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

#[cfg(feature = "alloc")]
use alloc::{vec, vec::Vec};

use crate::io::ReadSimple;

use super::Decoder;

pub struct DecoderBuilder<R = (), B = ()> {
    reader: R,
    buf: B,
}

impl Default for DecoderBuilder {
    fn default() -> Self {
        Self {
            reader: (),
            buf: (),
        }
    }
}

impl DecoderBuilder<(), ()> {
    #[deprecated = "DecoderBuilder is missing a reader and a buffer, which are required to build a decoder."]
    pub fn build(self) -> ! {
        panic!("See compilation warning");
    }
}

impl<R> DecoderBuilder<(R,), ()> {
    #[deprecated = "DecoderBuilder is missing a buffer, which is required to build a decoder."]
    pub fn build(self) -> ! {
        panic!("See compilation warning");
    }
}

impl<B> DecoderBuilder<(), (B,)> {
    #[deprecated = "DecoderBuilder is missing a reader, which is required to build a decoder."]
    pub fn build(self) -> ! {
        panic!("See compilation warning");
    }
}

impl<B> DecoderBuilder<(), B> {
    pub fn with_reader<R, E>(self, reader: R) -> DecoderBuilder<(R,), B>
    where
        R: ReadSimple,
    {
        DecoderBuilder {
            reader: (reader,),
            buf: self.buf,
        }
    }
}

impl<R> DecoderBuilder<R, ()> {
    pub fn with_buffer<B>(self, buf: B) -> DecoderBuilder<R, (B,)>
    where
        B: AsMut<[u8]>,
    {
        DecoderBuilder {
            reader: self.reader,
            buf: (buf,),
        }
    }

    pub fn with_stack_buffer<const SIZE: usize>(self) -> DecoderBuilder<R, ([u8; SIZE],)> {
        self.with_buffer([0; SIZE])
    }

    #[cfg(feature = "alloc")]
    pub fn with_heap_buffer(self, size: usize) -> DecoderBuilder<R, (Vec<u8>,)> {
        self.with_buffer(vec![0; size])
    }
}

impl<R, B> DecoderBuilder<(R,), (B,)>
where
    R: ReadSimple,
    B: AsMut<[u8]>,
{
    pub fn build(self) -> Decoder<R, B> {
        Decoder::new(self.reader.0, self.buf.0)
    }
}