#handle #reference-counting #rchandle


Regular and reference-counted type handles

3 releases

0.1.2 Aug 31, 2023
0.1.1 Aug 30, 2023
0.1.0 Aug 29, 2023

#472 in Memory management

Download history 18/week @ 2024-02-23 14/week @ 2024-03-01 37/week @ 2024-03-29 3/week @ 2024-04-05 84/week @ 2024-04-12

124 downloads per month


233 lines


Tiny Rust library that exports Handle<T> and RCHandle<T>. Can be useful for wrapping native ffi structs/pointers.

Both Handle and RCHandle implement Clone, where Handle will clone the underlying struct instance (if it implements Clone), and RCHandle will keep the underlying pointer.

Handle and RCHandle implement Send/Sync by default with the send_sync feature.

They both implement Deref and DerefMut, so you can access a field through a handle the same as you normally would on a normal instance.



struct Animal {
    is_dog: bool,

let animal = Animal { is_dog: false };
let cat = Handle::from_instance(animal);

// clone `cat` and mutate `is_dog`, note that `animal` is not mutable
let dog = handle.clone(); // this clones `Animal`, `Animal` must implement `Clone`
dog.is_dog = true;

RCHandle<T> (reference-counted handle)

// don't have to #[derive(Clone)] here!
struct Animal {
    is_dog: bool,

let mut animal = Animal { is_dog: false };
let mut handle = RCHandle::from_ptr(&mut animal);

// note that `Animal` does not implement `Clone`, because 
// cloning an `RCHandle` does not clone the underlying type
let mut handle2 = handle.clone();

handle2.is_dog = true;
assert!(handle.is_dog == handle2.is_dog);


To run tests, run cargo test.


Public domain (unlicense).

No runtime deps