Struct Arc

pub struct Arc<T: ?Sized, S: BackdropStrategy<Box<ArcInner<T>>>> { /* private fields */ }

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.

This Arc allows customizing how it is dropped. An backdrop_arc::Arc<T, S> behaves much like a Arc<backdrop::Backdrop<Box<T>, S>>, in that the backdrop strategy is executed when the last Arc clone goes out of scope. The difference with Arc<backdrop::Backdrop<Box<T>, S>> is that there is no double pointer-indirection (arc -> box -> T), managing the allocated T is done directly in the Arc.

Basic usage is as follows:

use backdrop_arc::Arc;
use backdrop_arc::{DebugStrategy, TrivialStrategy};

// Either specify the return type:
let mynum: Arc<usize, DebugStrategy<TrivialStrategy>> = Arc::new(42);

// Or use the 'Turbofish' syntax on the function call:
let mynum2 = Arc::<_, DebugStrategy<TrivialStrategy>>::new(42);

assert_eq!(mynum, mynum2);
// <- Because we are using the DebugStrategy, info is printed when the arcs go out of scope

See backdrop::Backdrop for more info.

Implementations

impl<T, S: BackdropStrategy<Box<ArcInner<T>>>> Arc<T, S>

pub fn new(data: T) -> Self

Construct an Arc<T, S>

pub fn with_strategy<S2: BackdropStrategy<Box<ArcInner<T>>>>( arc: Arc<T, S>, ) -> Arc<T, S2>

Alter the strategy that is used for an Arc<T, S> to another. This is a zero-cost operation.

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

Reconstruct the Arc<T, S> 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.

It is recommended to use OffsetArc for this

pub fn with_raw_offset_arc<F, U>(&self, f: F) -> U

where F: FnOnce(&OffsetArc<T, S>) -> U,

Temporarily converts |self| into a bonafide OffsetArc and exposes it to the provided callback. The refcount is not modified.

pub fn into_raw_offset(a: Self) -> OffsetArc<T, S>

Converts an Arc into a OffsetArc. This consumes the Arc, so the refcount is not modified.

pub fn from_raw_offset(a: OffsetArc<T, S>) -> Self

Converts a OffsetArc into an Arc. This consumes the OffsetArc, so the refcount is not modified.

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

Returns the inner value, if the Arc has exactly one strong reference.

Otherwise, an Err is returned with the same Arc that was passed in.

Examples

use backdrop_arc::{Arc, TrivialStrategy};

let x: Arc<usize, TrivialStrategy> = Arc::new(3);
assert_eq!(Arc::try_unwrap(x), Ok(3));

let x: Arc<usize, TrivialStrategy> = Arc::new(4);
let _y = Arc::clone(&x);
assert_eq!(*Arc::try_unwrap(x).unwrap_err(), 4);

impl<T, S: BackdropStrategy<Box<ArcInner<[T]>>>> Arc<[T], S>

pub unsafe fn from_raw_slice(ptr: *const [T]) -> Self

Reconstruct the Arc<[T]> from a raw pointer obtained from into_raw().

Arc::from_raw should accept unsized types, but this is not trivial to do correctly until the feature pointer_bytes_offsets is stabilized. This is stopgap solution for slices.

impl<T: ?Sized, S: BackdropStrategy<Box<ArcInner<T>>>> Arc<T, S>

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

Convert the Arc<T, S> to a raw pointer, suitable for use across FFI

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

It is recommended to use OffsetArc for this.

pub fn as_ptr(&self) -> *const T

Returns the raw pointer.

Same as into_raw except self isn’t consumed.

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

Produce a pointer to the data that can be converted back to an Arc. This is basically an &Arc<T, S>, 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>s if necessary.

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.

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

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

impl<T, S> Arc<MaybeUninit<T>, S>

where S: BackdropStrategy<Box<ArcInner<MaybeUninit<T>>>> + BackdropStrategy<Box<ArcInner<T>>>,

pub fn new_uninit() -> Self

Create an Arc contains an MaybeUninit<T>.

pub fn write(&mut self, val: T) -> &mut T

👎Deprecated since 0.1.7: this function previously was UB and now panics for non-unique Arcs. Use UniqueArc::write instead.

Calls MaybeUninit::write on the value contained.

Panics

If the Arc is not unique.

pub fn as_mut_ptr(&mut self) -> *mut MaybeUninit<T>

Obtain a mutable pointer to the stored MaybeUninit<T>.

pub unsafe fn assume_init(self) -> Arc<T, S>

Safety

Must initialize all fields before calling this function.

