use core::fmt;
use crate::{
Scalar,
layout::{Endian, Spec},
};
macro_rules! endian {
(Little, $le:expr, $be:expr) => {
$le
};
(Big, $le:expr, $be:expr) => {
$be
};
}
macro_rules! ints {
($($name:ident $literal:ident: $raw:ident[$size:literal] $endian:ident;)+) => {$(
#[doc = concat!("A `", stringify!($raw), "` of ", stringify!($size), " bytes, most significant ")]
#[doc = endian!($endian, "last (little-endian).", "first (big-endian).")]
#[expect(non_camel_case_types, reason = "named like the primitive integers they stand for")]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
#[repr(transparent)]
pub struct $name([u8; $size]);
impl $name {
pub const MAX: Self = Self([0xff; $size]);
#[inline]
pub const fn new(value: $raw) -> Self {
let (mut bytes, mut i) = ([0; $size], 0);
while i < $size {
bytes[endian!($endian, i, $size - 1 - i)] = (value >> (8 * i)) as u8;
i += 1;
}
let this = Self(bytes);
assert!(this.get() == value, "value is out of range");
this
}
#[inline]
pub const fn get(self) -> $raw {
let (mut value, mut i) = (0, 0);
while i < $size {
value |= (self.0[endian!($endian, i, $size - 1 - i)] as $raw) << (8 * i);
i += 1;
}
value
}
#[inline]
pub const fn to_bytes(self) -> [u8; $size] {
self.0
}
#[inline]
pub const fn from_bytes(bytes: [u8; $size]) -> Self {
Self(bytes)
}
}
unsafe impl Scalar for $name {
const SPEC: Spec = Spec::any::<Self>().with_endian(Endian::$endian);
}
impl From<$name> for $raw {
#[inline]
fn from(value: $name) -> Self {
value.get()
}
}
impl PartialOrd for $name {
#[inline]
fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
Some(self.cmp(other))
}
}
impl Ord for $name {
#[inline]
fn cmp(&self, other: &Self) -> core::cmp::Ordering {
self.get().cmp(&other.get())
}
}
impl fmt::Debug for $name {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Debug::fmt(&self.get(), f)
}
}
impl fmt::Display for $name {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Display::fmt(&self.get(), f)
}
}
impl fmt::LowerHex for $name {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::LowerHex::fmt(&self.get(), f)
}
}
#[doc = concat!("A [`", stringify!($name), "`] that is `V`, and nothing else.")]
#[expect(non_camel_case_types, reason = "named like the primitive integers they stand for")]
#[derive(Copy, Clone, PartialEq, Eq, Hash)]
#[repr(transparent)]
pub struct $literal<const V: $raw>($name);
impl<const V: $raw> $literal<V> {
#[inline]
pub const fn new() -> Self {
Self($name::new(V))
}
#[inline]
pub const fn get(self) -> $raw {
V
}
}
unsafe impl<const V: $raw> Scalar for $literal<V> {
const SPEC: Spec = {
let _ = Self::new();
Spec::ranges::<Self>(Endian::$endian, const { &[(V as u128, V as u128)] })
};
}
impl<const V: $raw> Default for $literal<V> {
#[inline]
fn default() -> Self {
Self::new()
}
}
impl<const V: $raw> fmt::Debug for $literal<V> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Debug::fmt(&V, f)
}
}
)+};
}
impl From<u16> for u16le {
#[inline]
fn from(value: u16) -> Self {
Self::new(value)
}
}
macro_rules! from {
($($name:ident: $raw:ident;)+) => {$(
impl From<$raw> for $name {
#[inline]
fn from(value: $raw) -> Self {
Self::new(value)
}
}
)+};
}
from! {
u16be: u16; u32le: u32; u32be: u32; u64le: u64; u64be: u64; u128le: u128; u128be: u128;
}
ints! {
u16le u16lec: u16[2] Little;
u16be u16bec: u16[2] Big;
u24le u24lec: u32[3] Little;
u24be u24bec: u32[3] Big;
u32le u32lec: u32[4] Little;
u32be u32bec: u32[4] Big;
u48le u48lec: u64[6] Little;
u48be u48bec: u64[6] Big;
u64le u64lec: u64[8] Little;
u64be u64bec: u64[8] Big;
u128le u128lec: u128[16] Little;
u128be u128bec: u128[16] Big;
}
macro_rules! numbers {
($($name:ident: $raw:ident[$size:literal] $endian:ident;)+) => {$(
#[doc = concat!("A `", stringify!($raw), "` of ", stringify!($size), " bytes, most significant ")]
#[doc = endian!($endian, "last (little-endian).", "first (big-endian).")]
#[expect(non_camel_case_types, reason = "named like the primitive numbers they stand for")]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
#[repr(transparent)]
pub struct $name([u8; $size]);
impl $name {
#[inline]
pub const fn new(value: $raw) -> Self {
Self(endian!($endian, value.to_le_bytes(), value.to_be_bytes()))
}
#[inline]
pub const fn get(self) -> $raw {
endian!($endian, $raw::from_le_bytes(self.0), $raw::from_be_bytes(self.0))
}
#[inline]
pub const fn to_bytes(self) -> [u8; $size] {
self.0
}
#[inline]
pub const fn from_bytes(bytes: [u8; $size]) -> Self {
Self(bytes)
}
}
unsafe impl Scalar for $name {
const SPEC: Spec = Spec::any::<Self>().with_endian(Endian::$endian).not_a_number();
}
impl From<$name> for $raw {
#[inline]
fn from(value: $name) -> Self {
value.get()
}
}
impl From<$raw> for $name {
#[inline]
fn from(value: $raw) -> Self {
Self::new(value)
}
}
impl fmt::Debug for $name {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Debug::fmt(&self.get(), f)
}
}
impl fmt::Display for $name {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Display::fmt(&self.get(), f)
}
}
)+};
}
numbers! {
i16le: i16[2] Little;
i16be: i16[2] Big;
i32le: i32[4] Little;
i32be: i32[4] Big;
i64le: i64[8] Little;
i64be: i64[8] Big;
i128le: i128[16] Little;
i128be: i128[16] Big;
f32le: f32[4] Little;
f32be: f32[4] Big;
f64le: f64[8] Little;
f64be: f64[8] Big;
}
macro_rules! ordered {
($($name:ident)+) => {$(
impl PartialOrd for $name {
#[inline]
fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
Some(self.cmp(other))
}
}
impl Ord for $name {
#[inline]
fn cmp(&self, other: &Self) -> core::cmp::Ordering {
self.get().cmp(&other.get())
}
}
)+};
}
ordered!(i16le i16be i32le i32be i64le i64be i128le i128be);
#[expect(non_camel_case_types, reason = "named like the primitive integers they stand for")]
#[derive(Copy, Clone, PartialEq, Eq, Hash)]
#[repr(transparent)]
pub struct u8c<const V: u8>(u8);
impl<const V: u8> u8c<V> {
#[inline]
#[must_use]
pub const fn new() -> Self {
Self(V)
}
#[inline]
#[must_use]
pub const fn get(self) -> u8 {
V
}
}
unsafe impl<const V: u8> Scalar for u8c<V> {
const SPEC: Spec = Spec::ranges::<Self>(Endian::NATIVE, const { &[(V as u128, V as u128)] });
}
impl<const V: u8> Default for u8c<V> {
#[inline]
fn default() -> Self {
Self::new()
}
}
impl<const V: u8> fmt::Debug for u8c<V> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Debug::fmt(&V, f)
}
}
#[expect(non_camel_case_types, reason = "named like the primitive integers they stand for")]
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(transparent)]
pub struct u8in<const MIN: u8, const MAX: u8>(u8);
impl<const MIN: u8, const MAX: u8> u8in<MIN, MAX> {
#[inline]
#[must_use]
pub const fn new(value: u8) -> Option<Self> {
if MIN <= value && value <= MAX { Some(Self(value)) } else { None }
}
#[inline]
#[must_use]
pub const fn get(self) -> u8 {
self.0
}
}
unsafe impl<const MIN: u8, const MAX: u8> Scalar for u8in<MIN, MAX> {
const SPEC: Spec = Spec::ranges::<Self>(Endian::NATIVE, const { &[(MIN as u128, MAX as u128)] });
}
impl<const MIN: u8, const MAX: u8> fmt::Debug for u8in<MIN, MAX> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Debug::fmt(&self.0, f)
}
}