1use crate::any::Any;
32use crate::string::{Bytes, String};
33use crate::type_traits::AnyCompatible;
34use std::fmt::{self, Debug};
35use std::marker::PhantomData;
36use tvm_ffi_sys::TVMFFIAny;
37
38#[diagnostic::on_unimplemented(
53 message = "`Optional<{Self}>` only mirrors non-object-pointer `ffi::Optional` values",
54 label = "`{Self}` uses the object-pointer optional representation",
55 note = "use `Option<{Self}>` for object classes; it is the compatible nullable-pointer layout"
56)]
57pub unsafe trait OptionalCompatible: AnyCompatible {}
58
59macro_rules! impl_optional_compatible {
60 ($($t:ty),* $(,)?) => {
61 $(unsafe impl OptionalCompatible for $t {})*
62 };
63}
64
65impl_optional_compatible!(
66 bool,
67 i8,
68 i16,
69 i32,
70 i64,
71 isize,
72 u8,
73 u16,
74 u32,
75 u64,
76 usize,
77 f32,
78 f64,
79 *mut core::ffi::c_void,
80 crate::DLDataType,
81 crate::DLDevice,
82 String,
83 Bytes,
84 crate::big_int::BigInt,
85);
86
87#[repr(transparent)]
90pub struct Optional<T: OptionalCompatible> {
91 data: Any,
93 _marker: PhantomData<T>,
94}
95
96unsafe impl<T: OptionalCompatible + Send + Sync> Send for Optional<T> {}
99unsafe impl<T: OptionalCompatible + Send + Sync> Sync for Optional<T> {}
100
101const _: () = assert!(
104 std::mem::size_of::<Optional<i64>>() == 16
105 && std::mem::size_of::<Optional<String>>() == 16
106 && std::mem::align_of::<Optional<i64>>()
107 == std::mem::align_of::<crate::tvm_ffi_sys::TVMFFIAny>()
108);
109
110impl<T: OptionalCompatible> Optional<T> {
111 #[inline]
113 pub fn some(value: T) -> Self {
114 Self {
115 data: Any::from(value),
116 _marker: PhantomData,
117 }
118 }
119
120 #[inline]
122 pub fn none() -> Self {
123 Self {
124 data: Any::new(),
125 _marker: PhantomData,
126 }
127 }
128
129 #[inline]
131 pub fn is_some(&self) -> bool {
132 !self.data.is_none()
133 }
134
135 #[inline]
137 pub fn is_none(&self) -> bool {
138 !self.is_some()
139 }
140
141 #[inline]
143 pub fn get(&self) -> Option<T> {
144 let cell = self.data.as_raw_ffi_any();
146 unsafe { T::check_any_strict(cell).then(|| T::copy_from_any_view_after_check(cell)) }
149 }
150
151 #[inline]
153 pub fn into_option(self) -> Option<T> {
154 if self.is_some() {
155 let mut raw = Any::into_raw_ffi_any(self.data);
158 Some(unsafe { T::move_from_any_after_check(&mut raw) })
159 } else {
160 None
161 }
162 }
163
164 #[inline]
166 pub fn set(&mut self, value: Option<T>) {
167 self.data = match value {
169 Some(v) => Any::from(v),
170 None => Any::new(),
171 };
172 }
173}
174
175impl<T: OptionalCompatible + crate::type_traits::RefFromAnyUnchecked> Optional<T> {
176 #[inline]
192 pub fn as_ref(&self) -> Option<&T> {
193 if self.is_some() {
194 Some(unsafe { T::ref_from_any_unchecked(self.data.as_raw_ffi_any()) })
196 } else {
197 None
198 }
199 }
200}
201
202impl Optional<String> {
203 #[inline]
205 pub fn as_str(&self) -> Option<&str> {
206 if self.is_some() {
207 let s = unsafe { &*(&self.data as *const Any as *const String) };
211 Some(s.as_str())
212 } else {
213 None
214 }
215 }
216}
217
218unsafe impl<T: OptionalCompatible> AnyCompatible for Optional<T> {
221 fn type_str() -> std::string::String {
222 Option::<T>::type_str()
223 }
224
225 fn type_schema() -> std::string::String {
226 Option::<T>::type_schema()
227 }
228
229 unsafe fn copy_to_any_view(src: &Self, data: &mut TVMFFIAny) {
230 *data = *src.data.as_raw_ffi_any();
231 }
232
233 unsafe fn move_to_any(src: Self, data: &mut TVMFFIAny) {
234 *data = Any::into_raw_ffi_any(src.data);
235 }
236
237 unsafe fn check_any_strict(data: &TVMFFIAny) -> bool {
238 unsafe { Option::<T>::check_any_strict(data) }
239 }
240
241 unsafe fn match_constraints(data: &TVMFFIAny) -> bool {
242 unsafe { Option::<T>::match_constraints(data) }
243 }
244
245 unsafe fn copy_from_any_view_after_check(data: &TVMFFIAny) -> Self {
246 unsafe { Option::<T>::copy_from_any_view_after_check(data).into() }
247 }
248
249 unsafe fn move_from_any_after_check(data: &mut TVMFFIAny) -> Self {
250 unsafe { Option::<T>::move_from_any_after_check(data).into() }
251 }
252
253 unsafe fn try_cast_from_any_view(data: &TVMFFIAny) -> Result<Self, ()> {
254 unsafe { Option::<T>::try_cast_from_any_view(data).map(Self::from) }
255 }
256}
257
258crate::impl_into_arg!(impl[T: OptionalCompatible] Optional<T>);
259
260impl<T: OptionalCompatible> Default for Optional<T> {
261 #[inline]
263 fn default() -> Self {
264 Self::none()
265 }
266}
267
268impl<T: OptionalCompatible> Clone for Optional<T> {
269 #[inline]
270 fn clone(&self) -> Self {
271 Self {
272 data: self.data.clone(),
274 _marker: PhantomData,
275 }
276 }
277}
278
279impl<T: OptionalCompatible + PartialEq> PartialEq for Optional<T> {
280 #[inline]
281 fn eq(&self, other: &Self) -> bool {
282 self.get() == other.get()
283 }
284}
285
286impl<T: OptionalCompatible + Eq> Eq for Optional<T> {}
287
288impl<T: OptionalCompatible> From<Option<T>> for Optional<T> {
289 #[inline]
290 fn from(value: Option<T>) -> Self {
291 match value {
292 Some(v) => Self::some(v),
293 None => Self::none(),
294 }
295 }
296}
297
298impl<T: OptionalCompatible> From<Optional<T>> for Option<T> {
299 #[inline]
300 fn from(value: Optional<T>) -> Self {
301 value.into_option()
302 }
303}
304
305impl<T: OptionalCompatible + Debug> Debug for Optional<T> {
306 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
307 match self.get() {
308 Some(v) => write!(f, "Optional::Some({v:?})"),
309 None => f.write_str("Optional::None"),
310 }
311 }
312}