c1a4e29a1e
# Objective Since rust `1.76`, [`ptr::from_ref`](https://doc.rust-lang.org/stable/std/ptr/fn.from_ref.html) and [`ptr::from_mut`](https://doc.rust-lang.org/stable/std/ptr/fn.from_mut.html) are stable. This PR replaces code that use `as` casting by one of `ptr::from_ref`, `ptr::from_mut`, `cast_mut`, `cast_const`, or `cast` methods, which are less error-prone. ## Solution - Bump MSRV to `1.76.0` - Enables the following clippy lints: - [`ptr_as_ptr`](https://rust-lang.github.io/rust-clippy/master/index.html#/ptr_as_ptr) - [`ptr_cast_constness`](https://rust-lang.github.io/rust-clippy/master/index.html#/ptr_cast_constness) - [`ref_as_ptr`](https://rust-lang.github.io/rust-clippy/master/index.html#/ref_as_ptr) (I fix all warnings for this one, but it requires rust 1.77 to be enabled) - Fix the lints mentioned above
54 lines
1.8 KiB
Rust
54 lines
1.8 KiB
Rust
//! A reimplementation of the currently unstable [`std::sync::Exclusive`]
|
|
//!
|
|
//! [`std::sync::Exclusive`]: https://doc.rust-lang.org/nightly/std/sync/struct.Exclusive.html
|
|
|
|
use std::ptr;
|
|
|
|
/// See [`Exclusive`](https://github.com/rust-lang/rust/issues/98407) for stdlib's upcoming implementation,
|
|
/// which should replace this one entirely.
|
|
///
|
|
/// Provides a wrapper that allows making any type unconditionally [`Sync`] by only providing mutable access.
|
|
#[repr(transparent)]
|
|
pub struct SyncCell<T: ?Sized> {
|
|
inner: T,
|
|
}
|
|
|
|
impl<T: Sized> SyncCell<T> {
|
|
/// Construct a new instance of a `SyncCell` from the given value.
|
|
pub fn new(inner: T) -> Self {
|
|
Self { inner }
|
|
}
|
|
|
|
/// Deconstruct this `SyncCell` into its inner value.
|
|
pub fn to_inner(Self { inner }: Self) -> T {
|
|
inner
|
|
}
|
|
}
|
|
|
|
impl<T: ?Sized> SyncCell<T> {
|
|
/// Get a reference to this `SyncCell`'s inner value.
|
|
pub fn get(&mut self) -> &mut T {
|
|
&mut self.inner
|
|
}
|
|
|
|
/// For types that implement [`Sync`], get shared access to this `SyncCell`'s inner value.
|
|
pub fn read(&self) -> &T
|
|
where
|
|
T: Sync,
|
|
{
|
|
&self.inner
|
|
}
|
|
|
|
/// Build a mutable reference to a `SyncCell` from a mutable reference
|
|
/// to its inner value, to skip constructing with [`new()`](SyncCell::new()).
|
|
pub fn from_mut(r: &'_ mut T) -> &'_ mut SyncCell<T> {
|
|
// SAFETY: repr is transparent, so refs have the same layout; and `SyncCell` properties are `&mut`-agnostic
|
|
unsafe { &mut *(ptr::from_mut(r) as *mut SyncCell<T>) }
|
|
}
|
|
}
|
|
|
|
// SAFETY: `Sync` only allows multithreaded access via immutable reference.
|
|
// As `SyncCell` requires an exclusive reference to access the wrapped value for `!Sync` types,
|
|
// marking this type as `Sync` does not actually allow unsynchronized access to the inner value.
|
|
unsafe impl<T: ?Sized> Sync for SyncCell<T> {}
|