use core::num::NonZeroU8;
use crate::{StorageError, StorageResult};
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub enum ByteOrder {
LittleEndian,
BigEndian,
}
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub enum BitOrder {
MostSignificantFirst,
LeastSignificantFirst,
}
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub enum SampleClass {
UnsignedInteger,
SignedInteger,
FloatingPoint,
}
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub enum StorageUnit {
Packed(BitOrder),
Byte,
Word16(ByteOrder),
Word32(ByteOrder),
Word64(ByteOrder),
}
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub struct SampleStorage {
class: SampleClass,
significant_bits: NonZeroU8,
unit: StorageUnit,
}
impl SampleStorage {
pub fn new(class: SampleClass, significant_bits: u8, unit: StorageUnit) -> StorageResult<Self> {
let significant_bits =
NonZeroU8::new(significant_bits).ok_or(StorageError::ZeroSampleBits)?;
let bits = significant_bits.get();
let capacity = unit_capacity(unit, bits)?;
if bits > capacity {
return Err(StorageError::SampleBitsExceedStorage);
}
if class == SampleClass::SignedInteger && bits < 2 {
return Err(StorageError::SignedSampleNeedsValueBit);
}
if class == SampleClass::FloatingPoint
&& (matches!(unit, StorageUnit::Packed(_) | StorageUnit::Byte) || bits != capacity)
{
return Err(StorageError::InvalidFloatingStorage);
}
Ok(Self {
class,
significant_bits,
unit,
})
}
#[must_use]
pub const fn class(self) -> SampleClass {
self.class
}
#[must_use]
pub const fn significant_bits(self) -> u8 {
self.significant_bits.get()
}
#[must_use]
pub const fn unit(self) -> StorageUnit {
self.unit
}
#[must_use]
pub const fn storage_bits(self) -> u8 {
match self.unit {
StorageUnit::Packed(_) => self.significant_bits.get(),
StorageUnit::Byte => 8,
StorageUnit::Word16(_) => 16,
StorageUnit::Word32(_) => 32,
StorageUnit::Word64(_) => 64,
}
}
#[must_use]
pub const fn byte_order(self) -> Option<ByteOrder> {
match self.unit {
StorageUnit::Word16(order)
| StorageUnit::Word32(order)
| StorageUnit::Word64(order) => Some(order),
StorageUnit::Packed(_) | StorageUnit::Byte => None,
}
}
#[must_use]
pub const fn bit_order(self) -> Option<BitOrder> {
match self.unit {
StorageUnit::Packed(order) => Some(order),
StorageUnit::Byte
| StorageUnit::Word16(_)
| StorageUnit::Word32(_)
| StorageUnit::Word64(_) => None,
}
}
}
const fn unit_capacity(unit: StorageUnit, packed_bits: u8) -> StorageResult<u8> {
match unit {
StorageUnit::Packed(_) => {
if packed_bits > 64 {
Err(StorageError::PackedSampleTooWide)
} else {
Ok(packed_bits)
}
}
StorageUnit::Byte => Ok(8),
StorageUnit::Word16(_) => Ok(16),
StorageUnit::Word32(_) => Ok(32),
StorageUnit::Word64(_) => Ok(64),
}
}