Struct stabby::sync::Arc

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

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

Implementations

impl<T, Alloc> Arc<T, Alloc>

where Alloc: IAlloc,

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 fn make<F>(constructor: F) -> Arc<T>

where F: FnOnce(&mut MaybeUninit<T>),

Attempts to allocate Self, initializing it with constructor.

Note that the allocation may or may not be zeroed.

Panics

If the allocator fails to provide an appropriate allocation.

pub fn new(value: T) -> Arc<T>

Attempts to allocate Self and store value in it.

Panics

If the allocator fails to provide an appropriate allocation.

impl<T, Alloc> Arc<T, Alloc>

where Alloc: IAlloc,

pub fn try_make_in<F>( constructor: F, alloc: Alloc, ) -> Result<Arc<T, Alloc>, (F, Alloc)>

where F: FnOnce(&mut MaybeUninit<T>),

Attempts to allocate Self, initializing it with constructor.

Errors

Returns the constructor and the allocator in case of allocation failure.

Notes

Note that the allocation may or may not be zeroed.

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

Attempts to allocate a Self and store value in it

Errors

Returns value and the allocator in case of failure.

pub fn make_in<F>(constructor: F, alloc: Alloc) -> Arc<T, Alloc>

where F: FnOnce(&mut MaybeUninit<T>),

Attempts to allocate Self, initializing it with constructor.

Note that the allocation may or may not be zeroed.

Panics

If the allocator fails to provide an appropriate allocation.

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

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: Arc<T, Alloc>) -> 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>) -> Arc<T, Alloc>

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 Arc<T, Alloc>) -> Option<&mut T>

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

pub unsafe fn get_mut_unchecked(this: &mut Arc<T, Alloc>) -> &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: &Arc<T, Alloc>) -> 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: &Arc<T, Alloc>) -> 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: &Arc<T, Alloc>) -> 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 is_unique(this: &Arc<T, Alloc>) -> bool

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

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

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: &Arc<T, Alloc>) -> Weak<T, Alloc>

Constructs an additional Weak pointer to this.

pub const fn allocator(this: &Arc<T, Alloc>) -> &Alloc

Returns a reference to the allocator used to construct this

Trait Implementations

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

where Alloc: IAlloc,

fn clone(&self) -> Arc<T, Alloc>

Returns a copy of the value.

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

Performs copy-assignment from source.

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

where Alloc: IAlloc,

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &<Arc<T, Alloc> as Deref>::Target

Dereferences the value.

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

where Alloc: IAlloc,

fn drop(&mut self)

Executes the destructor for this type.

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

where Alloc: IAlloc,

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

Converts to this type from the input type.

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

where Alloc: IAlloc,

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

Converts to this type from the input type.

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

where Alloc: IAlloc,

unsafe fn as_ref<U>(&self) -> &U

Safety

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

where Alloc: IAlloc,

fn clone(this: &Arc<T, Alloc>) -> Arc<T, Alloc>

Clone the pointer.

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

where Alloc: IAlloc,

fn drop( this: &mut ManuallyDrop<Arc<T, Alloc>>, drop: unsafe extern "C" fn(_: &mut ()), )

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

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

where Alloc: IAlloc,

unsafe fn try_as_mut<U>(&mut self) -> Option<&mut U>

Safety

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

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

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…)

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.

fn size() -> usize

Returns the size of the type.

fn align() -> usize

Returns the alignment of the type.

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

where Alloc: IAlloc,

type Anonymized = Arc<(), Alloc>

A pointer type with type information discarded.

type Target = T

The original pointee.

fn anonimize(self) -> <Arc<T, Alloc> as IntoDyn>::Anonymized

Drop the type information from the pointer.

impl<T, Alloc> Send for Arc<T, Alloc>

where T: Send + Sync, Alloc: IAlloc + Send + Sync,

impl<T, Alloc> Sync for Arc<T, Alloc>

where T: Send + Sync, Alloc: IAlloc + Send + Sync,