Support for triomphe::Arc.

Cargo.toml

@@ -41,6 +41,7 @@ codecov = { repository = "orium/archery", branch = "master", service = "github"
 
 [dependencies]
 static_assertions = "1.1.0"
+triomphe = { version = "0.1.9", default-features = false, optional = true }
 
 [dev-dependencies]
 criterion = { version = "0.5.1", features = ["html_reports"] }
@@ -49,6 +50,7 @@ compiletest_rs = "0.10.2"
 
 [features]
 fatal-warnings = []
+triomphe = ["dep:triomphe"]
 
 [[bench]]
 name = "std_rc"
@@ -69,3 +71,9 @@ harness = false
 name = "archery_shared_pointer_arc"
 path = "benches/archery_shared_pointer_arc.rs"
 harness = false
+
+[[bench]]
+name = "archery_shared_pointer_arct"
+path = "benches/archery_shared_pointer_arct.rs"
+harness = false
+required-features = ["triomphe"]

benches/archery_shared_pointer_arct.rs

@@ -0,0 +1,45 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#![cfg_attr(feature = "fatal-warnings", deny(warnings))]
+
+use archery::*;
+use std::ops::Deref;
+
+use criterion::{criterion_group, criterion_main, Criterion};
+use std::hint::black_box;
+
+fn archery_shared_pointer_arct_deref(c: &mut Criterion) {
+    let limit = 200_000;
+
+    c.bench_function("archery shared pointer arct deref", move |b| {
+        b.iter(|| {
+            let rc: SharedPointer<_, ArcTK> = SharedPointer::new(42);
+
+            for _ in 0..limit {
+                black_box(rc.deref());
+            }
+
+            rc
+        })
+    });
+}
+
+fn archery_shared_pointer_arct_clone(c: &mut Criterion) {
+    let limit = 100_000;
+
+    c.bench_function("archery shared pointer arct clone and drop", move |b| {
+        b.iter_with_setup(
+            || Vec::with_capacity(limit),
+            |mut vec| {
+                vec.resize(limit, SharedPointer::<_, ArcTK>::new(42));
+                vec
+            },
+        )
+    });
+}
+
+criterion_group!(benches, archery_shared_pointer_arct_deref, archery_shared_pointer_arct_clone);
+criterion_main!(benches);

src/lib.rs

@@ -133,5 +133,8 @@ pub use shared_pointer::kind::SharedPointerKind;
 
 #[doc(no_inline)]
 pub use shared_pointer::kind::ArcK;
+#[cfg(feature = "triomphe")]
+#[doc(no_inline)]
+pub use shared_pointer::kind::ArcTK;
 #[doc(no_inline)]
 pub use shared_pointer::kind::RcK;

src/shared_pointer/kind/arct/mod.rs

@@ -0,0 +1,124 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+use crate::shared_pointer::kind::SharedPointerKind;
+use alloc::boxed::Box;
+use core::fmt;
+use core::fmt::Debug;
+use core::fmt::Formatter;
+use core::mem;
+use core::mem::ManuallyDrop;
+use core::ops::Deref;
+use core::ops::DerefMut;
+use core::ptr;
+use triomphe::Arc;
+
+type UntypedArc = Arc<()>;
+
+/// [Type constructors](https://en.wikipedia.org/wiki/Type_constructor) for
+/// [`Arc`] pointers.
+pub struct ArcTK {
+    /// We use [`ManuallyDrop`] here, so that we can drop it explicitly as
+    /// [`Arc<T>`](triomphe::Arc).  Not sure if it can be dropped as [`UntypedArc`], but it
+    /// seems to be playing with fire (even more than we already are).
+    inner: ManuallyDrop<UntypedArc>,
+}
+
+impl ArcTK {
+    #[inline(always)]
+    fn new_from_inner<T>(arc: Arc<T>) -> ArcTK {
+        ArcTK { inner: ManuallyDrop::new(unsafe { mem::transmute(arc) }) }
+    }
+
+    #[inline(always)]
+    unsafe fn take_inner<T>(self) -> Arc<T> {
+        let arc: UntypedArc = ManuallyDrop::into_inner(self.inner);
+
+        mem::transmute(arc)
+    }
+
+    #[inline(always)]
+    unsafe fn as_inner_ref<T>(&self) -> &Arc<T> {
+        let arc_t: *const Arc<T> = (self.inner.deref() as *const UntypedArc).cast::<Arc<T>>();
+
+        // Static check to make sure we are not messing up the sizes.
+        // This could happen if we allowed for `T` to be unsized, because it would need to be
+        // represented as a wide pointer inside `Arc`.
+        // TODO Use static_assertion when https://github.com/nvzqz/static-assertions-rs/issues/21
+        //      gets fixed
+        let _ = mem::transmute::<UntypedArc, Arc<T>>;
+
+        &*arc_t
+    }
+
+    #[inline(always)]
+    unsafe fn as_inner_mut<T>(&mut self) -> &mut Arc<T> {
+        let arc_t: *mut Arc<T> = (self.inner.deref_mut() as *mut UntypedArc).cast::<Arc<T>>();
+
+        &mut *arc_t
+    }
+}
+
+unsafe impl SharedPointerKind for ArcTK {
+    #[inline(always)]
+    fn new<T>(v: T) -> ArcTK {
+        ArcTK::new_from_inner(Arc::new(v))
+    }
+
+    #[inline(always)]
+    fn from_box<T>(v: Box<T>) -> ArcTK {
+        ArcTK::new_from_inner::<T>(Arc::from(v))
+    }
+
+    #[inline(always)]
+    unsafe fn as_ptr<T>(&self) -> *const T {
+        Arc::as_ptr(self.as_inner_ref())
+    }
+
+    #[inline(always)]
+    unsafe fn deref<T>(&self) -> &T {
+        self.as_inner_ref::<T>().as_ref()
+    }
+
+    #[inline(always)]
+    unsafe fn try_unwrap<T>(self) -> Result<T, ArcTK> {
+        Arc::try_unwrap(self.take_inner()).map_err(ArcTK::new_from_inner)
+    }
+
+    #[inline(always)]
+    unsafe fn get_mut<T>(&mut self) -> Option<&mut T> {
+        Arc::get_mut(self.as_inner_mut())
+    }
+
+    #[inline(always)]
+    unsafe fn make_mut<T: Clone>(&mut self) -> &mut T {
+        Arc::make_mut(self.as_inner_mut())
+    }
+
+    #[inline(always)]
+    unsafe fn strong_count<T>(&self) -> usize {
+        Arc::count(self.as_inner_ref::<T>())
+    }
+
+    #[inline(always)]
+    unsafe fn clone<T>(&self) -> ArcTK {
+        ArcTK { inner: ManuallyDrop::new(Arc::clone(self.as_inner_ref())) }
+    }
+
+    #[inline(always)]
+    unsafe fn drop<T>(&mut self) {
+        ptr::drop_in_place::<Arc<T>>(self.as_inner_mut());
+    }
+}
+
+impl Debug for ArcTK {
+    #[inline(always)]
+    fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
+        f.write_str("ArcTK")
+    }
+}
+
+#[cfg(test)]
+mod test;

