graphite_binary 0.1.0

Efficient binary serialization for the graphite_minecraft project
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

use super::*;
use std::mem::transmute;

pub enum Single {}

macro_rules! single_impl {
    ($typ:tt, $conv_from:tt, $conv_to:tt) => {
        impl SliceSerializable<'_, $typ> for Single {
            type CopyType = $typ;

            fn read(bytes: &mut &[u8]) -> anyhow::Result<$typ> {
                if bytes.is_empty() {
                    return Err(BinaryReadError::NotEnoughRemainingBytes.into());
                }

                #[allow(unused_unsafe)]
                let ret = unsafe { $conv_from(bytes[0]) };

                *bytes = &bytes[1..];
                Ok(ret)
            }

            fn get_write_size(_: $typ) -> usize {
                1
            }

            unsafe fn write<'b>(bytes: &'b mut [u8], data: $typ) -> &'b mut [u8] {
                debug_assert!(
                    !bytes.is_empty(),
                    "invariant: slice must contain at least 1 byte to perform read"
                );

                bytes[0] = $conv_to(data);
                &mut bytes[1..]
            }

            #[inline(always)]
            fn as_copy_type(t: &$typ) -> Self::CopyType {
                *t
            }
        }
    };
}

// u8
single_impl!(u8, noop, noop);

fn noop(byte: u8) -> u8 {
    byte
}

// i8
single_impl!(i8, transmute, transmute);

// bool
single_impl!(bool, byte_from_bool, byte_to_bool);

fn byte_from_bool(byte: u8) -> bool {
    byte != 0
}

fn byte_to_bool(bool: bool) -> u8 {
    if bool {
        1
    } else {
        0
    }
}