pack1 1.1.0

Byte array newtypes for different primitive types.
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
107
108
109
110
111
112
113
114
115

#![no_std]
#![warn(missing_docs)]
#![forbid(unsafe_code)]
#![warn(clippy::missing_const_for_fn)]
#![warn(clippy::missing_inline_in_public_items)]

//! Byte array newtypes for different primitive types.
//!
//! Because they're newtypes of byte arrays, they always have alignment 1.
//!
//! Each type has `new` and `get` functions, as well as [`From`] impls. The
//! `new` and `get` functions are `const fn` with int types, but not yet with
//! floating types.
//!
//! The intended usage of this crate is that you can use these these types in a
//! `repr(C)` struct, along with manual padding, and then have each field at the
//! exact byte offset you desire (and with the necessary endian-ness), without
//! the normal `repr(packed)` problem that it interferes with references.

macro_rules! int_fmt {
  ($i:ident, $base:ty) => {
    impl core::fmt::Binary for $i {
      #[inline]
      fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        core::fmt::Binary::fmt(&<$base>::from(*self), f)
      }
    }
    impl core::fmt::Debug for $i {
      #[inline]
      fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        core::fmt::Debug::fmt(&<$base>::from(*self), f)
      }
    }
    impl core::fmt::Display for $i {
      #[inline]
      fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        core::fmt::Display::fmt(&<$base>::from(*self), f)
      }
    }
    impl core::fmt::LowerExp for $i {
      #[inline]
      fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        core::fmt::LowerExp::fmt(&<$base>::from(*self), f)
      }
    }
    impl core::fmt::LowerHex for $i {
      #[inline]
      fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        core::fmt::LowerHex::fmt(&<$base>::from(*self), f)
      }
    }
    impl core::fmt::Octal for $i {
      #[inline]
      fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        core::fmt::Octal::fmt(&<$base>::from(*self), f)
      }
    }
    impl core::fmt::UpperExp for $i {
      #[inline]
      fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        core::fmt::UpperExp::fmt(&<$base>::from(*self), f)
      }
    }
    impl core::fmt::UpperHex for $i {
      #[inline]
      fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        core::fmt::UpperHex::fmt(&<$base>::from(*self), f)
      }
    }
  };
}

macro_rules! float_fmt {
  ($i:ident, $base:ty) => {
    impl core::fmt::Debug for $i {
      #[inline]
      fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        core::fmt::Debug::fmt(&<$base>::from(*self), f)
      }
    }
    impl core::fmt::Display for $i {
      #[inline]
      fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        core::fmt::Display::fmt(&<$base>::from(*self), f)
      }
    }
    impl core::fmt::LowerExp for $i {
      #[inline]
      fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        core::fmt::LowerExp::fmt(&<$base>::from(*self), f)
      }
    }
    impl core::fmt::UpperExp for $i {
      #[inline]
      fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        core::fmt::UpperExp::fmt(&<$base>::from(*self), f)
      }
    }
  };
}

mod _f32;
mod _f64;
mod _i128;
mod _i16;
mod _i32;
mod _i64;
mod _u128;
mod _u16;
mod _u32;
mod _u64;

pub use self::{
  _f32::*, _f64::*, _i128::*, _i16::*, _i32::*, _i64::*, _u128::*, _u16::*, _u32::*, _u64::*,
};