dungeon_cell/vtable/

static_vtable.rs

use core::any::TypeId;
use core::fmt;

use crate::bound::{Dynamic, Subset};
use crate::marker_traits::IsBound;

use super::{
    BoundsImpl, ConstVTableOf, Descriptor, Inspect, VTable, VTableOf,
    VTableSubset,
};

/// Implementation of [`VTable`] for `'static` types.
///
/// Static instances of [`StaticVTable`] can be made automatically for any type
/// using the [`VTableOf`] or [`ConstVTableOf`] trait. These instances are created using automatic static
/// promotion and therefore have no runtime overhead to create them.
///
/// # Examples
///
/// ```
/// use dungeon_cell::vtable::{StaticVTable, VTableOf, VTable};
/// use dungeon_cell::bound::bounds;
///
/// // get vtable for i32
/// let vtable = StaticVTable::<bounds::Normal>::new::<i32>();
///
/// assert_eq!(vtable.descriptor().type_name(), "i32");
/// assert_eq!(vtable.descriptor().size(), 4);
/// assert_eq!(vtable.descriptor().alignment(), 4);
///
/// // get static vtable for f64
/// let vtable = <&'static StaticVTable<bounds::Normal> as VTableOf<f64>>::instance();
///
/// assert_eq!(vtable.descriptor().type_name(), "f64");
/// assert_eq!(vtable.descriptor().size(), 8);
/// assert_eq!(vtable.descriptor().alignment(), 8);
/// ```
#[derive(Clone)]
#[repr(C)]
pub struct StaticVTable<B> {
    bound_impl: BoundsImpl<B>,
    descriptor: Descriptor<Static>,
}

impl<B> fmt::Debug for StaticVTable<B> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("StaticVTable")
            .field("type_name", &self.descriptor.type_name())
            .field("type_id", &self.descriptor.id().0)
            .field("size", &self.descriptor.size)
            .field("alignment", &self.descriptor.alignment)
            .finish()
    }
}

impl<B: IsBound> StaticVTable<B> {
    /// Return the const instance of the vtable for `T`.
    pub const fn new<T: 'static>() -> Self
    where
        T: Dynamic<B>,
    {
        <Self as ConstVTableOf<T>>::INSTANCE
    }
}

/// Static type ID.
///
/// Available for all `'static` types.
///
/// # Examples
/// ```
/// use dungeon_cell::vtable::{Static, Inspect};
///
/// assert_ne!(
///     <i32 as Inspect<Static>>::inspect(),
///     <f32 as Inspect<Static>>::inspect()
/// );
/// ```
#[derive(Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash, Debug)]
pub struct Static(TypeId);

// SAFETY: TypeId is well behaved and we always return the one for T.
unsafe impl<T: 'static> Inspect<Static> for T {
    fn inspect() -> Static {
        Static(TypeId::of::<T>())
    }
}

// SAFETY:
// The descriptor and bounds impl are always in sync.
// The Static Id type is well behaved because its built on TypeId.
unsafe impl<B: IsBound> VTable for StaticVTable<B> {
    type Bounds = B;

    type Id = Static;

    fn descriptor(&self) -> &super::Descriptor<Self::Id> {
        &self.descriptor
    }

    fn bound_impl(&self) -> &BoundsImpl<Self::Bounds> {
        &self.bound_impl
    }
}

// SAFETY: The type we describe doesnt change.
unsafe impl<B: IsBound, Bnew: IsBound> VTableSubset<Bnew> for StaticVTable<B>
where
    Bnew: Subset<B>,
{
    type Subset = StaticVTable<Bnew>;

    fn into_subset(self) -> Self::Subset {
        StaticVTable {
            bound_impl: self.bound_impl.into_subset::<Bnew>(),
            descriptor: self.descriptor,
        }
    }
}

// SAFETY: The type we describe doesnt change.
unsafe impl<'a, B: IsBound, Bnew: IsBound> VTableSubset<Bnew>
    for &'a StaticVTable<B>
where
    Bnew: Subset<B>,
{
    type Subset = &'a StaticVTable<Bnew>;

    fn into_subset(self) -> Self::Subset {
        // SAFETY: StaticVTable is repr(C) and BoundsImpl says its safe to transmute it
        // if we follow the Subset rule which we do.
        // Descriptor doesnt need to be repr(C) because it has the same type.
        unsafe {
            &*(self as *const StaticVTable<B> as *const StaticVTable<Bnew>)
        }
    }
}

// SAFETY: The returned vtable is for type T and the function doesn't ever panic.
unsafe impl<T: 'static, B: IsBound> VTableOf<T> for StaticVTable<B>
where
    T: Dynamic<B>,
{
    fn instance() -> Self {
        Self::new::<T>()
    }
}

// SAFETY: The returned vtable is for type T.
unsafe impl<T: 'static, B: IsBound> ConstVTableOf<T> for StaticVTable<B>
where
    T: Dynamic<B>,
{
    const INSTANCE: Self = Self {
        descriptor: Descriptor::new::<T>(),
        bound_impl: BoundsImpl::new::<T>(),
    };
}

// SAFETY: The returned vtable is for type T and the function doesn't ever panic.
unsafe impl<'a, T: 'static, B: IsBound> VTableOf<T> for &'a StaticVTable<B>
where
    T: Dynamic<B>,
{
    fn instance() -> Self {
        &ConstVTableOf::<T>::INSTANCE
    }
}

// SAFETY: The returned vtable is for type T.
unsafe impl<'a, T: 'static, B: IsBound> ConstVTableOf<T> for &'a StaticVTable<B>
where
    T: Dynamic<B>,
{
    const INSTANCE: Self = &ConstVTableOf::<T>::INSTANCE;
}

#[cfg(test)]
mod test {
    use core::mem::MaybeUninit;
    use core::sync::atomic::AtomicBool;

    use crate::bound::bounds;

    use super::*;

    #[test]
    fn has_debug() {
        let _ = format!("{:?}", StaticVTable::<bounds::Normal>::new::<i32>());
    }

    #[test]
    fn can_drop_a_t() {
        static Y: AtomicBool = AtomicBool::new(false);

        struct X {
            a: i32,
        }

        impl Drop for X {
            fn drop(&mut self) {
                assert_eq!(self.a, 123);

                Y.store(true, core::sync::atomic::Ordering::Relaxed);
            }
        }

        let v = StaticVTable::<bounds::Empty>::new::<X>();

        let mut x = MaybeUninit::new(X { a: 123 });

        unsafe { v.bound_impl().drop_value(x.as_mut_ptr() as _) };

        assert!(Y.load(core::sync::atomic::Ordering::Relaxed));
    }

    #[test]
    fn vtable_interface() {
        fn assert_for<T: 'static>() {
            let v = StaticVTable::<bounds::Empty>::new::<T>();

            assert_eq!(v.descriptor().size(), core::mem::size_of::<T>());
            assert_eq!(v.descriptor().alignment(), core::mem::align_of::<T>());
            // assert_eq!(v.is_type::<T>());
            let _ = v.descriptor().type_name();

            let _ = <StaticVTable<bounds::Empty> as VTableOf<T>>::instance();
            let _ = <&StaticVTable<bounds::Empty> as VTableOf<T>>::instance();

            let _ = <StaticVTable<bounds::Empty> as ConstVTableOf<T>>::INSTANCE;
            let _ =
                <&StaticVTable<bounds::Empty> as ConstVTableOf<T>>::INSTANCE;
        }

        assert_for::<i32>();
        assert_for::<String>();
        assert_for::<()>();
        assert_for::<u8>();
        assert_for::<[i32; 100]>();
    }
}