Struct Arc

#[repr(C)]
pub struct Arc<T, Alloc: IAlloc = DefaultAllocator> { /* private fields */ }

alloc::sync::Arc, but ABI-stable.

Implementations

impl<T, Alloc: IAlloc> Arc<T, Alloc>

where Struct<AllocPtr<T, Alloc>>: IStable, AllocPtr<T, Alloc>: IStable,

pub const fn has_optimal_layout() -> bool

Returns true if the layout for Arc is smaller or equal to that Rust would have generated for it.

impl<T> Arc<T>

pub unsafe fn make<F: for<'a> FnOnce(&'a mut MaybeUninit<T>) -> Result<&'a mut T, ()>>( constructor: F, ) -> Result<Self, Arc<MaybeUninit<T>>>

Attempts to allocate Self, initializing it with constructor.

Note that the allocation may or may not be zeroed.

If the allocation fails, the constructor will not be run.

Safety

constructor MUST return Err(()) if it failed to initialize the passed argument.

Errors

Returns the uninitialized allocation if the constructor declares a failure.

Panics

If the allocator fails to provide an appropriate allocation.

pub fn new(value: T) -> Self

Attempts to allocate Self and store value in it.

Panics

If the allocator fails to provide an appropriate allocation.

impl<T, Alloc: IAlloc> Arc<T, Alloc>

pub unsafe fn try_make_in<F: for<'a> FnOnce(&'a mut MaybeUninit<T>) -> Result<&'a mut T, ()>>( constructor: F, alloc: Alloc, ) -> Result<Self, Result<Arc<MaybeUninit<T>, Alloc>, (F, Alloc)>>

Attempts to allocate Self, initializing it with constructor.

Note that the allocation may or may not be zeroed.

If the constructor panics, the allocated memory will be leaked.

Errors

• Returns the constructor and the allocator in case of allocation failure.
• Returns the uninitialized allocated memory if constructor fails.

Safety

constructor MUST return Err(()) if it failed to initialize the passed argument.

Notes

Note that the allocation may or may not be zeroed.

pub fn try_new_in(value: T, alloc: Alloc) -> Result<Self, (T, Alloc)>

Attempts to allocate a Self and store value in it

Errors

Returns value and the allocator in case of failure.

pub unsafe fn make_in<F: for<'a> FnOnce(&'a mut MaybeUninit<T>) -> Result<&'a mut T, ()>>( constructor: F, alloc: Alloc, ) -> Result<Self, Arc<MaybeUninit<T>, Alloc>>

Attempts to allocate Self, initializing it with constructor.

Note that the allocation may or may not be zeroed.

Errors

Returns the uninitialized allocated memory if constructor fails.

Safety

constructor MUST return Err(()) if it failed to initialize the passed argument.

Panics

If the allocator fails to provide an appropriate allocation.

pub fn new_in(value: T, alloc: Alloc) -> Self

Attempts to allocate Self and store value in it.

Panics

If the allocator fails to provide an appropriate allocation.

pub const fn into_raw(this: Self) -> AllocPtr<T, Alloc>

Returns the pointer to the inner raw allocation, leaking this.

Note that the pointer may be dangling if T is zero-sized.

pub const unsafe fn from_raw(this: AllocPtr<T, Alloc>) -> Self

Constructs Self from a raw allocation.

Safety

this MUST not be dangling, and have been obtained through Self::into_raw.

pub fn get_mut(this: &mut Self) -> Option<&mut T>

Provides a mutable reference to the internals if the strong and weak counts are both 1.

pub const unsafe fn get_mut_unchecked(this: &mut Self) -> &mut T

Provides a mutable reference to the internals without checking.

Safety

If used carelessly, this can cause mutable references and immutable references to the same value to appear, causing undefined behaviour.

pub fn strong_count(this: &Self) -> usize

Returns the strong count.

pub unsafe fn increment_strong_count(this: *const T) -> usize

Increments the strong count.

Safety

this MUST be a valid pointer derived from Self

pub fn weak_count(this: &Self) -> usize

Returns the weak count. Note that all Arcs to a same value share a Weak, so the weak count can never be 0.

pub fn increment_weak_count(this: &Self) -> usize

Increments the weak count, returning its previous value.

pub fn make_mut(&mut self) -> &mut T

where T: Clone, Alloc: Clone,

Returns a mutable reference to this Arc’s value, cloning that value into a new Arc if Self::get_mut would have failed.

pub fn make_mut_and_get_alloc(&mut self) -> (&mut T, &Alloc)

