speedy_refs

Crates.iospeedy_refs
lib.rsspeedy_refs
version0.2.7
sourcesrc
created_at2023-04-05 02:15:00.036859
updated_at2023-04-30 00:10:11.448246
descriptionA collection of simple and fast and useful smart pointers.
homepage
repository
max_upload_size
id830604
Isaac Newton Dzikum (nisaacdz)

documentation

README

# 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` - **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); 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(data: &T) { // do something println!("{:?}", data); } ``` # LICENSE **MIT license**
Commit count: 0

cargo fmt