gistfile1.rs

//! Wrapper around Rc<Box<T>>

#![allow(dead_code)]

use std::ops::{Deref,DerefMut};
use std::rc::Rc;

struct Reference<T: ?Sized>(Rc<Box<T>>);

impl<T : ?Sized> Reference<T> {
    fn new(value: Box<T>) -> Self {
        Reference(Rc::new(value))
    }
}

impl<T : ?Sized> Deref for Reference<T> {
    type Target = Rc<Box<T>>;

    fn deref(&self) -> &Rc<Box<T>> { &self.0 }
}

impl<T : ?Sized> DerefMut for Reference<T> {
    fn deref_mut(&mut self) -> &mut Rc<Box<T>> { &mut self.0 }
}

#[cfg(test)]
#[allow(unused_variables)]
mod test {
    trait Trait {
        fn example(&self);
    }

    struct Struct;

    impl Trait for Struct {
        fn example(&self) {
            loop { }
        }
    }

    #[test]
    fn test_ref() {
        use super::Reference;

        // let s: Reference<Struct> = Reference::new(Struct);
        // let t: Reference<Trait> = Reference::new(Struct);

        let s: Reference<Struct> = Reference::new(Box::new(Struct));
        let t: Reference<Trait> = Reference::new(Box::new(Struct));
    }

    #[test]
    fn test_rc() {
        use std::rc::Rc;

        let s: Rc<Box<Struct>> = Rc::new(Box::new(Struct));
        let t: Rc<Box<Trait>> = Rc::new(Box::new(Struct));

        let s: Rc<Struct> = Rc::new(Struct);
        let t: Rc<Trait> = Rc::new(Struct);
    }
}