use std::marker::PhantomData;
use std::mem::{align_of, size_of};
use super::registry::{ensure_not_opaque_ptr, register_type_attr};
use super::{NativeFunction, TypeAttrColumn, get_method};
use crate::any::TryFromTemp;
use crate::derive::{Object, ObjectRef};
use crate::enum_ref::EnumObj;
use crate::object::{
Object, ObjectArc, ObjectCore, ObjectRef, is_instance_of, lock_type_registration,
};
use crate::tvm_ffi_sys::{TVMFFIGetTypeInfo, TVMFFIObject, TVMFFITypeInfo};
use crate::type_traits::AnyCompatible;
use crate::{Any, AnyView, EnumRef, Error, List, Result, String, TYPE_ERROR, VALUE_ERROR};
pub struct EnumDef<E: EnumRef> {
value: E,
}
impl<E: EnumRef> EnumDef<E> {
pub fn new(name: &str) -> Result<Self>
where
E: crate::object::PlainObjectRef,
{
const {
assert!(
size_of::<E::ContainerType>() == size_of::<EnumObj>()
&& align_of::<E::ContainerType>() == align_of::<EnumObj>(),
"an enum type registered from Rust adds no fields to `EnumObj`"
)
};
let type_index = E::ContainerType::type_index();
let type_key = E::ContainerType::TYPE_KEY;
if name.is_empty() {
return Err(Error::new(
VALUE_ERROR,
&format!("a value name of `{type_key}` must be non-empty"),
));
}
if !is_instance_of::<EnumObj>(type_index) || is_int_enum(type_index) {
return Err(Error::new(
TYPE_ERROR,
&format!("`{type_key}` is not an enum type whose values Rust can register"),
));
}
let metadata = unsafe { (*TVMFFIGetTypeInfo(type_index)).metadata };
let total_size = unsafe { metadata.as_ref() }.map_or(0, |metadata| metadata.total_size);
if total_size != 0 && total_size as usize != size_of::<EnumObj>() {
return Err(Error::new(
TYPE_ERROR,
&format!(
"`{type_key}` objects have fields beyond `ffi.Enum`, so Rust cannot \
register its values"
),
));
}
let _registering = lock_type_registration();
let state = ensure_state(type_index)?;
let index = state.entries.len() as i64;
let key = String::from(name);
let indexes = AnyView::from(&state.indexes);
if dict_get(indexes, AnyView::from(&key))?.is_some()
|| dict_get(indexes, AnyView::from(&index))?.is_some()
{
return Err(Error::new(
VALUE_ERROR,
&format!("Enum `{type_key}` already has a value named `{name}`"),
));
}
let object = ObjectArc::into_raw(ObjectArc::new(EnumObj::new(index, name)));
let value = unsafe {
(*object.cast_mut().cast::<TVMFFIObject>()).type_index = type_index;
E::from_data(ObjectArc::from_raw(object.cast()))
};
state.entries.push(Any::from(value.clone()))?;
dict_set(indexes, AnyView::from(&index), AnyView::from(&value))?;
dict_set(indexes, AnyView::from(&key), AnyView::from(&value))?;
Ok(Self { value })
}
pub fn set_attr(self, name: &str, value: impl Into<Any> + Send + Sync) -> Result<Self> {
let value = value.into();
ensure_not_opaque_ptr(name, &value)?;
self.set_attr_any(name, value)
}
pub unsafe fn set_native_fn_attr<Args, R>(
self,
name: &str,
f: NativeFunction<Args, R>,
) -> Result<Self> {
self.set_attr_any(name, unsafe { f.into_any() })
}
fn set_attr_any(self, name: &str, value: Any) -> Result<Self> {
let type_index = E::ContainerType::type_index();
let _registering = lock_type_registration();
let state = ensure_state(type_index)?;
let attrs = AnyView::from(&state.attrs);
let key = String::from(name);
let column = match dict_get(attrs, AnyView::from(&key))? {
Some(column) => column,
None => {
let column = crate::cached_global_func!("ffi.Dict").call_packed(&[])?;
dict_set(attrs, AnyView::from(&key), AnyView::from(&column))?;
column
}
};
dict_set(
AnyView::from(&column),
AnyView::from(&self.value),
AnyView::from(&value),
)?;
Ok(self)
}
pub fn value(&self) -> E {
self.value.clone()
}
}
pub struct EnumAttrMap<E, V> {
column: Any,
_types: PhantomData<fn() -> (E, V)>,
}
impl<E: EnumRef, V: AnyCompatible> EnumAttrMap<E, V> {
pub(crate) fn lookup(name: &str) -> Result<Option<Self>> {
let Some(state) = enum_state(E::ContainerType::type_index())? else {
return Ok(None);
};
let key = String::from(name);
let column = dict_get(AnyView::from(&state.attrs), AnyView::from(&key))?;
Ok(column.map(|column| Self {
column,
_types: PhantomData,
}))
}
pub fn get(&self, value: &E) -> Result<Option<V>> {
dict_get(AnyView::from(&self.column), AnyView::from(value))?
.map(any_into)
.transpose()
}
}
const ENUM_STATE_ATTR: &str = "__ffi_enum__";
#[repr(C)]
#[derive(Object)]
#[object(type_key = "ffi.EnumState", final)]
pub(crate) struct EnumStateObj {
base_: Object,
entries: List<Any>,
pub(crate) indexes: ObjectRef,
attrs: ObjectRef,
}
#[repr(C)]
#[derive(ObjectRef, Clone)]
pub(crate) struct EnumState {
data: ObjectArc<EnumStateObj>,
}
pub(crate) fn enum_state(type_index: i32) -> Result<Option<EnumState>> {
let Some(column) = TypeAttrColumn::lookup(ENUM_STATE_ATTR) else {
return Ok(None);
};
column.get(type_index).map(EnumState::try_from).transpose()
}
fn ensure_state(type_index: i32) -> Result<EnumState> {
if let Some(state) = enum_state(type_index)? {
return Ok(state);
}
let state: EnumState =
any_into(get_method("ffi.EnumState", "__ffi_init__")?.call_packed(&[])?)?;
register_type_attr(type_index, ENUM_STATE_ATTR, Any::from(state.clone()))?;
Ok(state)
}
fn is_int_enum(type_index: i32) -> bool {
let is_int_enum =
|info: *const TVMFFITypeInfo| unsafe { (*info).type_key.as_str() == "ffi.IntEnum" };
unsafe {
let info = TVMFFIGetTypeInfo(type_index);
!info.is_null()
&& (is_int_enum(info)
|| (0..(*info).type_depth as usize)
.any(|depth| is_int_enum(*(*info).type_acenstors.add(depth))))
}
}
pub(crate) fn dict_get(dict: AnyView<'_>, key: AnyView<'_>) -> Result<Option<Any>> {
let count: i64 = crate::cached_global_func!("ffi.DictCount")
.call_packed(&[dict, key])?
.try_into()?;
if count == 0 {
return Ok(None);
}
crate::cached_global_func!("ffi.DictGetItem")
.call_packed(&[dict, key])
.map(Some)
}
fn dict_set(dict: AnyView<'_>, key: AnyView<'_>, value: AnyView<'_>) -> Result<()> {
crate::cached_global_func!("ffi.DictSetItem").call_packed(&[dict, key, value])?;
Ok(())
}
pub(crate) fn any_into<T: AnyCompatible>(value: Any) -> Result<T> {
TryFromTemp::<T>::try_from(AnyView::from(&value)).map(TryFromTemp::into_value)
}