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 numthreads = 4; let barrier = Arc::new(Barrier::new(numthreads));

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);

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 dataref = Borrow::new(data); // Create another reference to the same variable let mut clone = Borrow::clone(&dataref); // Use the Borrow seemlessly dataref.0.push('!'); clone.1 += 55; dataref.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(data: &T) { // do something println!("{:?}", data); }

```

LICENSE

MIT license