unsafe_any/
lib.rs

1#![deny(missing_docs, warnings)]
2
3//! Traits for unsafe downcasting from trait objects to & or &mut references of
4//! concrete types. These should only be used if you are absolutely certain of the
5//! type of the data in said trait object - there be dragons etc.
6//!
7//! Originally inspired by https://github.com/chris-morgan/anymap
8//! and the implementation of `std::any::Any`.
9
10extern crate traitobject;
11
12use std::any::Any;
13use std::mem;
14
15/// A trait providing unchecked downcasting to its contents when stored
16/// in a trait object.
17pub trait UnsafeAny: Any {}
18impl<T: Any> UnsafeAny for T {}
19
20impl UnsafeAny {
21    /// Returns a reference to the contained value, assuming that it is of type `T`.
22    ///
23    /// ## Warning
24    ///
25    /// If you are not _absolutely certain_ of `T` you should _not_ call this!
26    pub unsafe fn downcast_ref_unchecked<T: Any>(&self) -> &T {
27        mem::transmute(traitobject::data(self))
28    }
29
30    /// Returns a mutable reference to the contained value, assuming that it is of type `T`.
31    ///
32    /// ## Warning
33    ///
34    /// If you are not _absolutely certain_ of `T` you should _not_ call this!
35    pub unsafe fn downcast_mut_unchecked<T: Any>(&mut self) -> &mut T {
36        mem::transmute(traitobject::data_mut(self))
37    }
38
39    /// Returns a the contained value, assuming that it is of type `T`.
40    ///
41    /// ## Warning
42    ///
43    /// If you are not _absolutely certain_ of `T` you should _not_ call this!
44    pub unsafe fn downcast_unchecked<T: Any>(self: Box<UnsafeAny>) -> Box<T> {
45        let raw: *mut UnsafeAny = mem::transmute(self);
46        mem::transmute(traitobject::data_mut(raw))
47    }
48}
49
50/// An extension trait for unchecked downcasting of trait objects.
51pub unsafe trait UnsafeAnyExt {
52    /// Returns a reference to the contained value, assuming that it is of type `T`.
53    ///
54    /// ## Warning
55    ///
56    /// If you are not _absolutely certain_ of `T` you should _not_ call this!
57    unsafe fn downcast_ref_unchecked<T: Any>(&self) -> &T {
58        mem::transmute(traitobject::data(self))
59    }
60
61    /// Returns a mutable reference to the contained value, assuming that it is of type `T`.
62    ///
63    /// ## Warning
64    ///
65    /// If you are not _absolutely certain_ of `T` you should _not_ call this!
66    unsafe fn downcast_mut_unchecked<T: Any>(&mut self) -> &mut T {
67        mem::transmute(traitobject::data_mut(self))
68    }
69
70    /// Returns a the contained value, assuming that it is of type `T`.
71    ///
72    /// ## Warning
73    ///
74    /// If you are not _absolutely certain_ of `T` you should _not_ call this!
75    unsafe fn downcast_unchecked<T: Any>(self: Box<Self>) -> Box<T> {
76        let raw: *mut Self = mem::transmute(self);
77        mem::transmute(traitobject::data_mut(raw))
78    }
79}
80
81unsafe impl UnsafeAnyExt for Any { }
82unsafe impl UnsafeAnyExt for UnsafeAny { }
83unsafe impl UnsafeAnyExt for Any + Send { }
84unsafe impl UnsafeAnyExt for Any + Sync { }
85unsafe impl UnsafeAnyExt for Any + Send + Sync { }
86unsafe impl UnsafeAnyExt for UnsafeAny + Send { }
87unsafe impl UnsafeAnyExt for UnsafeAny + Sync { }
88unsafe impl UnsafeAnyExt for UnsafeAny + Send + Sync { }
89
90#[cfg(test)]
91mod test {
92    use super::{UnsafeAny, UnsafeAnyExt};
93    use std::any::Any;
94
95    #[test] fn test_simple_downcast_ext() {
96        let a = Box::new(7usize) as Box<Any>;
97        unsafe { assert_eq!(*a.downcast_ref_unchecked::<usize>(), 7); }
98
99        let mut a = Box::new(7usize) as Box<Any>;
100        unsafe { assert_eq!(*a.downcast_mut_unchecked::<usize>(), 7); }
101
102        let mut a = Box::new(7usize) as Box<Any>;
103        unsafe {
104            *a.downcast_mut_unchecked::<usize>() = 8;
105            assert_eq!(*a.downcast_mut_unchecked::<usize>(), 8);
106        }
107    }
108
109    #[test] fn test_simple_downcast_inherent() {
110        let a = Box::new(7usize) as Box<UnsafeAny>;
111        unsafe { assert_eq!(*a.downcast_ref_unchecked::<usize>(), 7); }
112
113        let mut a = Box::new(7usize) as Box<UnsafeAny>;
114        unsafe { assert_eq!(*a.downcast_mut_unchecked::<usize>(), 7); }
115
116        let mut a = Box::new(7usize) as Box<UnsafeAny>;
117        unsafe {
118            *a.downcast_mut_unchecked::<usize>() = 8;
119            assert_eq!(*a.downcast_mut_unchecked::<usize>(), 8);
120        }
121    }
122
123    #[test] fn test_box_downcast_no_double_free() {
124        use std::sync::atomic::{AtomicUsize, Ordering};
125        use std::sync::Arc;
126
127        struct Dropper {
128            x: Arc<AtomicUsize>
129        }
130
131        impl Drop for Dropper {
132            fn drop(&mut self) {
133                self.x.fetch_add(1, Ordering::SeqCst);
134            }
135        }
136
137        let x = Arc::new(AtomicUsize::new(0));
138        let a = Box::new(Dropper { x: x.clone() }) as Box<UnsafeAny>;
139
140        let dropper = unsafe { a.downcast_unchecked::<Dropper>() };
141        drop(dropper);
142
143        assert_eq!(x.load(Ordering::SeqCst), 1);
144
145        // Test the UnsafeAnyExt implementation.
146        let x = Arc::new(AtomicUsize::new(0));
147        let a = Box::new(Dropper { x: x.clone() }) as Box<Any>;
148
149        let dropper = unsafe { a.downcast_unchecked::<Dropper>() };
150        drop(dropper);
151
152        assert_eq!(x.load(Ordering::SeqCst), 1);
153    }
154}
155
unsafe_any/lib.rs

unsafe_any/
lib.rs