impl<T, S> Arc<[MaybeUninit<T>], S>

where S: BackdropStrategy<Box<ArcInner<HeaderSlice<(), [MaybeUninit<T>]>>>> + BackdropStrategy<Box<ArcInner<[MaybeUninit<T>]>>> + BackdropStrategy<Box<ArcInner<[T]>>>,

pub fn new_uninit_slice(len: usize) -> Self

Create an Arc contains an array [MaybeUninit<T>] of len.

pub fn as_mut_slice(&mut self) -> &mut [MaybeUninit<T>]

👎Deprecated since 0.1.8: this function previously was UB and now panics for non-unique Arcs. Use UniqueArc or get_mut instead.

Obtain a mutable slice to the stored [MaybeUninit<T>].

pub unsafe fn assume_init(self) -> Arc<[T], S>

Safety

Must initialize all fields before calling this function.

impl<T: ?Sized, S> Arc<T, S>

where S: BackdropStrategy<Box<ArcInner<T>>>,

pub fn clone_many<'a>(this: &'a Self, count: usize) -> ArcCloneIter<'a, T, S>

Optimization over calling clone() many times:

Instead of incrementing the reference count by one many times (which requires an atomic barrier each time) we increase the reference count by inc once, needing only a single atomic barrier.

Failure scenarios

• Aborts if increasing the reference count by inc results in a refcount higher than isize::MAX, to make sure the refcount never overflows. (The only way to trigger this in a program is by mem::forgetting Arcs in a loop).

Examples

The resulting iterator gives out exactly count Arcs:

use backdrop_arc::{Arc, TrivialStrategy};

let myarc: Arc<u32, TrivialStrategy> = Arc::new(42);
let many_clones: Vec<_> = Arc::clone_many(&myarc, 1000).collect();
assert_eq!(Arc::count(&myarc), 1001);

If the iterator is dropped before all of them are given out, the reference count is decreased by the leftover amount (also in one atomic barier):

use backdrop_arc::{Arc, TrivialStrategy};

let myarc: Arc<u32, TrivialStrategy> = Arc::new(42);
let many_clones: Vec<_> = Arc::clone_many(&myarc, 1000).take(100).collect();
assert_eq!(Arc::count(&myarc), 101);

impl<T: Clone, S> Arc<T, S>

where S: BackdropStrategy<Box<ArcInner<T>>>,

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.

pub fn make_unique(this: &mut Self) -> &mut UniqueArc<T, S>

Makes a UniqueArc from an Arc, cloning if necessary.

If this Arc is uniquely owned, make_unique() will provide a UniqueArc containing this. If not, make_unique() will create a new Arc with a copy of the contents, update this to point to it, and provide a UniqueArc to it.

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

pub fn unwrap_or_clone(this: Arc<T, S>) -> T

If we have the only reference to T then unwrap it. Otherwise, clone T and return the clone.

Assuming arc_t is of type Arc<T, S>, this function is functionally equivalent to (*arc_t).clone(), but will avoid cloning the inner value where possible.

impl<T: ?Sized, S> Arc<T, S>

where S: BackdropStrategy<Box<ArcInner<T>>>,

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

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

pub fn get_unique(this: &mut Self) -> Option<&mut UniqueArc<T, S>>

Provides unique access to the arc if the Arc is uniquely owned.

pub fn is_unique(&self) -> bool

Whether or not the Arc is uniquely owned (is the refcount 1?).

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

Gets the number of Arc pointers to this allocation

pub fn try_unique(this: Self) -> Result<UniqueArc<T, S>, Self>

Returns a UniqueArc if the Arc has exactly one strong reference.

Otherwise, an Err is returned with the same Arc that was passed in.

Examples

use backdrop_arc::{Arc, UniqueArc, TrivialStrategy};

let x: Arc<usize, TrivialStrategy> = Arc::new(3);
assert_eq!(UniqueArc::into_inner(Arc::try_unique(x).unwrap()), 3);

let x: Arc<usize, TrivialStrategy> = Arc::new(4);
let _y = Arc::clone(&x);
assert_eq!(
    *Arc::try_unique(x).map(UniqueArc::into_inner).unwrap_err(),
    4,
);

impl<H, T, S> Arc<HeaderSlice<H, [T]>, S>

where S: BackdropStrategy<Box<ArcInner<HeaderSlice<H, [T]>>>>,

pub fn from_header_and_iter<I>(header: H, items: I) -> Self

where I: Iterator<Item = T> + ExactSizeIterator,

Creates an Arc for a HeaderSlice using the given header struct and iterator to generate the slice. The resulting Arc will be fat.