src/shared_pointer/kind/arct/test.rs

@@ -0,0 +1,193 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+use super::*;
+use pretty_assertions::assert_eq;
+use static_assertions::assert_impl_all;
+use std::cell::Cell;
+use std::string::ToString;
+
+type PointerKind = ArcTK;
+
+assert_impl_all!(ArcTK: Send, Sync);
+
+#[test]
+fn test_from_box_t() {
+    let mut ptr = PointerKind::from_box(Box::new(42));
+
+    unsafe {
+        assert_eq!(ptr.deref::<i32>(), &42);
+
+        ptr.drop::<i32>();
+    }
+}
+
+#[test]
+fn test_as_ptr() {
+    let mut x = PointerKind::new::<&'static str>("hello");
+
+    unsafe {
+        let mut y = PointerKind::clone::<&'static str>(&x);
+        let x_ptr: *const &'static str = PointerKind::as_ptr(&x);
+
+        assert_eq!(x_ptr, PointerKind::as_ptr(&y));
+        assert_eq!(*x_ptr, "hello");
+
+        x.drop::<&'static str>();
+        y.drop::<&'static str>();
+    }
+}
+
+#[test]
+fn test_deref() {
+    let mut ptr_42 = PointerKind::new::<i32>(42);
+    let mut ptr_box_dyn_hello = PointerKind::new::<Box<dyn ToString>>(Box::new("hello"));
+
+    unsafe {
+        assert_eq!(ptr_42.deref::<i32>(), &42);
+        assert_eq!(ptr_box_dyn_hello.deref::<Box<dyn ToString>>().to_string(), "hello");
+
+        ptr_42.drop::<i32>();
+        ptr_box_dyn_hello.drop::<Box<dyn ToString>>();
+    }
+}
+
+#[test]
+fn test_try_unwrap() {
+    let ptr = PointerKind::new::<i32>(42);
+
+    unsafe {
+        assert_eq!(ptr.try_unwrap::<i32>().unwrap(), 42);
+    }
+
+    let ptr = PointerKind::new::<i32>(42);
+
+    unsafe {
+        let ptr_clone = ptr.clone::<i32>();
+
+        let mut ptr_clone = ptr_clone.try_unwrap::<i32>().unwrap_err();
+        let mut ptr = ptr.try_unwrap::<i32>().unwrap_err();
+
+        assert_eq!(ptr.deref::<i32>(), &42);
+        assert_eq!(ptr_clone.deref::<i32>(), &42);
+
+        ptr.drop::<i32>();
+        ptr_clone.drop::<i32>();
+    }
+}
+
+#[test]
+fn test_get_mut() {
+    let mut ptr = PointerKind::new::<i32>(42);
+
+    unsafe {
+        assert_eq!(ptr.deref::<i32>(), &42);
+
+        *ptr.get_mut::<i32>().unwrap() += 1;
+
+        assert_eq!(ptr.deref::<i32>(), &43);
+
+        let mut ptr_clone = ptr.clone::<i32>();
+
+        assert_eq!(ptr.get_mut::<i32>(), None);
+        assert_eq!(ptr_clone.get_mut::<i32>(), None);
+
+        ptr.drop::<i32>();
+
+        *ptr_clone.get_mut::<i32>().unwrap() += 1;
+
+        assert_eq!(ptr_clone.deref::<i32>(), &44);
+
+        ptr_clone.drop::<i32>();
+    }
+}
+
+#[test]
+fn test_make_mut() {
+    let mut ptr = PointerKind::new::<i32>(42);
+
+    unsafe {
+        assert_eq!(ptr.deref::<i32>(), &42);
+
+        *ptr.make_mut::<i32>() += 1;
+
+        assert_eq!(ptr.deref::<i32>(), &43);
+
+        // Clone to force make_mut to clone the data.
+        let mut ptr_clone = ptr.clone::<i32>();
+
+        assert_eq!(ptr_clone.deref::<i32>(), &43);
+
+        *ptr_clone.make_mut::<i32>() += 1;
+
+        assert_eq!(ptr.deref::<i32>(), &43);
+        assert_eq!(ptr_clone.deref::<i32>(), &44);
+
+        *ptr.make_mut::<i32>() *= 2;
+
+        assert_eq!(ptr.deref::<i32>(), &(2 * 43));
+        assert_eq!(ptr_clone.deref::<i32>(), &44);
+
+        ptr.drop::<i32>();
+
+        assert_eq!(ptr_clone.deref::<i32>(), &44);
+
+        ptr_clone.drop::<i32>();
+    }
+}
+
+#[test]
+fn test_strong_count() {
+    let mut ptr = PointerKind::new::<i32>(42);
+
+    unsafe {
+        assert_eq!(ptr.strong_count::<i32>(), 1);
+
+        let mut ptr_clone = ptr.clone::<i32>();
+
+        assert_eq!(ptr.strong_count::<i32>(), 2);
+        assert_eq!(ptr_clone.strong_count::<i32>(), 2);
+
+        ptr.drop::<i32>();
+
+        assert_eq!(ptr_clone.strong_count::<i32>(), 1);
+
+        ptr_clone.drop::<i32>();
+    }
+}
+
+#[test]
+fn test_clone() {
+    let mut ptr = PointerKind::new::<Cell<i32>>(Cell::new(42));
+
+    unsafe {
+        let mut ptr_clone = ptr.clone::<Cell<i32>>();
+
+        assert_eq!(ptr.deref::<Cell<i32>>().get(), 42);
+        assert_eq!(ptr_clone.deref::<Cell<i32>>().get(), 42);
+
+        ptr_clone.deref::<Cell<i32>>().set(3);
+
+        assert_eq!(ptr.deref::<Cell<i32>>().get(), 3);
+        assert_eq!(ptr_clone.deref::<Cell<i32>>().get(), 3);
+
+        ptr.drop::<Cell<i32>>();
+
+        assert_eq!(ptr_clone.deref::<Cell<i32>>().get(), 3);
+
+        ptr_clone.drop::<Cell<i32>>();
+    }
+}
+
+#[test]
+fn test_debug() {
+    let mut ptr = PointerKind::new::<i32>(42);
+
+    assert_eq!(format!("{:?}", ptr), "ArcTK");
+
+    unsafe {
+        ptr.drop::<i32>();
+    }
+}