Struct Arc

Source

#[repr(C)]
pub struct Arc<T: ?Sized> {
    pub(crate) p: NonNull<ArcInner<T>>,
    pub(crate) phantom: PhantomData<T>,
}

Expand description

An atomically reference counted shared pointer

See the documentation for Arc in the standard library. Unlike the standard library Arc, this Arc does not support weak reference counting.

See the discussion in https://github.com/rust-lang/rust/pull/60594 for the usage of PhantomData.

cbindgen:derive-eq=false cbindgen:derive-neq=false

Fields§

§p: NonNull<ArcInner<T>>§phantom: PhantomData<T>

Implementations§

Source §

impl<T> Arc<T>

Source

pub fn new(data: T) -> Self

Construct an Arc<T>

Source

pub fn new_leaked(data: T) -> Self

Construct an intentionally-leaked arc.

Source

pub fn into_raw(this: Self) -> *const T

Convert the Arc to a raw pointer, suitable for use across FFI

Note: This returns a pointer to the data T, which is offset in the allocation.

Source

pub unsafe fn from_raw(ptr: *const T) -> Self

Reconstruct the Arc from a raw pointer obtained from into_raw()

Note: This raw pointer will be offset in the allocation and must be preceded by the atomic count.

Source

pub unsafe fn from_raw_addrefed(ptr: *const T) -> Self

Like from_raw, but returns an addrefed arc instead.

Source

pub unsafe fn new_static<F>(alloc: F, data: T) -> Arc<T>
where F: FnOnce(Layout) -> *mut u8,

Create a new static Arc (one that won’t reference count the object) and place it in the allocation provided by the specified alloc function.

alloc must return a pointer into a static allocation suitable for storing data with the Layout passed into it. The pointer returned by alloc will not be freed.

Source

pub fn borrow_arc<'a>(&'a self) -> ArcBorrow<'a, T>

Produce a pointer to the data that can be converted back to an Arc. This is basically an &Arc<T>, without the extra indirection. It has the benefits of an &T but also knows about the underlying refcount and can be converted into more Arc<T>s if necessary.

Source

pub fn heap_ptr(&self) -> *const c_void

Returns the address on the heap of the Arc itself – not the T within it – for memory reporting.

If this is a static reference, this returns null.

Source §

pub fn mark_as_intentionally_leaked(&self)

Marks this Arc as intentionally leaked for the purposes of refcount logging.

It’s a logic error to call this more than once, but it’s not unsafe, as it’d just report negative leaks.

Source

pub(crate) unsafe fn drop_slow(&mut self)

Source

pub fn ptr_eq(this: &Self, other: &Self) -> bool

Test pointer equality between the two Arcs, i.e. they must be the same allocation

Source

pub(crate) fn ptr(&self) -> *mut ArcInner<T>

Source

pub fn raw_ptr(&self) -> NonNull<()>

Returns a raw ptr to the underlying allocation.

Source §

impl<T: Clone> Arc<T>

Source

pub fn make_mut(this: &mut Self) -> &mut T

Makes a mutable reference to the Arc, cloning if necessary

This is functionally equivalent to Arc::make_mut from the standard library.

If this Arc is uniquely owned, make_mut() will provide a mutable reference to the contents. If not, make_mut() will create a new Arc with a copy of the contents, update this to point to it, and provide a mutable reference to its contents.

This is useful for implementing copy-on-write schemes where you wish to avoid copying things if your Arc is not shared.

Source §

impl<T: ?Sized> Arc<T>

Source

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

Provides mutable access to the contents if the Arc is uniquely owned.

Source

pub fn is_static(&self) -> bool

Whether or not the Arc is a static reference.

Source

pub fn is_unique(&self) -> bool

Whether or not the Arc is uniquely owned (is the refcount 1?) and not a static reference.

Source §

impl<H, T> Arc<HeaderSlice<H, T>>

Source

pub fn from_header_and_iter_alloc<F, I>( alloc: F, header: H, items: I, num_items: usize, is_static: bool, ) -> Self
where F: FnOnce(Layout) -> *mut u8, I: Iterator<Item = T>,

Creates an Arc for a HeaderSlice using the given header struct and iterator to generate the slice.

is_static indicates whether to create a static Arc.

alloc is used to get a pointer to the memory into which the dynamically sized ArcInner<HeaderSlice<H, T>> value will be written. If is_static is true, then alloc must return a pointer into some static memory allocation. If it is false, then alloc must return an allocation that can be dellocated by calling Box::from_raw::<ArcInner<HeaderSlice<H, T>>> on it.

Source

pub fn from_header_and_iter_with_size( header: H, items: I, num_items: usize, ) -> Self
where I: Iterator<Item = T>,

Creates an Arc for a HeaderSlice using the given header struct and iterator to generate the slice. Panics if num_items doesn’t match the number of items.

Source