pub fn from_header_and_slice(header: H, items: &[T]) -> Self

where T: Copy,

Creates an Arc for a HeaderSlice using the given header struct and iterator to generate the slice. The resulting Arc will be fat.

pub fn from_header_and_vec(header: H, v: Vec<T>) -> Self

Creates an Arc for a HeaderSlice using the given header struct and vec to generate the slice. The resulting Arc will be fat.

impl<H, S> Arc<HeaderSlice<H, str>, S>

where S: BackdropStrategy<Box<ArcInner<HeaderSlice<H, str>>>>,

pub fn from_header_and_str(header: H, string: &str) -> Self

Creates an Arc for a HeaderSlice using the given header struct and a str slice to generate the slice. The resulting Arc will be fat.

Trait Implementations

impl<T: ?Sized, S> AsRef<T> for Arc<T, S>

where S: BackdropStrategy<Box<ArcInner<T>>>,

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: ?Sized, S> Borrow<T> for Arc<T, S>

where S: BackdropStrategy<Box<ArcInner<T>>>,

fn borrow(&self) -> &T

Immutably borrows from an owned value.

impl<T: ?Sized, S> Clone for Arc<T, S>

where S: BackdropStrategy<Box<ArcInner<T>>>,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, U: ?Sized, S> CoerciblePtr<U> for Arc<T, S>

where S: BackdropStrategy<Box<ArcInner<T>>> + BackdropStrategy<Box<ArcInner<U>>>,

type Pointee = T

The type we point to. This influences which kinds of unsizing are possible.

type Output = Arc<U, S>

The output type when unsizing the pointee to U.

fn as_sized_ptr(&mut self) -> *mut T

Get the raw inner pointer.

unsafe fn replace_ptr(self, new: *mut U) -> Arc<U, S>

Replace the container inner pointer with an unsized version.

impl<T: ?Sized + Debug, S> Debug for Arc<T, S>

where S: BackdropStrategy<Box<ArcInner<T>>>,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Default, S> Default for Arc<T, S>

where S: BackdropStrategy<Box<ArcInner<T>>>,

fn default() -> Arc<T, S>

Returns the “default value” for a type.

impl<T: ?Sized, S> Deref for Arc<T, S>

where S: BackdropStrategy<Box<ArcInner<T>>>,

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<'de, T: Deserialize<'de>, S> Deserialize<'de> for Arc<T, S>

where S: BackdropStrategy<Box<ArcInner<T>>>,

fn deserialize<D>(deserializer: D) -> Result<Arc<T, S>, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: ?Sized + Display, S> Display for Arc<T, S>

where S: BackdropStrategy<Box<ArcInner<T>>>,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: ?Sized, S> Drop for Arc<T, S>

where S: BackdropStrategy<Box<ArcInner<T>>>,

fn drop(&mut self)

Executes the destructor for this type.

impl<T: Copy, S> From<&[T]> for Arc<[T], S>

where S: BackdropStrategy<Box<ArcInner<[T]>>> + BackdropStrategy<Box<ArcInner<HeaderSlice<(), [T]>>>>,

fn from(slice: &[T]) -> Self

Converts to this type from the input type.

impl<S> From<&str> for Arc<str, S>

where S: BackdropStrategy<Box<ArcInner<str>>> + BackdropStrategy<Box<ArcInner<HeaderSlice<(), str>>>>,

fn from(s: &str) -> Self

Converts to this type from the input type.

impl<T: ?Sized, S> From<Arc<HeaderSlice<(), T>, S>> for Arc<T, S>

where S: BackdropStrategy<Box<ArcInner<HeaderSlice<(), T>>>> + BackdropStrategy<Box<ArcInner<T>>>,

fn from(this: Arc<HeaderSlice<(), T>, S>) -> Self

Converts to this type from the input type.

impl<T, S: BackdropStrategy<Box<ArcInner<T>>>> From<Arc<T>> for Arc<T, S>

Converting to- and from a triomphe::Arc<T> is a zero-cost operation

fn from(arc: Arc<T>) -> Self

Converts to this type from the input type.

impl<T: ?Sized, S> From<Arc<T, S>> for Arc<HeaderSlice<(), T>, S>

where S: BackdropStrategy<Box<ArcInner<HeaderSlice<(), T>>>> + BackdropStrategy<Box<ArcInner<T>>>,

fn from(this: Arc<T, S>) -> Self

Converts to this type from the input type.

impl<T, S: BackdropStrategy<Box<ArcInner<T>>>> From<Arc<T, S>> for Arc<T>

Converting to- and from a triomphe::Arc<T> is a zero-cost operation

