bincode-next 3.0.0-rc.9

A compact, ultra-fast binary serialization format for Rust, optimized for networking and storage!
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

pub trait Sealed {}

impl<T> Sealed for &mut T where T: Sealed {}

/// A helper trait to perform compile-time checks on bit-packed fields.
pub trait BitPackedCheck<const BITS: u8> {
    /// Performs the check.
    const CHECK: ();
}

impl<const BITS: u8, T> BitPackedCheck<BITS> for T {
    const CHECK: () = assert!(
        BITS > 0 && BITS <= 64 && BITS as usize <= core::mem::size_of::<Self>() * 8,
        "Bit width must be 1-64 and not exceed type size"
    );
}

/// A trait to indicate that a type is a bincode primitive.
/// This is used for bulk copy optimizations when the configuration allows it.
pub trait IsPrimitive: Copy + 'static {}

impl IsPrimitive for u8 {}
impl IsPrimitive for i8 {}
impl IsPrimitive for u16 {}
impl IsPrimitive for i16 {}
impl IsPrimitive for u32 {}
impl IsPrimitive for i32 {}
impl IsPrimitive for u64 {}
impl IsPrimitive for i64 {}
impl IsPrimitive for u128 {}
impl IsPrimitive for i128 {}
impl IsPrimitive for f32 {}
impl IsPrimitive for f64 {}

#[doc(hidden)]
#[macro_export]
macro_rules! assume {
    ($cond:expr) => {
        if !$cond {
            debug_assert!(false, "Assumption failed: {}", stringify!($cond));
            unsafe { core::hint::unreachable_unchecked() };
        }
    };
}

pub use assume;

#[doc(hidden)]
#[macro_export]
macro_rules! is_likely {
    ($e:expr) => {{
        #[cfg(is_nightly)]
        {
            std::intrinsics::likely($e)
        }
        #[cfg(not(is_nightly))]
        {
            // Fallback for stable
            $e
        }
    }};
}

pub use is_likely;

#[doc(hidden)]
#[macro_export]
macro_rules! is_unlikely {
    ($e:expr) => {{
        #[cfg(is_nightly)]
        {
            std::intrinsics::unlikely($e)
        }
        #[cfg(not(is_nightly))]
        {
            // Fallback for stable
            $e
        }
    }};
}

pub use is_unlikely;