Compiler Explorer

Source code

use std::ops::Deref;

struct RefCountAndT<T> {
    strong_references: usize,
    weak_references: usize,
    obj: T,
}

impl <T> RefCountAndT<T> {
    fn has_no_remaining_references(&self) -> bool {
        self.strong_references == 0 && self.weak_references == 0
    }

fn has_no_strong_references(&self) -> bool {
        self.strong_references == 0
    }
}

struct Rc<T> {
    ref_count_and_t: *mut RefCountAndT<T>,
}

impl <T> Rc<T> {
    pub fn new(obj: T) -> Self {
        //Move 'obj' onto the heap into a new RefCountAndT instance. We can use Box for this, just temporarily! 
        let ref_count_and_t = Box::new(RefCountAndT {
            strong_references: 1,
            weak_references: 0,
            obj,
        });
        //Now we *leak* the box to obtain the raw pointer! Box::leak returns a mutable *borrow*...
        let leaked : &mut RefCountAndT<T> = Box::leak(ref_count_and_t);
        //...but we want a *pointer*. Luckily, we can cast one into the other. This does NOT require unsafe code,
        //only *using* the pointer is unsafe (because it can be null)!
        let leaked_ptr : *mut RefCountAndT<T> = leaked;
        Self {
            ref_count_and_t: leaked_ptr,
        }
    }

pub fn get(&self) -> &T {
        unsafe {
            &self.ref_count_and_t.as_ref().unwrap().obj
        }
    }

pub fn get_mut(&mut self) -> &mut T {
        unsafe {
            &mut self.ref_count_and_t.as_mut().unwrap().obj
        }
    }

pub fn as_weak(&self) -> WeakPtr<T> {
        unsafe {
            let ref_count_and_t = self.ref_count_and_t.as_mut().unwrap();
            ref_count_and_t.weak_references += 1;
        }
        WeakPtr::<T> {
            control_block: self.ref_count_and_t,
        }
    }
}

impl <T> Drop for Rc<T> {
    fn drop(&mut self) {
        unsafe {
            let ref_count_and_t = self.ref_count_and_t.as_mut().unwrap();
            ref_count_and_t.strong_references -= 1;
            // If this was the last strong reference, we have to drop the value of `T`! This is the 
            // guarantee of a smart pointer: Once the last smart pointer goes out of scope, the pointed-to
            // instance is destroyed. It's a bit tricky to do so, because our value is part of the control
            // block...
            if ref_count_and_t.has_no_strong_references() {
                // We have to use this 'drop_in_place' method, which effectively calls the destructor of the value
                // but does not deallocate its memory
                std::ptr::drop_in_place(&mut ref_count_and_t.obj);
            }
            // Only drop the control block if there are neither strong nor weak references! 
            if ref_count_and_t.has_no_remaining_references() {
                let _as_box = Box::from_raw(self.ref_count_and_t);
            }
        }
    }
}

impl <T> Clone for Rc<T> {
    fn clone(&self) -> Self {
        unsafe {
            let ref_count_and_t = self.ref_count_and_t.as_mut().unwrap();
            ref_count_and_t.strong_references += 1;
        }
        Self {
            ref_count_and_t: self.ref_count_and_t
        }
    }
}

impl <T> Deref for Rc<T> {
    type Target = T;

fn deref(&self) -> &Self::Target {
        self.get()
    }
}

struct WeakPtr<T> {
    control_block: *mut RefCountAndT<T>,
}

impl <T> WeakPtr<T> {
    pub fn to_rc(&self) -> Option<Rc<T>> {
        unsafe {
            let ref_count_and_t = self.control_block.as_mut().unwrap();
            if ref_count_and_t.strong_references == 0 {
                return None;
            }
            ref_count_and_t.strong_references += 1;
            Some(Rc::<T> {
                ref_count_and_t,
            })
        }
    }
}

impl <T> Drop for WeakPtr<T> {
    fn drop(&mut self) {
        unsafe {
            let ref_count_and_t = self.control_block.as_mut().unwrap();
            ref_count_and_t.weak_references -= 1;
            if ref_count_and_t.has_no_remaining_references() {
                let _as_box = Box::from_raw(self.control_block);
            }
        }
    }
}

impl <T> Clone for WeakPtr<T> {
    fn clone(&self) -> Self {
        unsafe {
            let ref_count_and_t = self.control_block.as_mut().unwrap();
            ref_count_and_t.weak_references += 1;
        }
        Self {
            control_block: self.control_block,
        }
    }
}

pub fn main() {
    let strong1 = Rc::new(42);
    let weak1 = strong1.as_weak();

println!("Strong: {}", strong1.get());
    println!("Weak: {}", weak1.to_rc().unwrap().get());

drop(strong1);
    println!("Weak pointer still valid after last Rc<T> dropped? {}", weak1.to_rc().is_some());
}