where T: Clone, Alloc: Clone,

Returns a mutable reference to this Arc’s value, cloning that value into a new Arc if Self::get_mut would have failed.

pub fn is_unique(this: &Self) -> bool

Whether or not this is the sole owner of its data, including weak owners.

pub fn try_into_inner(this: Self) -> Result<T, Self>

Attempts the value from the allocation, freeing said allocation.

Errors

Returns this if it’s not the sole owner of its value.

pub fn downgrade(this: &Self) -> Weak<T, Alloc>

Constructs an additional Weak pointer to this.

pub const fn allocator(this: &Self) -> &Alloc

Returns a reference to the allocator used to construct this

Trait Implementations

impl<T, Alloc: IAlloc> Clone for Arc<T, Alloc>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T, Alloc: IAlloc> Deref for Arc<T, Alloc>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, Alloc: IAlloc> Drop for Arc<T, Alloc>

fn drop(&mut self)

Executes the destructor for this type.

impl<T, Alloc: IAlloc> From<&Arc<T, Alloc>> for Arc<T, Alloc>

fn from(value: &Arc<T, Alloc>) -> Self

Converts to this type from the input type.

impl<T, Alloc: IAlloc> From<&Arc<T, Alloc>> for Weak<T, Alloc>

fn from(value: &Arc<T, Alloc>) -> Self

Converts to this type from the input type.

impl<T, Alloc: IAlloc> From<Arc<T, Alloc>> for ArcSlice<T, Alloc>

fn from(value: Arc<T, Alloc>) -> Self

Converts to this type from the input type.

impl<T, Alloc: IAlloc> IPtr for Arc<T, Alloc>

unsafe fn as_ref(&self) -> AnonymRef<'_>

Safety

impl<T, Alloc: IAlloc> IPtrClone for Arc<T, Alloc>

fn clone(this: &Self) -> Self

Clone the pointer.

impl<T, Alloc: IAlloc> IPtrOwned for Arc<T, Alloc>

fn drop( this: &mut ManuallyDrop<Self>, drop: unsafe extern "C" fn(AnonymRefMut<'_>), )

Called instead of Drop::drop when the dynptr is dropped.

impl<T, Alloc: IAlloc> IPtrTryAsMut for Arc<T, Alloc>

unsafe fn try_as_mut(&mut self) -> Option<AnonymRefMut<'_>>

Safety

impl<T, Alloc: IAlloc> IStable for Arc<T, Alloc>

where Struct<AllocPtr<T, Alloc>>: IStable, AllocPtr<T, Alloc>: IStable,

const REPORT: &'static TypeReport

A compile-time generated report of the fields of the type, allowing for compatibility inspection.

const ID: u64

A stable (and ideally unique) identifier for the type. Often generated using crate::report::gen_id, but can be manually set.

type ForbiddenValues = <Struct<AllocPtr<T, Alloc>> as IStable>::ForbiddenValues

The values that the annotated type cannot occupy.

type UnusedBits = <Struct<AllocPtr<T, Alloc>> as IStable>::UnusedBits

The padding bits in the annotated types

type Size = <Struct<AllocPtr<T, Alloc>> as IStable>::Size

The size of the annotated type in bytes.

type Align = <Struct<AllocPtr<T, Alloc>> as IStable>::Align

The alignment of the annotated type in bytes.

type HasExactlyOneNiche = <Struct<AllocPtr<T, Alloc>> as IStable>::HasExactlyOneNiche

Allows the detection of whether or not core::option::Options are stable:

type ContainsIndirections = <Struct<AllocPtr<T, Alloc>> as IStable>::ContainsIndirections

Whether or not the type contains indirections (pointers, indices in independent data-structures…)

fn size() -> usize

Returns the size of the type.

fn align() -> usize

Returns the alignment of the type.

unsafe fn is_invalid(ptr: *const u8) -> bool

Returns true if ptr points to memory that cannot be a valid value of Self.

impl<T, Alloc: IAlloc> IntoDyn for Arc<T, Alloc>

type Anonymized = Arc<(), Alloc>

A pointer type with type information discarded.

type Target = T

The original pointee.

fn anonimize(self) -> Self::Anonymized

Drop the type information from the pointer.

impl<T: Send + Sync, Alloc: IAlloc + Send + Sync> Send for Arc<T, Alloc>

impl<T: Send + Sync, Alloc: IAlloc + Send + Sync> Sync for Arc<T, Alloc>