frclib-core 0.2.4

A collection of utilities to be used across the FRC in rust ecosystem
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

use std::io::{Cursor, Read};

use num::traits::{FromBytes, ToBytes};

fn empty_schema_supplier() -> String {
    String::with_capacity(0)
}

macro_rules! prim_structure {
    ($typ:ident , $string:literal) => {
        impl super::FrcStructure for $typ {
            const SCHEMA_SUPPLIER: fn() -> String = empty_schema_supplier;
            const TYPE: &'static str = $string;
            const SIZE: usize = core::mem::size_of::<Self>();

            #[inline]
            fn pack(&self, buffer: &mut Vec<u8>) {
                buffer.extend_from_slice(&<Self as ToBytes>::to_le_bytes(self));
            }

            #[inline]
            fn unpack(buffer: &mut Cursor<&[u8]>) -> Self {
                let mut value_buffer = [0u8; Self::SIZE];
                let _ = buffer.read_exact(&mut value_buffer);
                <Self as FromBytes>::from_le_bytes(&value_buffer)
            }
        }
    };
}

prim_structure!(f64, "float64");
prim_structure!(f32, "float32");
prim_structure!(i64, "int64");
prim_structure!(i32, "int32");
prim_structure!(i16, "int16");
prim_structure!(i8, "int8");
prim_structure!(u64, "uint64");
prim_structure!(u32, "uint32");
prim_structure!(u16, "uint16");
prim_structure!(u8, "uint8");

impl super::FrcStructure for bool {
    const SCHEMA_SUPPLIER: fn() -> String = empty_schema_supplier;
    const TYPE: &'static str = "bool";
    const SIZE: usize = core::mem::size_of::<Self>();
    #[inline]
    fn pack(&self, buffer: &mut Vec<u8>) {
        buffer.push(u8::from(*self));
    }
    #[inline]
    fn unpack(buffer: &mut Cursor<&[u8]>) -> Self {
        let mut value_buffer = [0u8; Self::SIZE];
        let _ = buffer.read_exact(&mut value_buffer);
        value_buffer[0] != 0
    }
}

impl super::FrcStructure for char {
    const SCHEMA_SUPPLIER: fn() -> String = empty_schema_supplier;
    const TYPE: &'static str = "char";
    const SIZE: usize = 1;
    #[inline]
    fn pack(&self, buffer: &mut Vec<u8>) {
        buffer.push(*self as u8);
    }
    #[inline]
    fn unpack(buffer: &mut Cursor<&[u8]>) -> Self {
        let mut value_buffer = [0u8; Self::SIZE];
        let _ = buffer.read_exact(&mut value_buffer);
        value_buffer[0] as Self
    }
}

impl<T, const N: usize> super::FrcStructure for [T; N]
where
    T: super::FrcStructure + Copy,
{
    const TYPE: &'static str = T::TYPE;
    const SIZE: usize = T::SIZE * N;
    const SCHEMA_SUPPLIER: fn() -> String = empty_schema_supplier;

    #[inline]
    fn pack(&self, buffer: &mut Vec<u8>) {
        for item in self {
            item.pack(buffer);
        }
    }

    #[inline]
    fn unpack(buffer: &mut Cursor<&[u8]>) -> Self {
        let mut arr = [T::unpack(buffer); N];
        let mut is_first = true;
        for item in &mut arr {
            if is_first {
                is_first = false;
            } else {
                *item = T::unpack(buffer);
            }
        }
        arr
    }

    fn format_field(field: &str) -> String {
        format!("{} {}[{}]", T::TYPE, field, N)
    }
}