oblux 0.1.0

one-bit less unsigned integer 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

//! Unsigned integer types with guaranteed signed integer compatibility.

#[rustfmt::skip]
macro_rules! define_ux {
	($name:ident, $unsigned:ty, $signed:ty) => {
		#[doc = concat!(
					"Unsigned integer type with guaranteed [`",
					stringify!($signed),
					"`] compatibility.",
				)]
		#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
		pub struct $name($unsigned);

		impl $name {
			/// The minimum value for this type (always `0`).
			///
			/// ```
			#[doc = concat!("# use oblux::", stringify!($name), ";")]
			#[doc = concat!("assert_eq!(", stringify!($name), "::MIN.get(), ", "0);")]
			/// ```
			pub const MIN: Self = Self(<$unsigned>::MIN);

			/// The maximum value for this type.
			///
			/// ```
			#[doc = concat!("# use oblux::", stringify!($name), ";")]
			#[doc = concat!(
						"assert_eq!(",
						stringify!($name),
						"::MAX.get(), ",
						stringify!($signed),
						"::MAX as ",
						stringify!($unsigned),
						");",
					)]
			/// ```
			pub const MAX: Self = Self(Self::INNER_MAX);

			/// The constant value `1`.
			///
			/// ```
			#[doc = concat!("# use oblux::", stringify!($name), ";")]
			#[doc = concat!("assert_eq!(", stringify!($name), "::ONE.get(), ", "1);")]
			/// ```
			pub const ONE: Self = Self(1);

			/// The constant value `2`.
			///
			/// ```
			#[doc = concat!("# use oblux::", stringify!($name), ";")]
			#[doc = concat!("assert_eq!(", stringify!($name), "::TWO.get(), ", "2);")]
			/// ```
			pub const TWO: Self = Self(2);

			/// The constant value `3`.
			///
			/// ```
			#[doc = concat!("# use oblux::", stringify!($name), ";")]
			#[doc = concat!("assert_eq!(", stringify!($name), "::THREE.get(), ", "3);")]
			/// ```
			pub const THREE: Self = Self(3);

			const INNER_MAX: $unsigned = <$signed>::MAX as $unsigned;

			/// Creates a new instance if `x` is within the valid range.
            ///
            #[doc = concat!(
            			"Returns `None` if magnitude of `x` exceeds [`",
            			stringify!($signed),
            			"::MAX`].",
            		)]
			pub const fn new(x: $unsigned) -> Option<Self> {
				if x <= Self::INNER_MAX {
					Some(Self(x))
				} else {
					None
				}
			}

			/// Creates a new instance if `x` is non-negative.
			pub const fn from_signed(x: $signed) -> Option<Self> {
				if x < 0 {
					None
				} else {
					Self::new(x as $unsigned)
				}
			}

			#[doc = concat!("Returns the underlying [`", stringify!($unsigned), "`].")]
			pub const fn get(self) -> $unsigned {
				self.0
			}

			#[doc = concat!("Returns the corresponding [`", stringify!($signed), "`].")]
            ///
            #[doc = concat!(
	            		"This is always safe because the value is guaranteed to be within the ",
	            		"positive range of [`", stringify!($signed), "`].",
					)]
			pub const fn to_signed(self) -> $signed {
				self.get() as $signed
			}
		}
	};
}

define_ux!(U7, u8, i8);
define_ux!(U15, u16, i16);
define_ux!(U31, u32, i32);
define_ux!(U63, u64, i64);
define_ux!(U127, u128, i128);