Struct yewtil::ptr::Irc

pub struct Irc<T> { /* fields omitted */ }

Immutable Reference Counted pointer.

The Irc points to a value that cannot be mutated. If a Mrc and Irc point to the same value, mutating the value via the Mrc will clone and allocate, then mutate the value, leaving the value pointed to by the Irc alone.

Unless the Irc is unwrapped, that value is mutated, and another Irc is created using that value the Irc will guarantee that the value is not changed, and can be transparently passed to child components with knowledge that its value matches that of an original Mrc or Irc that it was cloned from.

This makes Ircs ideal for passing around immutable views to data through components in Yew, as cloning the Irc itself is cheap, and the Irc guarantees that its data cannot be changed by some intermediate component without obvious unwrap --> modify --> rewrap operations.

Implementations

impl<T> Irc<T>

pub fn new(value: T) -> Self

Allocates the value behind an Irc pointer.

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

Tries to extract the value from the Irc, returning the Irc if there is one or more other smart pointers to the value.

Example

use yewtil::ptr::Irc;
let irc = Irc::new(0);

let clone = irc.clone();
let irc = irc.try_unwrap().expect_err("Should not be able to unwrap");

std::mem::drop(clone);
let value = irc.try_unwrap().expect("Should get value");

pub fn get_count(&self) -> usize

Gets the reference count of the Irc.

An exclusive Irc will have a count of 1. The count is incremented on any cloning action and is decremented when drop is called.

Example

use yewtil::ptr::Irc;
let irc = Irc::new(0);
assert_eq!(irc.get_count(), 1);

let _clone = irc.clone();
assert_eq!(irc.get_count(), 2);

std::mem::drop(_clone);
assert_eq!(irc.get_count(), 1);

pub fn is_exclusive(&self) -> bool

use yewtil::ptr::Irc;
let irc = Irc::new(0);
assert!(irc.is_exclusive());

let _clone = irc.clone();
assert!(!irc.is_exclusive());

std::mem::drop(_clone);
assert!(irc.is_exclusive());

impl<T: Clone> Irc<T>

pub fn unwrap_clone(self) -> T

Unwraps the value from the Irc, cloning the value instead if another Irc or Mrc points to the same value.

pub fn clone_inner(&self) -> T

Clones the wrapped value of the Irc.

Trait Implementations

impl<T> AsRef<T> for Irc<T>

fn as_ref(&self) -> &T

Performs the conversion.

impl<T> Borrow<T> for Irc<T>

fn borrow(&self) -> &T

Immutably borrows from an owned value.

impl<T> Clone for Irc<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Irc<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Irc<T>

fn default() -> Self

Returns the "default value" for a type.

impl<T> Deref for Irc<T>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> Drop for Irc<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: Eq> Eq for Irc<T>

impl<T: Hash> Hash for Irc<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, 

Feeds a slice of this type into the given Hasher.

impl<T: Ord> Ord for Irc<T>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

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

Restrict a value to a certain interval.

impl<T: PartialEq> PartialEq<Irc<T>> for Irc<T>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T: PartialOrd> PartialOrd<Irc<T>> for Irc<T>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

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

#[must_use]fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]fn le(&self, other: &Rhs) -> bool

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

#[must_use]fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]fn ge(&self, other: &Rhs) -> bool

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