Struct Irc 

pub struct Irc<T: IrcItem<Tag>, Tag> { /* private fields */ }

Available on crate feature irc only.

Intrusive reference counter, which support conversion bwteween Box<T>.

It does not support weak reference.

Implementations

impl<T: IrcItem<Tag>, Tag> Irc<T, Tag>

pub fn new(inner: T) -> Self

Wrap a stack value T into Irc.

The counter will be reset to 1 on initialization.

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

pub fn is_unique(&self) -> bool

If is_unique returns true, then this thread is the only owner

False negative

it’s possible to return false when counter drop to 1, Because of using Acquire load and Release on drop.

Example

use embed_collections::irc::{Irc, IrcItem};
use core::sync::atomic::AtomicUsize;

struct Tag;

struct MyItem {
    value: i32,
    counter: AtomicUsize,
}

unsafe impl IrcItem<Tag> for MyItem {
    type Counter = AtomicUsize;
    fn counter(&self) -> &Self::Counter {
        &self.counter
    }
}

// Create a new Irc
let irc1 = Irc::<_, Tag>::new(MyItem { value: 10, counter: AtomicUsize::new(0) });
assert_eq!(irc1.value, 10);
assert!(irc1.is_unique());

// Clone the Irc
let irc2 = irc1.clone();
assert_eq!(irc1.strong_count(), 2);
assert!(!irc1.is_unique());

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

return mutable reference if we are the only owner

False negative

It can return None even when only one reference left

impl<T: IrcItem<Tag> + Clone, Tag> Irc<T, Tag>

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

The Cow function, the same as Arc::make_mut()

Example

use embed_collections::irc::{Irc, IrcItem};
use core::sync::atomic::AtomicUsize;

struct Tag;
struct MyItem {
    value: i32,
    counter: AtomicUsize,
}

impl Clone for MyItem {
    fn clone(&self) -> Self {
        Self { value: self.value, counter: AtomicUsize::new(0) }
    }
}

unsafe impl IrcItem<Tag> for MyItem {
    type Counter = AtomicUsize;
    fn counter(&self) -> &Self::Counter {
        &self.counter
    }
}

let mut irc1 = Irc::<_, Tag>::new(MyItem { value: 10, counter: AtomicUsize::new(0) });
let irc2 = irc1.clone();

// This will clone the inner item because it's shared
let m = Irc::make_mut(&mut irc1);
m.value = 20;

assert_eq!(irc1.value, 20);
assert_eq!(irc2.value, 10);

Trait Implementations

impl<T: IrcItem<Tag>, Tag> AsRef<T> for Irc<T, Tag>

fn as_ref(&self) -> &T

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

impl<T: IrcItem<Tag>, Tag> Clone for Irc<T, Tag>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: IrcItem<Tag> + Debug, Tag> Debug for Irc<T, Tag>

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

Formats the value using the given formatter.

impl<T: IrcItem<Tag>, Tag> Deref for Irc<T, Tag>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T: IrcItem<Tag> + Display, Tag> Display for Irc<T, Tag>

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

Formats the value using the given formatter.

impl<T: IrcItem<Tag>, Tag> Drop for Irc<T, Tag>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<T: IrcItem<Tag>, Tag> From<Box<T>> for Irc<T, Tag>

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

Convert a boxed T into Irc.

The counter will be reset to 1 on initialization.

impl<T: IrcItem<Tag>, Tag> Pointer for Irc<T, Tag>

unsafe fn from_raw(p: *const Self::Target) -> Self

Safety

must be pointer acquire from Irc::into_raw()

type Target = T

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

fn into_raw(self) -> *const Self::Target

fn as_ptr(&self) -> *const Self::Target

impl<T: IrcItem<Tag>, Tag> SmartPointer for Irc<T, Tag>

fn new(inner: T) -> Self

impl<T: IrcItem<Tag>, Tag> Send for Irc<T, Tag>

impl<T: IrcItem<Tag>, Tag> Sync for Irc<T, Tag>