musli 0.2.1

Müsli is a flexible and efficient serialization framework.
Documentation 
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

use crate::alloc::Vec;
use crate::{Context, Writer};

/// A writer which either writes to an underlying writer, or discards what is
/// being written.
///
/// This is used when a record is encoded more than once, such as when a header
/// row is being written, to ignore the parts of the record which are not
/// relevant to the current pass.
pub(crate) enum Sink<W> {
    /// Write to the underlying writer.
    Real(W),
    /// Discard anything written.
    Discard,
}

impl<W> Writer for Sink<W>
where
    W: Writer,
{
    type Ok = ();
    type Mut<'this>
        = Sink<W::Mut<'this>>
    where
        Self: 'this;

    #[inline]
    fn finish<C>(&mut self, _: C) -> Result<Self::Ok, C::Error>
    where
        C: Context,
    {
        Ok(())
    }

    #[inline]
    fn borrow_mut(&mut self) -> Self::Mut<'_> {
        match self {
            Sink::Real(writer) => Sink::Real(writer.borrow_mut()),
            Sink::Discard => Sink::Discard,
        }
    }

    #[inline]
    fn extend<C>(&mut self, cx: C, buffer: Vec<u8, C::Allocator>) -> Result<(), C::Error>
    where
        C: Context,
    {
        match self {
            Sink::Real(writer) => writer.extend(cx, buffer),
            Sink::Discard => Ok(()),
        }
    }

    #[inline]
    fn write_bytes<C>(&mut self, cx: C, bytes: &[u8]) -> Result<(), C::Error>
    where
        C: Context,
    {
        match self {
            Sink::Real(writer) => writer.write_bytes(cx, bytes),
            Sink::Discard => Ok(()),
        }
    }

    #[inline]
    fn write_byte<C>(&mut self, cx: C, b: u8) -> Result<(), C::Error>
    where
        C: Context,
    {
        match self {
            Sink::Real(writer) => writer.write_byte(cx, b),
            Sink::Discard => Ok(()),
        }
    }
}