diff options
Diffstat (limited to 'vendor/cxx/src/weak_ptr.rs')
| -rw-r--r-- | vendor/cxx/src/weak_ptr.rs | 189 |
1 files changed, 0 insertions, 189 deletions
diff --git a/vendor/cxx/src/weak_ptr.rs b/vendor/cxx/src/weak_ptr.rs deleted file mode 100644 index e9320f374..000000000 --- a/vendor/cxx/src/weak_ptr.rs +++ /dev/null @@ -1,189 +0,0 @@ -use crate::shared_ptr::{SharedPtr, SharedPtrTarget}; -use crate::string::CxxString; -use core::ffi::c_void; -use core::fmt::{self, Debug}; -use core::marker::PhantomData; -use core::mem::MaybeUninit; - -/// Binding to C++ `std::weak_ptr<T>`. -/// -/// The typical way to construct a WeakPtr from Rust is by [downgrading] from a -/// SharedPtr. -/// -/// [downgrading]: crate::SharedPtr::downgrade -#[repr(C)] -pub struct WeakPtr<T> -where - T: WeakPtrTarget, -{ - repr: [MaybeUninit<*mut c_void>; 2], - ty: PhantomData<T>, -} - -impl<T> WeakPtr<T> -where - T: WeakPtrTarget, -{ - /// Makes a new WeakPtr wrapping a null pointer. - /// - /// Matches the behavior of default-constructing a std::weak\_ptr. - pub fn null() -> Self { - let mut weak_ptr = MaybeUninit::<WeakPtr<T>>::uninit(); - let new = weak_ptr.as_mut_ptr().cast(); - unsafe { - T::__null(new); - weak_ptr.assume_init() - } - } - - /// Upgrades a non-owning reference into an owning reference if possible, - /// otherwise to a null reference. - /// - /// Matches the behavior of [std::weak_ptr\<T\>::lock](https://en.cppreference.com/w/cpp/memory/weak_ptr/lock). - pub fn upgrade(&self) -> SharedPtr<T> - where - T: SharedPtrTarget, - { - let this = self as *const Self as *const c_void; - let mut shared_ptr = MaybeUninit::<SharedPtr<T>>::uninit(); - let new = shared_ptr.as_mut_ptr().cast(); - unsafe { - T::__upgrade(this, new); - shared_ptr.assume_init() - } - } -} - -unsafe impl<T> Send for WeakPtr<T> where T: Send + Sync + WeakPtrTarget {} -unsafe impl<T> Sync for WeakPtr<T> where T: Send + Sync + WeakPtrTarget {} - -impl<T> Clone for WeakPtr<T> -where - T: WeakPtrTarget, -{ - fn clone(&self) -> Self { - let mut weak_ptr = MaybeUninit::<WeakPtr<T>>::uninit(); - let new = weak_ptr.as_mut_ptr().cast(); - let this = self as *const Self as *mut c_void; - unsafe { - T::__clone(this, new); - weak_ptr.assume_init() - } - } -} - -impl<T> Drop for WeakPtr<T> -where - T: WeakPtrTarget, -{ - fn drop(&mut self) { - let this = self as *mut Self as *mut c_void; - unsafe { T::__drop(this) } - } -} - -impl<T> Debug for WeakPtr<T> -where - T: Debug + WeakPtrTarget + SharedPtrTarget, -{ - fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - Debug::fmt(&self.upgrade(), formatter) - } -} - -/// Trait bound for types which may be used as the `T` inside of a `WeakPtr<T>` -/// in generic code. -/// -/// This trait has no publicly callable or implementable methods. Implementing -/// it outside of the CXX codebase is not supported. -pub unsafe trait WeakPtrTarget { - #[doc(hidden)] - fn __typename(f: &mut fmt::Formatter) -> fmt::Result; - #[doc(hidden)] - unsafe fn __null(new: *mut c_void); - #[doc(hidden)] - unsafe fn __clone(this: *const c_void, new: *mut c_void); - #[doc(hidden)] - unsafe fn __downgrade(shared: *const c_void, new: *mut c_void); - #[doc(hidden)] - unsafe fn __upgrade(weak: *const c_void, shared: *mut c_void); - #[doc(hidden)] - unsafe fn __drop(this: *mut c_void); -} - -macro_rules! impl_weak_ptr_target { - ($segment:expr, $name:expr, $ty:ty) => { - unsafe impl WeakPtrTarget for $ty { - fn __typename(f: &mut fmt::Formatter) -> fmt::Result { - f.write_str($name) - } - unsafe fn __null(new: *mut c_void) { - extern "C" { - attr! { - #[link_name = concat!("cxxbridge1$std$weak_ptr$", $segment, "$null")] - fn __null(new: *mut c_void); - } - } - unsafe { __null(new) } - } - unsafe fn __clone(this: *const c_void, new: *mut c_void) { - extern "C" { - attr! { - #[link_name = concat!("cxxbridge1$std$weak_ptr$", $segment, "$clone")] - fn __clone(this: *const c_void, new: *mut c_void); - } - } - unsafe { __clone(this, new) } - } - unsafe fn __downgrade(shared: *const c_void, weak: *mut c_void) { - extern "C" { - attr! { - #[link_name = concat!("cxxbridge1$std$weak_ptr$", $segment, "$downgrade")] - fn __downgrade(shared: *const c_void, weak: *mut c_void); - } - } - unsafe { __downgrade(shared, weak) } - } - unsafe fn __upgrade(weak: *const c_void, shared: *mut c_void) { - extern "C" { - attr! { - #[link_name = concat!("cxxbridge1$std$weak_ptr$", $segment, "$upgrade")] - fn __upgrade(weak: *const c_void, shared: *mut c_void); - } - } - unsafe { __upgrade(weak, shared) } - } - unsafe fn __drop(this: *mut c_void) { - extern "C" { - attr! { - #[link_name = concat!("cxxbridge1$std$weak_ptr$", $segment, "$drop")] - fn __drop(this: *mut c_void); - } - } - unsafe { __drop(this) } - } - } - }; -} - -macro_rules! impl_weak_ptr_target_for_primitive { - ($ty:ident) => { - impl_weak_ptr_target!(stringify!($ty), stringify!($ty), $ty); - }; -} - -impl_weak_ptr_target_for_primitive!(bool); -impl_weak_ptr_target_for_primitive!(u8); -impl_weak_ptr_target_for_primitive!(u16); -impl_weak_ptr_target_for_primitive!(u32); -impl_weak_ptr_target_for_primitive!(u64); -impl_weak_ptr_target_for_primitive!(usize); -impl_weak_ptr_target_for_primitive!(i8); -impl_weak_ptr_target_for_primitive!(i16); -impl_weak_ptr_target_for_primitive!(i32); -impl_weak_ptr_target_for_primitive!(i64); -impl_weak_ptr_target_for_primitive!(isize); -impl_weak_ptr_target_for_primitive!(f32); -impl_weak_ptr_target_for_primitive!(f64); - -impl_weak_ptr_target!("string", "CxxString", CxxString); |