wowlab_engine_domain/rotation/buffer/dense/

accessors.rs

use std::sync::Arc;

use bytemuck::{Pod, Zeroable};
use wowlab_buffer_contract::SLOT_ALIGNMENT;
#[cfg(any(test, feature = "test-support"))]
use wowlab_types::{
    combat::ResourceType,
    sim::{AuraKey, AuraProjectionKey, SpellIdx},
};

use crate::rotation::buffer::{
    AuraProjectionSlotHandle, AuraSlot, ByteOffset, CombatSlot, CooldownSlot, CooldownSlotHandle,
    EquipmentSlot, EquipmentSlotHandle, FrozenBufferLayout, HeroTreeSlot, HeroTreeSlotHandle,
    HistorySlot, HistorySlotHandle, ItemSlot, ItemSlotHandle, LayoutFingerprint, PetSlot,
    PlayerSlot, ResourceSlot, ResourceSlotHandle, SetBonusSlot, SetBonusSlotHandle, SpellSlot,
    SpellSlotHandle, SwingSlot, SwingSlotHandle, TalentSlot, TalentSlotHandle, UnitSlot,
    UnitSlotHandle, WeaponImbueSlot, WeaponImbueSlotHandle,
};

#[path = "aura_ops.rs"]
mod aura_ops;

/// `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(crate) fn $read(&self) -> &$Slot {
            self.slot_ref::<$Slot>(self.layout.offsets.$field)
        }
        #[inline(always)]
        pub(crate) fn $write(&mut self) -> &mut $Slot {
            self.slot_mut::<$Slot>(self.layout.offsets.$field)
        }
    };
}

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

macro_rules! keyed_read_slot {
    ($read:ident, $Slot:ty, $Key:ty, $map:ident) => {
        #[cfg(any(test, feature = "test-support"))]
        #[inline]
        pub fn $read(&self, key: $Key) -> Option<&$Slot> {
            wowlab_types::bench_metrics::record_keyed_lookup();
            let &base = self.layout.offsets.slots.$map.get(&key)?;
            Some(self.slot_ref::<$Slot>(base))
        }
    };
}

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

macro_rules! handled_slot {
    ($read:ident, $write:ident, $Slot:ty, $Handle:ty) => {
        #[inline(always)]
        pub(crate) fn $read(&self, handle: $Handle) -> &$Slot {
            self.slot_ref::<$Slot>(handle.offset())
        }

        #[inline(always)]
        pub(crate) fn $write(&mut self, handle: $Handle) -> &mut $Slot {
            self.slot_mut::<$Slot>(handle.offset())
        }
    };
}

/// Flat byte buffer holding all runtime rotation state for zero-allocation evaluation.
#[derive(Debug)]
pub struct DenseBuffer {
    chunks: Vec<SlotChunk>,
    pub(super) layout: Arc<FrozenBufferLayout>,
}

impl DenseBuffer {
    #[must_use]
    // #t(rust_pub_api_smart_pointers) buffer and program must retain the exact same immutable layout identity.
    pub(crate) fn new(layout: Arc<FrozenBufferLayout>) -> Self {
        Self {
            chunks: vec![SlotChunk([0u8; SLOT_ALIGNMENT]); chunks_for_bytes(layout.byte_len())],
            layout,
        }
    }

    pub fn layout_fingerprint(&self) -> LayoutFingerprint {
        self.layout.fingerprint()
    }

    /// Clear every history slot's previous-cast flags (`prev_gcd` / `prev_off_gcd`).
    pub fn clear_history(&mut self) {
        for index in 0..self.layout.history_handles().len() {
            // BOUNDS: index is drawn from the current frozen history-handle slice length.
            let handle = self.layout.history_handles()[index];
            let h = self.history_mut_at(handle);

            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();
    }

    #[cfg(test)]
    pub(crate) fn layout(&self) -> &Arc<FrozenBufferLayout> {
        &self.layout
    }

    #[inline]
    pub(crate) 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(crate) fn bytes(&self) -> &[u8] {
        // BOUNDS: frozen byte_len determines chunks.len() at construction.
        &bytemuck::cast_slice::<SlotChunk, u8>(&self.chunks)[..self.layout.byte_len()]
    }
    /// Active mutable byte view. See [`Self::bytes`].
    #[inline]
    pub(crate) fn bytes_mut(&mut self) -> &mut [u8] {
        let len = self.layout.byte_len();

        // #t(rust_unchecked_indexing) frozen byte_len determines chunks.len() at construction
        &mut bytemuck::cast_slice_mut::<SlotChunk, u8>(&mut self.chunks)[..len]
    }
    #[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 populate_standalone_defaults(&mut self) {
        let byte_len = self.layout.byte_len();
        let defaults = self.layout.standalone_defaults();
        // #t(rust_unchecked_indexing) frozen byte_len determines chunks.len() at construction
        let bytes = &mut bytemuck::cast_slice_mut::<SlotChunk, u8>(&mut self.chunks)[..byte_len];

        for &(offset, value) in 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);
    handled_slot!(spell_at, spell_mut_at, SpellSlot, SpellSlotHandle);
    handled_slot!(
        aura_projection_at,
        aura_projection_mut_at,
        AuraSlot,
        AuraProjectionSlotHandle
    );
    handled_slot!(
        cooldown_at,
        cooldown_mut_at,
        CooldownSlot,
        CooldownSlotHandle
    );
    handled_slot!(history_at, history_mut_at, HistorySlot, HistorySlotHandle);
    handled_slot!(
        resource_at,
        resource_mut_at,
        ResourceSlot,
        ResourceSlotHandle
    );
    handled_slot!(unit_at, unit_mut_at, UnitSlot, UnitSlotHandle);
    handled_slot!(talent_at, talent_mut_at, TalentSlot, TalentSlotHandle);
    handled_slot!(
        hero_tree_at,
        hero_tree_mut_at,
        HeroTreeSlot,
        HeroTreeSlotHandle
    );
    handled_slot!(item_at, item_mut_at, ItemSlot, ItemSlotHandle);
    handled_slot!(swing_at, swing_mut_at, SwingSlot, SwingSlotHandle);
    handled_slot!(
        equipment_at,
        equipment_mut_at,
        EquipmentSlot,
        EquipmentSlotHandle
    );
    handled_slot!(
        set_bonus_at,
        set_bonus_mut_at,
        SetBonusSlot,
        SetBonusSlotHandle
    );
    handled_slot!(
        weapon_imbue_at,
        weapon_imbue_mut_at,
        WeaponImbueSlot,
        WeaponImbueSlotHandle
    );
    keyed_slot!(cooldown, cooldown_mut, CooldownSlot, SpellIdx, cooldowns);
    keyed_read_slot!(aura, 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
    );
}

