use crate::error::Error;
use crate::object;
use crate::type_traits::AnyCompatible;
use tvm_ffi_sys::TVMFFITypeIndex as TypeIndex;
use tvm_ffi_sys::{TVMFFIAny, TVMFFIAnyViewToOwnedAny};
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AnyView<'a> {
data: TVMFFIAny,
_phantom: std::marker::PhantomData<&'a ()>,
}
#[repr(C)]
pub struct Any {
data: TVMFFIAny,
}
impl<'a> AnyView<'a> {
pub fn new() -> Self {
Self {
data: TVMFFIAny::new(),
_phantom: std::marker::PhantomData,
}
}
#[doc(hidden)]
#[inline(always)]
pub fn from_object<T: object::ObjectCore>(value: &'a T) -> Self {
let pointer = std::ptr::from_ref(value).cast::<tvm_ffi_sys::TVMFFIObject>();
let header = unsafe { &*pointer };
assert!(
header.type_index >= TypeIndex::kTVMFFIStaticObjectBegin as i32
&& header.deleter.is_some()
&& header
.combined_ref_count
.load(std::sync::atomic::Ordering::Relaxed)
& tvm_ffi_sys::COMBINED_REF_COUNT_MASK_U32
!= 0,
"cannot borrow an unmanaged or dead object as AnyView"
);
let mut data = TVMFFIAny::new();
data.type_index = header.type_index;
data.data_union.v_obj = pointer.cast_mut();
unsafe { Self::from_raw_ffi_any(data) }
}
#[inline(always)]
pub fn type_index(&self) -> i32 {
self.data.type_index
}
#[inline]
pub fn type_key(&self) -> &'static str {
object::registered_type_key(self.data.type_index)
}
#[inline(always)]
pub fn is_none(&self) -> bool {
self.data.type_index == TypeIndex::kTVMFFINone as i32
}
#[inline(always)]
pub fn as_raw_ffi_any(&self) -> &TVMFFIAny {
&self.data
}
#[inline(always)]
pub unsafe fn from_raw_ffi_any(data: TVMFFIAny) -> Self {
Self {
data,
_phantom: std::marker::PhantomData,
}
}
#[inline(always)]
pub fn downcast_ref<T: crate::type_traits::DowncastRefFromAny>(&self) -> Option<&T> {
unsafe { T::downcast_ref_from_any(&self.data) }
}
#[inline(always)]
pub fn is<T: AnyCompatible>(&self) -> bool {
unsafe { T::check_any_strict(&self.data) }
}
#[doc(hidden)]
pub fn debug_strong_count(&self) -> Option<usize> {
unsafe {
if self.data.type_index >= TypeIndex::kTVMFFIStaticObjectBegin as i32 {
Some(object::unsafe_::strong_count(self.data.data_union.v_obj))
} else {
None
}
}
}
}
impl<'a> From<&'a object::Object> for AnyView<'a> {
#[inline(always)]
fn from(value: &'a object::Object) -> Self {
Self::from_object(value)
}
}
impl<'a, T: AnyCompatible> From<&'a T> for AnyView<'a> {
#[inline(always)]
fn from(value: &'a T) -> Self {
unsafe {
let mut data = TVMFFIAny::new();
T::copy_to_any_view(value, &mut data);
Self {
data,
_phantom: std::marker::PhantomData,
}
}
}
}
impl<'a> From<&AnyView<'a>> for AnyView<'a> {
#[inline(always)]
fn from(value: &AnyView<'a>) -> Self {
*value
}
}
impl Default for AnyView<'_> {
fn default() -> Self {
Self::new()
}
}
#[doc(hidden)]
pub struct TryFromTemp<T> {
value: T,
}
impl<T> TryFromTemp<T> {
#[inline(always)]
pub fn new(value: T) -> Self {
Self { value }
}
#[inline(always)]
pub fn into_value(this: Self) -> T {
this.value
}
}
impl Any {
#[inline(always)]
pub fn new() -> Self {
Self {
data: TVMFFIAny::new(),
}
}
#[inline(always)]
pub fn type_index(&self) -> i32 {
self.data.type_index
}
#[inline]
pub fn type_key(&self) -> &'static str {
object::registered_type_key(self.data.type_index)
}
#[inline(always)]
pub fn is_none(&self) -> bool {
self.data.type_index == TypeIndex::kTVMFFINone as i32
}
#[inline(always)]
pub fn as_raw_ffi_any(&self) -> &TVMFFIAny {
&self.data
}
#[inline]
pub fn downcast_ref<T: crate::type_traits::DowncastRefFromAny>(&self) -> Option<&T> {
unsafe { T::downcast_ref_from_any(&self.data) }
}
#[inline(always)]
pub fn is<T: AnyCompatible>(&self) -> bool {
unsafe { T::check_any_strict(&self.data) }
}
#[inline(always)]
pub fn as_raw_ffi_any_mut(&mut self) -> *mut TVMFFIAny {
&mut self.data
}
#[inline(always)]
pub fn into_raw_ffi_any(self) -> TVMFFIAny {
let this = std::mem::ManuallyDrop::new(self);
this.data
}
#[inline(always)]
pub unsafe fn from_raw_ffi_any(data: TVMFFIAny) -> Self {
Self { data }
}
#[doc(hidden)]
pub fn debug_strong_count(&self) -> Option<usize> {
unsafe {
if self.data.type_index >= TypeIndex::kTVMFFIStaticObjectBegin as i32 {
Some(object::unsafe_::strong_count(self.data.data_union.v_obj))
} else {
None
}
}
}
}
impl Default for Any {
#[inline(always)]
fn default() -> Self {
Self::new()
}
}
impl Clone for Any {
#[inline]
fn clone(&self) -> Self {
if self.data.type_index >= TypeIndex::kTVMFFIStaticObjectBegin as i32 {
unsafe { object::unsafe_::inc_ref(self.data.data_union.v_obj) }
}
Self { data: self.data }
}
}
impl Drop for Any {
#[inline(always)]
fn drop(&mut self) {
if self.data.type_index >= TypeIndex::kTVMFFIStaticObjectBegin as i32 {
unsafe { object::unsafe_::dec_ref(self.data.data_union.v_obj) }
}
}
}
impl<'a> From<&'a Any> for AnyView<'a> {
#[inline(always)]
fn from(value: &'a Any) -> Self {
Self {
data: value.data,
_phantom: std::marker::PhantomData,
}
}
}
impl std::fmt::Display for AnyView<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let repr = crate::cached_global_func!("ffi.ReprPrint")
.call_packed(&[*self])
.and_then(crate::String::try_from);
match repr {
Ok(text) => f.pad(text.as_str()),
Err(_) => f.pad(&object::type_key_of_index(self.type_index())),
}
}
}
impl std::fmt::Display for Any {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
std::fmt::Display::fmt(&AnyView::from(self), f)
}
}
impl std::fmt::Debug for AnyView<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let key = object::type_key_of_index(self.type_index());
write!(f, "AnyView({key}: {self})")
}
}
impl std::fmt::Debug for Any {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let view = AnyView::from(self);
let key = object::type_key_of_index(view.type_index());
write!(f, "Any({key}: {view})")
}
}
#[inline]
pub(crate) fn is_plain_inline(type_index: i32) -> bool {
type_index < TypeIndex::kTVMFFIRawStr as i32
|| type_index == TypeIndex::kTVMFFISmallStr as i32
|| type_index == TypeIndex::kTVMFFISmallBytes as i32
|| type_index == TypeIndex::kTVMFFIUnchanged as i32
}
impl From<AnyView<'_>> for Any {
#[inline]
fn from(value: AnyView<'_>) -> Self {
let data = value.data;
if data.type_index >= TypeIndex::kTVMFFIStaticObjectBegin as i32 {
unsafe { object::unsafe_::inc_ref(data.data_union.v_obj) };
return Self { data };
}
if is_plain_inline(data.type_index) {
return Self { data };
}
any_view_to_owned_via_runtime(data)
}
}
#[cold]
#[inline(never)]
fn any_view_to_owned_via_runtime(view: TVMFFIAny) -> Any {
unsafe {
let mut data = TVMFFIAny::new();
crate::check_safe_call!(TVMFFIAnyViewToOwnedAny(&view, &mut data)).unwrap();
Any { data }
}
}
impl<T: AnyCompatible> From<T> for Any {
#[inline(always)]
fn from(value: T) -> Self {
unsafe {
let mut data = TVMFFIAny::new();
T::move_to_any(value, &mut data);
Self { data }
}
}
}
impl<'a, T: AnyCompatible> TryFrom<AnyView<'a>> for TryFromTemp<T> {
type Error = crate::error::Error;
#[inline]
fn try_from(value: AnyView<'a>) -> Result<Self, Self::Error> {
unsafe {
if T::check_any_strict(&value.data) {
Ok(TryFromTemp::new(T::copy_from_any_view_after_check(
&value.data,
)))
} else {
T::try_cast_from_any_view(&value.data)
.map_err(|_| {
let msg = format!(
"Cannot convert from type `{}` to `{}`",
T::get_mismatch_type_info(&value.data),
T::type_str()
);
crate::error::Error::new(crate::error::TYPE_ERROR, &msg)
})
.map(TryFromTemp::new)
}
}
}
}
impl<'a, T: AnyCompatible> TryFrom<&'a Any> for TryFromTemp<T> {
type Error = crate::error::Error;
#[inline]
fn try_from(value: &'a Any) -> Result<Self, Self::Error> {
TryFromTemp::try_from(AnyView::from(value))
}
}
impl<T: AnyCompatible> TryFrom<Any> for TryFromTemp<T> {
type Error = crate::error::Error;
#[inline]
fn try_from(value: Any) -> Result<Self, Self::Error> {
unsafe {
if T::check_any_strict(&value.data) {
let mut value = std::mem::ManuallyDrop::new(value);
Ok(TryFromTemp::new(T::move_from_any_after_check(
&mut value.data,
)))
} else {
T::try_cast_from_any_view(&value.data)
.map_err(|_| {
let msg = format!(
"Cannot convert from type `{}` to `{}`",
T::get_mismatch_type_info(&value.data),
T::type_str()
);
crate::error::Error::new(crate::error::TYPE_ERROR, &msg)
})
.map(TryFromTemp::new)
}
}
}
}
crate::impl_any_compatible_conversions!(
(),
bool,
i8,
i16,
i32,
i64,
isize,
u8,
u16,
u32,
u64,
usize,
f32,
f64,
crate::string::String,
crate::string::Bytes,
crate::big_int::BigInt,
tvm_ffi_sys::dlpack::DLDataType,
tvm_ffi_sys::dlpack::DLDevice,
);
crate::impl_try_from_any!(*mut core::ffi::c_void, crate::object::ObjectRef);
crate::impl_into_arg!(Any, *mut core::ffi::c_void, crate::object::ObjectRef);
crate::impl_try_from_any_for_parametric!(Option<T>);
crate::impl_into_arg!(impl[T: AnyCompatible + Clone] Option<T>);
pub(crate) trait ArgTryFromAnyView: Sized + crate::type_traits::TypeSchema {
fn try_from_any_view(value: &AnyView, arg_index: usize) -> Result<Self, Error>;
}
impl<T: AnyCompatible> ArgTryFromAnyView for T {
fn try_from_any_view(value: &AnyView, arg_index: usize) -> Result<Self, Error> {
unsafe {
if T::check_any_strict(&value.data) {
Ok(T::copy_from_any_view_after_check(&value.data))
} else {
T::try_cast_from_any_view(&value.data).map_err(|_| {
let msg = format!(
"Argument #{}: Cannot convert from type `{}` to `{}`",
arg_index,
T::get_mismatch_type_info(&value.data),
T::type_str()
);
crate::error::Error::new(crate::error::TYPE_ERROR, &msg)
})
}
}
}
}