mirascript-vm 0.1.105

Native Rust virtual machine for MiraScript
Documentation
use crate::{MiraError, Result, RuntimeErrorKind};

use super::{ArenaId, Payload};

const ARENA_INDEX_BITS: u32 = 32;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub(super) struct ArenaKey(u64);

impl ArenaKey {
    pub fn new(arena_id: ArenaId, index: usize, category: &'static str) -> Result<Self> {
        let index = u32::try_from(index)
            .ok()
            .and_then(|index| index.checked_add(1))
            .ok_or_else(|| MiraError::runtime(RuntimeErrorKind::ArenaExhausted { category }))?;
        Ok(Self(
            (u64::from(arena_id.get()) << ARENA_INDEX_BITS) | u64::from(index),
        ))
    }

    pub const fn arena_id(self) -> ArenaId {
        ArenaId::from((self.0 >> ARENA_INDEX_BITS) as u16)
    }

    pub const fn index(self) -> usize {
        ((self.0 as u32) - 1) as usize
    }

    pub const fn payload(self) -> [u8; 6] {
        Payload::from_bits(self.0).to_bytes()
    }

    pub const fn from_payload(payload: [u8; 6]) -> Self {
        let bytes = Payload::from_bytes(payload).to_bits();
        Self(bytes)
    }
}

#[cfg(test)]
mod tests {
    use std::num::NonZeroU16;

    use super::*;

    #[test]
    fn arena_key_roundtrips_through_six_byte_payload() {
        for (arena_id, index) in [
            (NonZeroU16::MIN, 0),
            (NonZeroU16::new(17).unwrap(), 42),
            (NonZeroU16::MAX, u32::MAX as usize - 1),
        ] {
            let arena_id = ArenaId::from(arena_id.get());
            let key = ArenaKey::new(arena_id, index, "test").unwrap();
            assert_eq!(ArenaKey::from_payload(key.payload()), key);
            assert_eq!(key.arena_id(), arena_id);
            assert_eq!(key.index(), index);
        }
    }

    #[test]
    fn arena_key_rejects_a_slot_outside_the_32_bit_component() {
        assert!(ArenaKey::new(ArenaId::next(), u32::MAX as usize, "test").is_err());
    }
}