wowlab_engine_domain/rotation/buffer/dense/

accessors.rs

use bytemuck::{Pod, Zeroable};
use wowlab_buffer_contract::SLOT_ALIGNMENT;
use wowlab_types::{
    combat::ResourceType,
    sim::{AuraKey, AuraProjectionKey, SpellIdx},
};

use super::{BufferOffsets, HistoryIterMut};
use crate::rotation::buffer::{
    AuraSlot, ByteOffset, CombatSlot, CooldownSlot, DefaultValue, EquipmentSlot, HeroTreeSlot,
    HistorySlot, ItemSlot, PetSlot, PlayerSlot, ResourceSlot, SetBonusSlot, SpellSlot,
    StandaloneDefault, SwingSlot, TalentSlot, UnitSlot, WeaponImbueSlot,
};

/// `repr(align(8))` backing chunk so the `Vec<SlotChunk>` allocation is `SLOT_ALIGNMENT`-aligned.
#[derive(Clone, Copy, Debug)]
#[repr(C, align(8))]
struct SlotChunk([u8; SLOT_ALIGNMENT]);

// SAFETY: plain `[u8; N]` with no padding is transparently zeroable.
unsafe impl Zeroable for SlotChunk {}
// SAFETY: every bit pattern of `[u8; N]` is a valid value.
unsafe impl Pod for SlotChunk {}

const _: () = assert!(
    size_of::<SlotChunk>() == SLOT_ALIGNMENT,
    "SlotChunk must be exactly SLOT_ALIGNMENT bytes wide"
);

const _: () = assert!(
    align_of::<SlotChunk>() == SLOT_ALIGNMENT,
    "SlotChunk must be SLOT_ALIGNMENT-aligned"
);

#[inline]
fn chunks_for_bytes(byte_len: usize) -> usize {
    byte_len.div_ceil(SLOT_ALIGNMENT)
}

macro_rules! singleton_slot {
    ($read:ident, $write:ident, $Slot:ty, $field:ident) => {
        #[inline(always)]
        pub fn $read(&self) -> &$Slot {
            self.slot_ref::<$Slot>(self.offsets.$field)
        }
        #[inline(always)]
        pub fn $write(&mut self) -> &mut $Slot {
            self.slot_mut::<$Slot>(self.offsets.$field)
        }
    };
}

macro_rules! keyed_slot {
    ($read:ident, $write:ident, $Slot:ty, $Key:ty, $map:ident) => {
        #[inline]
        pub fn $read(&self, key: $Key) -> Option<&$Slot> {
            let &base = self.offsets.slots.$map.get(&key)?;
            Some(self.slot_ref::<$Slot>(base))
        }
        #[inline]
        pub fn $write(&mut self, key: $Key) -> Option<&mut $Slot> {
            let &base = self.offsets.slots.$map.get(&key)?;
            Some(self.slot_mut::<$Slot>(base))
        }
    };
}

macro_rules! keyed_slot_str {
    ($read:ident, $write:ident, $Slot:ty, $map:ident) => {
        #[inline]
        pub fn $read(&self, key: &str) -> Option<&$Slot> {
            let &base = self.offsets.slots.$map.get(key)?;
            Some(self.slot_ref::<$Slot>(base))
        }
        #[inline]
        pub fn $write(&mut self, key: &str) -> Option<&mut $Slot> {
            let &base = self.offsets.slots.$map.get(key)?;
            Some(self.slot_mut::<$Slot>(base))
        }
    };
}

macro_rules! ensure_slot {
    ($fn:ident, $Slot:ty, $map:ident, $key:ident : $Key:ty, $insert:expr, $lookup:expr) => {
        #[doc = concat!(
                            "Ensure a `", stringify!($Slot), "` exists for `", stringify!($key),
                            "`, returning `true` if it already existed."
                        )]
        pub fn $fn(&mut self, $key: $Key) -> bool {
            if self.offsets.slots.$map.contains_key($lookup) {
                return true;
            }
            let base = self.align_to_slot();
            self.resize_bytes(base + <$Slot>::SIZE);
            self.offsets.slots.$map.insert($insert, ByteOffset::new(base));
            false
        }
    };
}

