Struct bacon_rajan_cc::Cc

pub struct Cc<T: 'static + Trace> { /* fields omitted */ }

A reference-counted pointer type over an immutable value.

See the module level documentation for more details.

Methods

impl<T: Trace> Cc<T>

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

Constructs a new Cc<T>.

Examples

use bacon_rajan_cc::Cc;

let five = Cc::new(5);

pub fn downgrade(&self) -> Weak<T>

Downgrades the Cc<T> to a Weak<T> reference.

Examples

use bacon_rajan_cc::Cc;

let five = Cc::new(5);

let weak_five = five.downgrade();

impl<T: 'static + Trace> Cc<T>

pub fn is_unique(&self) -> bool

Returns true if there are no other Cc or Weak<T> values that share the same inner value.

Examples

use bacon_rajan_cc;
use bacon_rajan_cc::Cc;

let five = Cc::new(5);
assert_eq!(five.is_unique(), true);

let another_five = five.clone();
assert_eq!(five.is_unique(), false);
assert_eq!(another_five.is_unique(), false);

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

Unwraps the contained value if the Cc<T> is unique.

If the Cc<T> is not unique, an Err is returned with the same Cc<T>.

Examples

use bacon_rajan_cc::Cc;

let x = Cc::new(3);
assert_eq!(x.try_unwrap(), Ok(3));

let x = Cc::new(4);
let _y = x.clone();
assert_eq!(x.try_unwrap(), Err(Cc::new(4)));

pub fn get_mut(&mut self) -> Option<&mut T>

Returns a mutable reference to the contained value if the Cc<T> is unique.

Returns None if the Cc<T> is not unique.

Examples

use bacon_rajan_cc::Cc;

let mut x = Cc::new(3);
*Cc::get_mut(&mut x).unwrap() = 4;
assert_eq!(*x, 4);

let _y = x.clone();
assert!(Cc::get_mut(&mut x).is_none());

pub fn strong_count(&self) -> usize

Get the number of strong references to this value.

pub fn weak_count(&self) -> usize

Get the number of weak references to this value.

impl<T: 'static + Clone + Trace> Cc<T>

pub fn make_unique(&mut self) -> &mut T

Make a mutable reference from the given Cc<T>.

This is also referred to as a copy-on-write operation because the inner data is cloned if the reference count is greater than one.

Examples

use bacon_rajan_cc::Cc;

let mut five = Cc::new(5);

let mut_five = five.make_unique();

Trait Implementations

impl<T: Trace> Trace for Cc<T>

fn trace(&self, tracer: &mut Tracer)

Invoke the Tracer on each of the CcBoxPtrs owned by this Trace instance.

impl<T: Trace> Clone for Cc<T>

fn clone(&self) -> Cc<T>

Makes a clone of the Cc<T>.

When you clone an Cc<T>, it will create another pointer to the data and increase the strong reference counter.

Examples

use bacon_rajan_cc::Cc;

let five = Cc::new(5);

five.clone();

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

Performs copy-assignment from source.

impl<T: Ord + Trace> Ord for Cc<T>

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

Comparison for two Cc<T>s.

The two are compared by calling cmp() on their inner values.

Examples

use bacon_rajan_cc::Cc;

let five = Cc::new(5);

five.partial_cmp(&Cc::new(5));

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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: Default + Trace> Default for Cc<T>

fn default() -> Cc<T>

Creates a new Cc<T>, with the Default value for T.

Examples

use bacon_rajan_cc::Cc;

let x: Cc<i32> = Default::default();

impl<T: PartialOrd + Trace> PartialOrd<Cc<T>> for Cc<T>

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

Partial comparison for two Cc<T>s.

The two are compared by calling partial_cmp() on their inner values.

Examples

use bacon_rajan_cc::Cc;

let five = Cc::new(5);

five.partial_cmp(&Cc::new(5));

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

Less-than comparison for two Cc<T>s.

The two are compared by calling < on their inner values.

Examples

use bacon_rajan_cc::Cc;

let five = Cc::new(5);

five < Cc::new(5);

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

'Less-than or equal to' comparison for two Cc<T>s.

The two are compared by calling <= on their inner values.

Examples

use bacon_rajan_cc::Cc;

let five = Cc::new(5);

five <= Cc::new(5);

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

Greater-than comparison for two Cc<T>s.

The two are compared by calling > on their inner values.

Examples

use bacon_rajan_cc::Cc;

let five = Cc::new(5);

five > Cc::new(5);

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

'Greater-than or equal to' comparison for two Cc<T>s.

The two are compared by calling >= on their inner values.

Examples

use bacon_rajan_cc::Cc;

let five = Cc::new(5);

five >= Cc::new(5);

impl<T: PartialEq + Trace> PartialEq<Cc<T>> for Cc<T>

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

Equality for two Cc<T>s.

Two Cc<T>s are equal if their inner value are equal.

Examples

use bacon_rajan_cc::Cc;

let five = Cc::new(5);

five == Cc::new(5);

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

Inequality for two Cc<T>s.

Two Cc<T>s are unequal if their inner value are unequal.

Examples

use bacon_rajan_cc::Cc;

let five = Cc::new(5);

five != Cc::new(5);

impl<T: Trace> Drop for Cc<T>

fn drop(&mut self)

Drops the Cc<T>.

This will decrement the strong reference count. If the strong reference count becomes zero and the only other references are Weak<T> ones, drops the inner value.

Examples

use bacon_rajan_cc::Cc;

{
    let five = Cc::new(5);

    // stuff

    drop(five); // explicit drop
}
{
    let five = Cc::new(5);

    // stuff

} // implicit drop

impl<T: Eq + Trace> Eq for Cc<T>

impl<T: Display + Trace> Display for Cc<T>

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

Formats the value using the given formatter.

impl<T: Debug + Trace> Debug for Cc<T>

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

Formats the value using the given formatter.

impl<T: Trace> Deref for Cc<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T: Hash + Trace> Hash for Cc<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: Trace> Pointer for Cc<T>

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

Formats the value using the given formatter.