use std::marker::PhantomData;
use super::structural_common::{raw_ffi_any_same_as, structural_error_from_raw};
use crate::any::{Any, AnyView, TryFromTemp};
use crate::error::{Error, Result};
use crate::tvm_ffi_sys::{TVMFFIAny, TVMFFITypeIndex};
use crate::type_traits::{AnyCompatible, ContainerElement};
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct Unchanged;
#[repr(transparent)]
pub struct UnchangedOr<T: ContainerElement = Any> {
data: Any,
_marker: PhantomData<T>,
}
impl<T: ContainerElement> UnchangedOr<T> {
#[inline]
pub fn unchanged() -> Self {
Self {
data: Unchanged.into(),
_marker: PhantomData,
}
}
#[inline]
pub fn changed(value: T) -> Self {
let mut raw = TVMFFIAny::new();
unsafe {
T::container_move_to_any(value, &mut raw);
Self {
data: Any::from_raw_ffi_any(raw),
_marker: PhantomData,
}
}
}
#[inline]
pub fn is_unchanged(&self) -> bool {
is_unchanged(&self.data)
}
#[inline]
pub fn unchanged_or_same_as(&self, original: &T) -> bool {
if self.is_unchanged() {
return true;
}
let mut raw = TVMFFIAny::new();
unsafe {
T::container_copy_to_any_view(original, &mut raw);
}
raw_ffi_any_same_as(raw, *self.data.as_raw_ffi_any())
}
#[inline]
pub fn into_option(self) -> Option<T> {
if self.is_unchanged() {
return None;
}
unsafe {
let mut raw = Any::into_raw_ffi_any(self.data);
Some(T::container_move_from_any_after_check(&mut raw))
}
}
#[inline]
pub fn value_or_unchanged(self, original: T) -> T {
self.into_option().unwrap_or(original)
}
#[inline]
pub fn map<U: ContainerElement>(self, convert: impl FnOnce(T) -> U) -> UnchangedOr<U> {
match self.into_option() {
Some(value) => UnchangedOr::changed(convert(value)),
None => UnchangedOr::unchanged(),
}
}
}
impl UnchangedOr<Any> {
#[inline(always)]
pub(crate) fn from_any(data: Any) -> Self {
Self {
data,
_marker: PhantomData,
}
}
#[inline(always)]
pub(crate) fn from_carrier(data: Any) -> Result<Self> {
if data.type_index() == TVMFFITypeIndex::kTVMFFIError as i32 {
core::hint::cold_path();
return unsafe {
let raw = Any::into_raw_ffi_any(data);
Err(structural_error_from_raw(raw))
};
}
Ok(Self {
data,
_marker: PhantomData,
})
}
}
impl<T: ContainerElement> Clone for UnchangedOr<T> {
#[inline]
fn clone(&self) -> Self {
Self {
data: self.data.clone(),
_marker: PhantomData,
}
}
}
crate::impl_into_arg!(impl[T: ContainerElement] UnchangedOr<T>);
impl<'b, T: ContainerElement> TryFrom<&'b Any> for UnchangedOr<T> {
type Error = Error;
#[inline]
fn try_from(value: &'b Any) -> Result<Self> {
TryFromTemp::<Self>::try_from(value).map(TryFromTemp::into_value)
}
}
impl<T: ContainerElement> TryFrom<Any> for UnchangedOr<T> {
type Error = Error;
#[inline]
fn try_from(value: Any) -> Result<Self> {
TryFromTemp::<Self>::try_from(value).map(TryFromTemp::into_value)
}
}
impl<'a, T: ContainerElement> TryFrom<AnyView<'a>> for UnchangedOr<T> {
type Error = Error;
#[inline]
fn try_from(value: AnyView<'a>) -> Result<Self> {
TryFromTemp::<Self>::try_from(value).map(TryFromTemp::into_value)
}
}
#[inline]
pub(crate) fn is_unchanged(value: &Any) -> bool {
value.type_index() == TVMFFITypeIndex::kTVMFFIUnchanged as i32
}
unsafe impl AnyCompatible for Unchanged {
unsafe fn copy_to_any_view(_src: &Self, data: &mut TVMFFIAny) {
*data = TVMFFIAny::new();
data.type_index = TVMFFITypeIndex::kTVMFFIUnchanged as i32;
}
unsafe fn move_to_any(src: Self, data: &mut TVMFFIAny) {
unsafe { Self::copy_to_any_view(&src, data) };
}
unsafe fn check_any_strict(data: &TVMFFIAny) -> bool {
data.type_index == TVMFFITypeIndex::kTVMFFIUnchanged as i32
}
unsafe fn copy_from_any_view_after_check(_data: &TVMFFIAny) -> Self {
Self
}
unsafe fn move_from_any_after_check(_data: &mut TVMFFIAny) -> Self {
Self
}
unsafe fn try_cast_from_any_view(data: &TVMFFIAny) -> std::result::Result<Self, ()> {
unsafe { Self::check_any_strict(data).then_some(Self).ok_or(()) }
}
fn type_str() -> std::string::String {
"Unchanged".into()
}
fn type_schema() -> std::string::String {
crate::type_traits::type_schema("ffi.Unchanged", &[])
}
}
crate::impl_try_from_any!(Unchanged);
crate::impl_into_arg!(Unchanged);
unsafe impl<T: ContainerElement> AnyCompatible for UnchangedOr<T> {
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 {
if T::CONTAINER_IS_ANY {
data.type_index != TVMFFITypeIndex::kTVMFFIError as i32
} else {
unsafe { Unchanged::check_any_strict(data) || T::container_check_any_strict(data) }
}
}
unsafe fn match_constraints(data: &TVMFFIAny) -> bool {
unsafe { Unchanged::check_any_strict(data) || T::container_match_constraints(data) }
}
unsafe fn copy_from_any_view_after_check(data: &TVMFFIAny) -> Self {
if unsafe { Unchanged::check_any_strict(data) } {
return Self::unchanged();
}
unsafe { Self::changed(T::container_copy_from_any_view_after_check(data)) }
}
unsafe fn move_from_any_after_check(data: &mut TVMFFIAny) -> Self {
unsafe {
Self {
data: Any::from_raw_ffi_any(std::mem::replace(data, TVMFFIAny::new())),
_marker: PhantomData,
}
}
}
unsafe fn try_cast_from_any_view(data: &TVMFFIAny) -> std::result::Result<Self, ()> {
if T::CONTAINER_IS_ANY && data.type_index == TVMFFITypeIndex::kTVMFFIError as i32 {
return Err(());
}
if unsafe { Unchanged::check_any_strict(data) } {
return Ok(Self::unchanged());
}
unsafe { T::container_try_cast_from_any_view(data).map(Self::changed) }
}
fn type_str() -> std::string::String {
format!("UnchangedOr<{}>", T::container_type_str())
}
fn type_schema() -> std::string::String {
crate::type_traits::type_schema("UnchangedOr", &[T::container_type_schema()])
}
}
impl From<Unchanged> for UnchangedOr<Any> {
#[inline]
fn from(_: Unchanged) -> Self {
Self::unchanged()
}
}
impl<T: crate::object::ObjectRefCore> From<T> for UnchangedOr<Any> {
#[inline]
fn from(value: T) -> Self {
Self::changed(Any::from(value))
}
}
impl<T: crate::object::ObjectRefCore> From<UnchangedOr<T>> for UnchangedOr<Any> {
#[inline]
fn from(value: UnchangedOr<T>) -> Self {
Self::from_any(Any::from(value))
}
}
macro_rules! impl_unchanged_or_any_from_scalar {
($($ty:ty),*) => {
$(
impl From<$ty> for UnchangedOr<Any> {
#[inline]
fn from(value: $ty) -> Self {
Self::changed(Any::from(value))
}
}
impl From<UnchangedOr<$ty>> for UnchangedOr<Any> {
#[inline]
fn from(value: UnchangedOr<$ty>) -> Self {
Self::from_any(Any::from(value))
}
}
)*
};
}
impl_unchanged_or_any_from_scalar!(
bool, i8, i16, i32, i64, isize, u8, u16, u32, u64, usize, f32, f64
);