/// Flat byte buffer holding all runtime rotation state for zero-allocation evaluation.
#[derive(Debug)]
pub struct DenseBuffer {
    chunks: Vec<SlotChunk>,
    byte_len: usize,
    pub(super) offsets: BufferOffsets,
    standalone_defaults: Vec<(ByteOffset, &'static DefaultValue)>,
}

impl DenseBuffer {
    #[must_use]
    pub fn new(offsets: BufferOffsets, size: usize) -> Self {
        let mut standalone_defaults = Vec::with_capacity(offsets.standalone.len());

        for (&descriptor_id, &offset) in &offsets.standalone {
            if let Some(default) = inventory::iter::<StandaloneDefault>
                .into_iter()
                .find(|d| (d.matches)(descriptor_id))
            {
                standalone_defaults.push((offset, &default.value));
            }
        }

        Self {
            chunks: vec![SlotChunk([0u8; SLOT_ALIGNMENT]); chunks_for_bytes(size)],
            byte_len: size,
            offsets,
            standalone_defaults,
        }
    }

    /// Snapshot the concrete aura identities currently allocated in this buffer.
    pub fn aura_keys(&self) -> impl Iterator<Item = AuraKey> + '_ {
        self.offsets.slots.auras.keys().copied()
    }
    /// Snapshot the APL aura category projections allocated by the rotation schema.
    pub fn aura_projection_keys(&self) -> impl Iterator<Item = AuraProjectionKey> + '_ {
        self.offsets.slots.aura_projections.keys().copied()
    }

    #[inline]
    #[must_use]
    pub fn as_ptr(&self) -> *const u8 {
        self.chunks.as_ptr().cast::<u8>()
    }

    #[inline]
    pub fn as_mut_ptr(&mut self) -> *mut u8 {
        self.chunks.as_mut_ptr().cast::<u8>()
    }

    /// Active byte view truncated to the schema-declared `byte_len`.
    #[inline]
    #[must_use]
    pub fn bytes(&self) -> &[u8] {
        // #t(rust_unchecked_indexing) byte_len is maintained <= chunks.len() * SLOT_ALIGNMENT by resize_bytes
        &bytemuck::cast_slice::<SlotChunk, u8>(&self.chunks)[..self.byte_len]
    }

    /// Active mutable byte view. See [`Self::bytes`].
    #[inline]
    pub fn bytes_mut(&mut self) -> &mut [u8] {
        let len = self.byte_len;

        // #t(rust_unchecked_indexing) byte_len is maintained <= chunks.len() * SLOT_ALIGNMENT by resize_bytes
        &mut bytemuck::cast_slice_mut::<SlotChunk, u8>(&mut self.chunks)[..len]
    }

    /// Mutable in-place iterator over every [`HistorySlot`] without allocating a key list.
    pub fn history_iter_mut(&mut self) -> HistoryIterMut<'_> {
        let mut offsets: Vec<usize> = self
            .offsets
            .slots
            .history
            .values()
            .map(ByteOffset::as_usize)
            .collect();

        offsets.sort_unstable();

        HistoryIterMut {
            rest: self.bytes_mut(),
            offsets: offsets.into_iter(),
            consumed: 0,
        }
    }
    /// Clear every history slot's previous-cast flags (`prev_gcd` / `prev_off_gcd`).
    pub fn clear_history(&mut self) {
        for h in self.history_iter_mut() {
            h.prev_gcd = 0;
            h.prev_off_gcd = 0;
        }
    }
    /// Zero the buffer and write standalone field defaults.
    pub fn reset_and_defaults(&mut self) {
        self.bytes_mut().fill(0);
        self.populate_standalone_defaults();
    }
    #[inline]
    fn slot_ref<T>(&self, base: ByteOffset) -> &T
    where
        T: Pod,
    {
        let base = base.as_usize();

        // #t(rust_unchecked_indexing) base + slot size is schema-validated to lie within byte_len
        bytemuck::from_bytes(&self.bytes()[base..base + size_of::<T>()])
    }
    #[inline]
    fn slot_mut<T>(&mut self, base: ByteOffset) -> &mut T
    where
        T: Pod,
    {
        let base = base.as_usize();

        // #t(rust_unchecked_indexing) base + slot size is schema-validated to lie within byte_len
        bytemuck::from_bytes_mut(&mut self.bytes_mut()[base..base + size_of::<T>()])
    }
    fn resize_bytes(&mut self, new_byte_len: usize) {
        let needed_chunks = chunks_for_bytes(new_byte_len);

        if needed_chunks > self.chunks.len() {
            self.chunks
                .resize(needed_chunks, SlotChunk([0u8; SLOT_ALIGNMENT]));
        }

        let prev_len = self.byte_len;

        if new_byte_len > prev_len {
            let bytes = bytemuck::cast_slice_mut::<SlotChunk, u8>(&mut self.chunks);

            // #t(rust_unchecked_indexing) needed_chunks above guarantees bytes.len() >= new_byte_len
            for byte in &mut bytes[prev_len..new_byte_len] {
                *byte = 0;
            }
        }

        self.byte_len = new_byte_len;
    }
    fn align_to_slot(&mut self) -> usize {
        let cur = self.byte_len;

        if cur % SLOT_ALIGNMENT != 0 {
            self.resize_bytes(cur + (SLOT_ALIGNMENT - (cur % SLOT_ALIGNMENT)));
        }

        self.byte_len
    }
    fn populate_standalone_defaults(&mut self) {
        let byte_len = self.byte_len;
        // #t(rust_unchecked_indexing) byte_len is maintained <= chunks.len() * SLOT_ALIGNMENT by resize_bytes
        let bytes = &mut bytemuck::cast_slice_mut::<SlotChunk, u8>(&mut self.chunks)[..byte_len];

        for &(offset, value) in &self.standalone_defaults {
            value.write_to(bytes, offset);
        }
    }
    singleton_slot!(player, player_mut, PlayerSlot, player);
    singleton_slot!(combat, combat_mut, CombatSlot, combat);
    singleton_slot!(pet, pet_mut, PetSlot, pet);
    keyed_slot!(cooldown, cooldown_mut, CooldownSlot, SpellIdx, cooldowns);
    keyed_slot!(aura, aura_mut, AuraSlot, AuraKey, auras);
    keyed_slot!(
        aura_projection,
        aura_projection_mut,
        AuraSlot,
        AuraProjectionKey,
        aura_projections
    );
    keyed_slot!(
        resource,
        resource_mut,
        ResourceSlot,
        ResourceType,
        resources
    );

    keyed_slot!(spell, spell_mut, SpellSlot, SpellIdx, spells);

    keyed_slot!(history, history_mut, HistorySlot, SpellIdx, history);

    keyed_slot_str!(talent, talent_mut, TalentSlot, talents);
    keyed_slot_str!(hero_tree, hero_tree_mut, HeroTreeSlot, hero_trees);
    keyed_slot_str!(item, item_mut, ItemSlot, items);
    keyed_slot_str!(swing, swing_mut, SwingSlot, swings);
    keyed_slot_str!(equipment, equipment_mut, EquipmentSlot, equipment);
    keyed_slot_str!(set_bonus, set_bonus_mut, SetBonusSlot, set_bonuses);
    keyed_slot_str!(unit, unit_mut, UnitSlot, units);
    keyed_slot_str!(
        weapon_imbue,
        weapon_imbue_mut,
        WeaponImbueSlot,
        weapon_imbues
    );

    ensure_slot!(ensure_swing_slot, SwingSlot, swings, key: &str, key.to_string(), key);

    ensure_slot!(ensure_unit_slot, UnitSlot, units, key: &str, key.to_string(), key);

    ensure_slot!(
        ensure_weapon_imbue_slot,
        WeaponImbueSlot,
        weapon_imbues,
        key: &str,
        key.to_string(),
        key
    );

    ensure_slot!(ensure_aura_slot, AuraSlot, auras, key: AuraKey, key, &key);

    ensure_slot!(
        ensure_aura_projection_slot,
        AuraSlot,
        aura_projections,
        key: AuraProjectionKey,
        key,
        &key
    );

    ensure_slot!(
        ensure_spell_slot,
        SpellSlot,
        spells,
        spell: SpellIdx,
        spell,
        &spell
    );

    ensure_slot!(
        ensure_cooldown_slot,
        CooldownSlot,
        cooldowns,
        spell: SpellIdx,
        spell,
        &spell
    );

    ensure_slot!(
        ensure_resource_slot,
        ResourceSlot,
        resources,
        resource: ResourceType,
        resource,
        &resource
    );
}