/// A dense buffer bound to the schema that allocated it.
///
/// Typed slot access is available only through this finalized capability.
/// Raw [`DenseBuffer`] values cannot fabricate or apply layout-local handles.
#[derive(Debug)]
pub struct BoundDenseBuffer {
    inner: DenseBuffer,
}

impl BoundDenseBuffer {
    pub(crate) const fn from_schema(inner: DenseBuffer) -> Self {
        Self { inner }
    }

    #[inline]
    #[must_use]
    pub fn player(&self) -> &PlayerSlot {
        self.inner.player()
    }

    #[inline]
    pub fn player_mut(&mut self) -> &mut PlayerSlot {
        self.inner.player_mut()
    }

    #[inline]
    #[must_use]
    pub fn combat(&self) -> &CombatSlot {
        self.inner.combat()
    }

    #[inline]
    pub fn combat_mut(&mut self) -> &mut CombatSlot {
        self.inner.combat_mut()
    }

    #[inline]
    #[must_use]
    pub fn pet(&self) -> &PetSlot {
        self.inner.pet()
    }

    #[inline]
    pub fn pet_mut(&mut self) -> &mut PetSlot {
        self.inner.pet_mut()
    }
}

macro_rules! bound_handled_slot {
    ($read:ident, $write:ident, $Slot:ty, $Handle:ty) => {
        impl BoundDenseBuffer {
            #[inline(always)]
            #[must_use]
            pub fn $read(&self, handle: $Handle) -> &$Slot {
                self.inner.$read(handle)
            }

            #[inline(always)]
            pub fn $write(&mut self, handle: $Handle) -> &mut $Slot {
                self.inner.$write(handle)
            }
        }
    };
}

bound_handled_slot!(spell_at, spell_mut_at, SpellSlot, SpellSlotHandle);
bound_handled_slot!(
    aura_projection_at,
    aura_projection_mut_at,
    AuraSlot,
    AuraProjectionSlotHandle
);
bound_handled_slot!(
    cooldown_at,
    cooldown_mut_at,
    CooldownSlot,
    CooldownSlotHandle
);
bound_handled_slot!(history_at, history_mut_at, HistorySlot, HistorySlotHandle);
bound_handled_slot!(
    resource_at,
    resource_mut_at,
    ResourceSlot,
    ResourceSlotHandle
);
bound_handled_slot!(unit_at, unit_mut_at, UnitSlot, UnitSlotHandle);
bound_handled_slot!(talent_at, talent_mut_at, TalentSlot, TalentSlotHandle);
bound_handled_slot!(
    hero_tree_at,
    hero_tree_mut_at,
    HeroTreeSlot,
    HeroTreeSlotHandle
);
bound_handled_slot!(item_at, item_mut_at, ItemSlot, ItemSlotHandle);
bound_handled_slot!(swing_at, swing_mut_at, SwingSlot, SwingSlotHandle);
bound_handled_slot!(
    equipment_at,
    equipment_mut_at,
    EquipmentSlot,
    EquipmentSlotHandle
);
bound_handled_slot!(
    set_bonus_at,
    set_bonus_mut_at,
    SetBonusSlot,
    SetBonusSlotHandle
);
bound_handled_slot!(
    weapon_imbue_at,
    weapon_imbue_mut_at,
    WeaponImbueSlot,
    WeaponImbueSlotHandle
);

impl std::ops::Deref for BoundDenseBuffer {
    type Target = DenseBuffer;

    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}

impl std::ops::DerefMut for BoundDenseBuffer {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}