lyra-engine/lyra-ecs/src/component_info.rs

use std::{any::TypeId, alloc::Layout};

/// A dynamic type id. Supports types that are not known to Rust.
#[derive(Clone, Copy, Hash, Debug, PartialEq, Eq)]
pub enum DynTypeId {
    Rust(TypeId),
    Unknown(u128),
}

impl From<u128> for DynTypeId {
    fn from(val: u128) -> Self {
        DynTypeId::Unknown(val)
    }
}

impl From<TypeId> for DynTypeId {
    fn from(val: TypeId) -> Self {
        DynTypeId::Rust(val)
    }
}

/* impl From<TypeId> for DynTypeId {
    fn from(value: TypeId) -> Self {
        DynTypeId::Rust(value)
    }
} */

impl DynTypeId {
    pub fn of<T: 'static>() -> Self {
        Self::Rust(TypeId::of::<T>())
    }

    pub fn is<T: 'static>(&self) -> bool {
        match self {
            DynTypeId::Rust(tyid) => *tyid == TypeId::of::<T>(),
            DynTypeId::Unknown(_) => false,
        }
    }

    pub fn is_id<I: Into<DynTypeId>>(&self, id: I) -> bool {
        let id = id.into();
        *self == id
    }

        /// Force self into a rust TypeId, will panic if this type is not a Rust type.
    pub fn as_rust(&self) -> TypeId {
        match self {
            DynTypeId::Rust(t) => *t,
            DynTypeId::Unknown(_) => panic!("This type is unknown to rust, cannot construct a TypeId from it!"),
        }
    }
}

/// Some information about a component.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct ComponentInfo {
    pub type_id: DynTypeId,
    pub(crate) layout: Layout,
}

impl ComponentInfo {
    pub fn new<T: 'static>() -> Self {
        Self {
            type_id: TypeId::of::<T>().into(),
            layout: Layout::new::<T>(),
        }
    }

    /// Create ComponentInfo from a type that is not known to rust
    pub fn new_unknown<D>(type_id: D, name: &str, layout: Layout) -> Self
    where
        D: Into<DynTypeId>,
    {
        let _ = name; // would be used at some point
        Self {
            type_id: type_id.into(),
            layout,
        }
    }
}