use crate::any::Any;
use crate::string::{Bytes, String};
use crate::type_traits::AnyCompatible;
use std::fmt::{self, Debug};
use std::marker::PhantomData;
use tvm_ffi_sys::TVMFFIAny;
#[diagnostic::on_unimplemented(
message = "`Optional<{Self}>` only mirrors non-object-pointer `ffi::Optional` values",
label = "`{Self}` uses the object-pointer optional representation",
note = "use `Option<{Self}>` for object classes; it is the compatible nullable-pointer layout"
)]
pub unsafe trait OptionalCompatible: AnyCompatible {}
macro_rules! impl_optional_compatible {
($($t:ty),* $(,)?) => {
$(unsafe impl OptionalCompatible for $t {})*
};
}
impl_optional_compatible!(
bool,
i8,
i16,
i32,
i64,
isize,
u8,
u16,
u32,
u64,
usize,
f32,
f64,
*mut core::ffi::c_void,
crate::DLDataType,
crate::DLDevice,
String,
Bytes,
crate::big_int::BigInt,
);
#[repr(transparent)]
pub struct Optional<T: OptionalCompatible> {
data: Any,
_marker: PhantomData<T>,
}
unsafe impl<T: OptionalCompatible + Send + Sync> Send for Optional<T> {}
unsafe impl<T: OptionalCompatible + Send + Sync> Sync for Optional<T> {}
const _: () = assert!(
std::mem::size_of::<Optional<i64>>() == 16
&& std::mem::size_of::<Optional<String>>() == 16
&& std::mem::align_of::<Optional<i64>>()
== std::mem::align_of::<crate::tvm_ffi_sys::TVMFFIAny>()
);
impl<T: OptionalCompatible> Optional<T> {
#[inline]
pub fn some(value: T) -> Self {
Self {
data: Any::from(value),
_marker: PhantomData,
}
}
#[inline]
pub fn none() -> Self {
Self {
data: Any::new(),
_marker: PhantomData,
}
}
#[inline]
pub fn is_some(&self) -> bool {
!self.data.is_none()
}
#[inline]
pub fn is_none(&self) -> bool {
!self.is_some()
}
#[inline]
pub fn get(&self) -> Option<T> {
let cell = self.data.as_raw_ffi_any();
unsafe { T::check_any_strict(cell).then(|| T::copy_from_any_view_after_check(cell)) }
}
#[inline]
pub fn into_option(self) -> Option<T> {
if self.is_some() {
let mut raw = Any::into_raw_ffi_any(self.data);
Some(unsafe { T::move_from_any_after_check(&mut raw) })
} else {
None
}
}
#[inline]
pub fn set(&mut self, value: Option<T>) {
self.data = match value {
Some(v) => Any::from(v),
None => Any::new(),
};
}
}
impl<T: OptionalCompatible + crate::type_traits::RefFromAnyUnchecked> Optional<T> {
#[inline]
pub fn as_ref(&self) -> Option<&T> {
if self.is_some() {
Some(unsafe { T::ref_from_any_unchecked(self.data.as_raw_ffi_any()) })
} else {
None
}
}
}
impl Optional<String> {
#[inline]
pub fn as_str(&self) -> Option<&str> {
if self.is_some() {
let s = unsafe { &*(&self.data as *const Any as *const String) };
Some(s.as_str())
} else {
None
}
}
}
unsafe impl<T: OptionalCompatible> AnyCompatible for Optional<T> {
fn type_str() -> std::string::String {
Option::<T>::type_str()
}
fn type_schema() -> std::string::String {
Option::<T>::type_schema()
}
unsafe fn copy_to_any_view(src: &Self, data: &mut TVMFFIAny) {
*data = *src.data.as_raw_ffi_any();
}
unsafe fn move_to_any(src: Self, data: &mut TVMFFIAny) {
*data = Any::into_raw_ffi_any(src.data);
}
unsafe fn check_any_strict(data: &TVMFFIAny) -> bool {
unsafe { Option::<T>::check_any_strict(data) }
}
unsafe fn match_constraints(data: &TVMFFIAny) -> bool {
unsafe { Option::<T>::match_constraints(data) }
}
unsafe fn copy_from_any_view_after_check(data: &TVMFFIAny) -> Self {
unsafe { Option::<T>::copy_from_any_view_after_check(data).into() }
}
unsafe fn move_from_any_after_check(data: &mut TVMFFIAny) -> Self {
unsafe { Option::<T>::move_from_any_after_check(data).into() }
}
unsafe fn try_cast_from_any_view(data: &TVMFFIAny) -> Result<Self, ()> {
unsafe { Option::<T>::try_cast_from_any_view(data).map(Self::from) }
}
}
crate::impl_into_arg!(impl[T: OptionalCompatible] Optional<T>);
impl<T: OptionalCompatible> Default for Optional<T> {
#[inline]
fn default() -> Self {
Self::none()
}
}
impl<T: OptionalCompatible> Clone for Optional<T> {
#[inline]
fn clone(&self) -> Self {
Self {
data: self.data.clone(),
_marker: PhantomData,
}
}
}
impl<T: OptionalCompatible + PartialEq> PartialEq for Optional<T> {
#[inline]
fn eq(&self, other: &Self) -> bool {
self.get() == other.get()
}
}
impl<T: OptionalCompatible + Eq> Eq for Optional<T> {}
impl<T: OptionalCompatible> From<Option<T>> for Optional<T> {
#[inline]
fn from(value: Option<T>) -> Self {
match value {
Some(v) => Self::some(v),
None => Self::none(),
}
}
}
impl<T: OptionalCompatible> From<Optional<T>> for Option<T> {
#[inline]
fn from(value: Optional<T>) -> Self {
value.into_option()
}
}
impl<T: OptionalCompatible + Debug> Debug for Optional<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self.get() {
Some(v) => write!(f, "Optional::Some({v:?})"),
None => f.write_str("Optional::None"),
}
}
}