fn from(arc: Arc<T, S>) -> Self

Converts to this type from the input type.

impl<T, S> From<Box<T>> for Arc<T, S>

where S: BackdropStrategy<Box<ArcInner<T>>>,

fn from(b: Box<T>) -> Self

Converts to this type from the input type.

impl<S> From<String> for Arc<str, S>

where S: BackdropStrategy<Box<ArcInner<str>>> + BackdropStrategy<Box<ArcInner<HeaderSlice<(), str>>>>,

fn from(s: String) -> Self

Converts to this type from the input type.

impl<T, S: BackdropStrategy<Box<ArcInner<T>>>> From<T> for Arc<T, S>

fn from(t: T) -> Self

Converts to this type from the input type.

impl<T, S> From<Vec<T>> for Arc<[T], S>

where S: BackdropStrategy<Box<ArcInner<[T]>>> + BackdropStrategy<Box<ArcInner<HeaderSlice<(), [T]>>>>,

fn from(v: Vec<T>) -> Self

Converts to this type from the input type.

impl<A, S> FromIterator<A> for Arc<[A], S>

where S: BackdropStrategy<Box<ArcInner<[A]>>> + BackdropStrategy<Box<ArcInner<HeaderSlice<(), [A]>>>> + BackdropStrategy<Box<[A]>>,

fn from_iter<T: IntoIterator<Item = A>>(iter: T) -> Self

Creates a value from an iterator.

impl<T: ?Sized + Hash, S> Hash for Arc<T, S>

where S: BackdropStrategy<Box<ArcInner<T>>>,

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: ?Sized + Ord, S> Ord for Arc<T, S>

where S: BackdropStrategy<Box<ArcInner<T>>>,

fn cmp(&self, other: &Arc<T, S>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: ?Sized + PartialEq, S> PartialEq for Arc<T, S>

where S: BackdropStrategy<Box<ArcInner<T>>>,

fn eq(&self, other: &Arc<T, S>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Arc<T, S>) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: ?Sized + PartialOrd, S> PartialOrd for Arc<T, S>

where S: BackdropStrategy<Box<ArcInner<T>>>,

fn partial_cmp(&self, other: &Arc<T, S>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Arc<T, S>) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Arc<T, S>) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Arc<T, S>) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Arc<T, S>) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: ?Sized, S> Pointer for Arc<T, S>

where S: BackdropStrategy<Box<ArcInner<T>>>,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, S> RefCnt for Arc<T, S>

where S: BackdropStrategy<Box<ArcInner<T>>>,

type Base = T

The base type the pointer points to.

fn into_ptr(me: Self) -> *mut Self::Base

Converts the smart pointer into a raw pointer, without affecting the reference count.

fn as_ptr(me: &Self) -> *mut Self::Base

Provides a view into the smart pointer as a raw pointer.

unsafe fn from_ptr(ptr: *const Self::Base) -> Self

Converts a raw pointer back into the smart pointer, without affecting the reference count.

fn inc(me: &Self) -> *mut Self::Base

Increments the reference count by one.

unsafe fn dec(ptr: *const Self::Base)

Decrements the reference count by one.

impl<T: Serialize, S> Serialize for Arc<T, S>

where S: BackdropStrategy<Box<ArcInner<T>>>,

fn serialize<Ser>(&self, serializer: Ser) -> Result<Ser::Ok, Ser::Error>

where Ser: Serializer,

Serialize this value into the given Serde serializer.

impl<T: ?Sized, S: BackdropStrategy<Box<ArcInner<T>>>> TryFrom<Arc<T, S>> for UniqueArc<T, S>

type Error = Arc<T, S>

The type returned in the event of a conversion error.

fn try_from(arc: Arc<T, S>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T: ?Sized, S> CloneStableDeref for Arc<T, S>

where S: BackdropStrategy<Box<ArcInner<T>>>,

impl<T, S> CloneableCart for Arc<T, S>

where S: BackdropStrategy<Box<ArcInner<T>>>,

impl<T: ?Sized + Eq, S> Eq for Arc<T, S>

where S: BackdropStrategy<Box<ArcInner<T>>>,

impl<T: ?Sized + Sync + Send, S> Send for Arc<T, S>

where S: BackdropStrategy<Box<ArcInner<T>>>,

impl<T: ?Sized, S> StableDeref for Arc<T, S>

where S: BackdropStrategy<Box<ArcInner<T>>>,

impl<T: ?Sized + Sync + Send, S> Sync for Arc<T, S>

where S: BackdropStrategy<Box<ArcInner<T>>>,