Struct Rc

pub struct Rc<'a, T, const MEMORY_SIZE: usize, const INDEX_SIZE: usize>
where
    T: ?Sized,
{ /* private fields */ }

A smart pointer holding its value in an IndexAllocator and allowing shared ownership between multiple Rc.

The Rc smart pointer can be obtained by using Rc::try_new.

Example

use index_alloc::IndexAllocator;
use index_alloc::rc::Rc;

let allocator: IndexAllocator<64, 8> = IndexAllocator::empty();

let test_rc = Rc::try_new([1, 2, 3, 4], &allocator).unwrap();
assert_eq!(*test_rc, [1, 2, 3, 4]);

Implementations

impl<'a, T, const MEMORY_SIZE: usize, const INDEX_SIZE: usize> Rc<'a, T, MEMORY_SIZE, INDEX_SIZE>

where T: ?Sized,

pub fn try_new<U>( val: U, allocator: &'a IndexAllocator<MEMORY_SIZE, INDEX_SIZE>, ) -> Result<Self, IndexError>

where U: 'a, &'a T: From<&'a U>,

Try to create a new Rc owning a value allocated of type T on a IndexAllocator. The inner memory is reference counted and only freed when every strong reference (Rc) are dropped.

Errors

The method return an IndexError if the allocation failed.

Examples found in repository

examples/rc_graph.rs (line 62)

fn main() {
    let allocator: IndexAllocator<1024, 64> = IndexAllocator::empty();

    let mut main_node = Node::new("Main");
    let first_child_node = Rc::try_new(Node::new("First child node"), &allocator).unwrap();

    let second_child_node = {
        let mut node = Node::new("Second child node");
        node.add_link(Link::Weak(first_child_node.downgrade()));
        Rc::try_new(node, &allocator).unwrap()
    };

    main_node.add_link(Link::new_held(first_child_node.clone()));
    main_node.add_link(Link::new_held(second_child_node.clone()));

    for l in main_node.iter_links() {
        println!("Main node is linked to : {}", l.to().unwrap().val);
    }

    for l in second_child_node.iter_links() {
        println!("Second child node is linked to : {}", l.to().unwrap().val);
    }
}

pub fn downgrade(&self) -> Weak<'a, T, MEMORY_SIZE, INDEX_SIZE>

Create a Weak reference to the value owned by the Rc.

Examples found in repository

examples/rc_graph.rs (line 66)

fn main() {
    let allocator: IndexAllocator<1024, 64> = IndexAllocator::empty();

    let mut main_node = Node::new("Main");
    let first_child_node = Rc::try_new(Node::new("First child node"), &allocator).unwrap();

    let second_child_node = {
        let mut node = Node::new("Second child node");
        node.add_link(Link::Weak(first_child_node.downgrade()));
        Rc::try_new(node, &allocator).unwrap()
    };

    main_node.add_link(Link::new_held(first_child_node.clone()));
    main_node.add_link(Link::new_held(second_child_node.clone()));

    for l in main_node.iter_links() {
        println!("Main node is linked to : {}", l.to().unwrap().val);
    }

    for l in second_child_node.iter_links() {
        println!("Second child node is linked to : {}", l.to().unwrap().val);
    }
}

pub fn strong_count(&self) -> usize

Return the number of strong reference (see Rc) to the inner value.

pub fn weak_count(&self) -> usize

Return the number of weak reference (see Weak) to the inner value.

pub fn allocator(&self) -> &'a IndexAllocator<MEMORY_SIZE, INDEX_SIZE>

Get a reference to the IndexAllocator used by the Rc.

Trait Implementations

impl<'a, T, const MEMORY_SIZE: usize, const INDEX_SIZE: usize> Clone for Rc<'a, T, MEMORY_SIZE, INDEX_SIZE>

where T: ?Sized,

fn clone(&self) -> Self

Create a new Rc referencing to the same value.

Example

use index_alloc::IndexAllocator;
use index_alloc::rc::Rc;

let allocator: IndexAllocator<64, 8> = IndexAllocator::empty();

let test_rc = Rc::try_new("Hello World", &allocator).unwrap();

{
    let test_ref = Rc::clone(&test_rc);
    assert_eq!(*test_ref, "Hello World");
}

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

Performs copy-assignment from source.

impl<'a, T, const MEMORY_SIZE: usize, const INDEX_SIZE: usize> Debug for Rc<'a, T, MEMORY_SIZE, INDEX_SIZE>

where T: ?Sized + Debug,

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

Formats the value using the given formatter.

impl<'a, T, const MEMORY_SIZE: usize, const INDEX_SIZE: usize> Deref for Rc<'a, T, MEMORY_SIZE, INDEX_SIZE>

where T: ?Sized,

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<'a, T, const MEMORY_SIZE: usize, const INDEX_SIZE: usize> Drop for Rc<'a, T, MEMORY_SIZE, INDEX_SIZE>

where T: ?Sized,

fn drop(&mut self)

Executes the destructor for this type.