SPEEDY_REFS

A collection of simple, Fast, and useful smart pointers for rust.

FEATURES

• Rc -> Blazingly fast alternative to the std Rc smart pointer.
• RefCell -> Blazingly fast alternative to the std RefCell.
• Arc - Lighter alternative the std Arc with equivalent performance
• HeapCell - Similar to NonNull with simpler type deallocation and dropping
• Reon - Read only static pointer that implements Sync and Send
• RcCell - Simple and more concise version of Rc<RefCell>
• SharedCell - For Shared ownership without borrow checking.
• Borrow - A cloneable shared ownership without borrow checking. Like how references are used in languages like java, go, python, etc.

Upcoming

• Atomic - Uses atomic operations to control mutable and immutable access to any type for multithread syncing.
• Hazard - A hazard pointer implementation.

DEPENDENCIES

INSTALLATION

[dependencies]
speedy_refs = "0.2.7"

Example

Reon

use std::thread;
use std::sync::{Arc, Barrier};
use speedy_refs::Reon;

fn main() {
    let x = Reon::new(42);
    let num_threads = 4;
    let barrier = Arc::new(Barrier::new(num_threads));

    let mut threads = Vec::with_capacity(num_threads);

    for _ in 0..num_threads {
        let x = x.clone();
        let barrier = Arc::clone(&barrier);
        let thread = thread::spawn(move || {
            barrier.wait();
            println!("Thread {:?} sees value: {}", thread::current().id(), *x);
        });
        threads.push(thread);
    }

    for thread in threads {
        thread.join().unwrap();
    }
}

Borrow

use speedy_refs::Borrow;

#[derive(Debug, PartialEq, Eq)]
struct Data(String, usize, bool, Vec<Self>);

fn main() {
    // Create a new variable
    let data = Data(String::from("Hello, World"), 100, false, vec![]);
    // Create a Borrow (a reference) with the variable
    let mut data_ref = Borrow::new(data);
    // Create another reference to the same variable
    let mut clone = Borrow::clone(&data_ref);
    // Use the Borrow seemlessly
    data_ref.0.push('!');
    clone.1 += 55;
    data_ref.2 = true;
    clone.3.push(Data("".into(), 0, false, Vec::new()));

    // Debug for JavaCell is same as that for Data
    println!("{:?}", clone);
    // Output
    //Data("Hello, World!", 155, true, [Data("", 0, false, [])])
    println!("{:?}", data_ref);
    // Output
    //Data("Hello, World!", 155, true, [Data("", 0, false, [])])

    assert_eq!(
        *data_ref,
        Data(
            String::from("Hello, World!"),
            155,
            true,
            vec![Data("".into(), 0, false, vec![])]
        )
    );
    assert_eq!(
        *clone,
        Data(
            String::from("Hello, World!"),
            155,
            true,
            vec![Data("".into(), 0, false, vec![])]
        )
    );
    // Borrow implements AsRef and Deref of T
    print(&data_ref);
}

fn print<T: std::fmt::Debug>(data: &T) {
    // do something
    println!("{:?}", data);
}

LICENSE

MIT license