Implement missing `Send` and `Sync` traits

src/borrow.rs

@@ -10,6 +10,10 @@ pub(super) struct DormantMutRef<'a, T> {
     _marker: PhantomData<&'a mut T>,
 }
 
+// SAFETY: `DormantMutRef<'a, T>` represents a value of `&'a mut T`.
+unsafe impl<'a, T> Send for DormantMutRef<'a, T> where &'a mut T: Send {}
+unsafe impl<'a, T> Sync for DormantMutRef<'a, T> where &'a mut T: Sync {}
+
 impl<'a, T> DormantMutRef<'a, T> {
     /// Creates a dormant mutable reference and returns both the original reference and the dormant
     /// reference, so that the original reference can continue to be used.
@@ -75,6 +79,10 @@ pub(super) struct DestroyableRef<'a, T> {
     _marker: PhantomData<&'a T>,
 }
 
+// SAFETY: `DestroyableRef<'a, T>` represents a value of `&'a T`.
+unsafe impl<'a, T> Send for DestroyableRef<'a, T> where &'a T: Send {}
+unsafe impl<'a, T> Sync for DestroyableRef<'a, T> where &'a T: Sync {}
+
 impl<'a, T> DestroyableRef<'a, T> {
     /// Creates a destroyable reference from an immutable reference.
     pub fn new(val: &'a T) -> Self {
@@ -99,6 +107,10 @@ pub(super) struct DestroyableMutRef<'a, T> {
     _marker: PhantomData<&'a mut T>,
 }
 
+// SAFETY: `DestroyableMutRef<'a, T>` represents a value of `&'a mut T`.
+unsafe impl<'a, T> Send for DestroyableMutRef<'a, T> where &'a mut T: Send {}
+unsafe impl<'a, T> Sync for DestroyableMutRef<'a, T> where &'a mut T: Sync {}
+
 impl<'a, T> DestroyableMutRef<'a, T> {
     /// Creates a destroyable reference from an immutable reference.
     pub fn new(val: &'a mut T) -> Self {

src/entry.rs

@@ -164,6 +164,10 @@ where
     _marker: core::marker::PhantomData<(Arc<XNode<I>>, I)>,
 }
 
+// SAFETY: `XEntry<I>` represents a value of either `Arc<XNode<I>>` or `I`.
+unsafe impl<I: ItemEntry> Send for XEntry<I> where (Arc<XNode<I>>, I): Send {}
+unsafe impl<I: ItemEntry> Sync for XEntry<I> where (Arc<XNode<I>>, I): Sync {}
+
 #[derive(PartialEq, Eq, Debug)]
 #[repr(usize)]
 enum EntryType {

src/test.rs

@@ -2,6 +2,7 @@ extern crate std;
 use crate::*;
 use std::boxed::Box;
 use std::sync::Arc;
+use std::thread;
 
 extern crate test;
 use test::Bencher;
@@ -481,6 +482,53 @@ fn test_range() {
     assert_eq!(count, n!(5));
 }
 
+#[test]
+fn test_threads() {
+    let mut xarray_arc: XArray<Arc<i32>> = XArray::new();
+    xarray_arc.store(2, Arc::new(3));
+
+    thread::scope(|scope| {
+        scope.spawn(|| {
+            assert_eq!(xarray_arc.load(1), None);
+            assert_eq!(*xarray_arc.load(2).unwrap().as_ref(), 3);
+        });
+        scope.spawn(|| {
+            assert_eq!(*xarray_arc.load(2).unwrap().as_ref(), 3);
+            assert_eq!(xarray_arc.load(1), None);
+        });
+    });
+
+    thread::spawn(move || {
+        assert_eq!(*xarray_arc.load(2).unwrap().as_ref(), 3);
+    })
+    .join()
+    .unwrap();
+}
+
+#[test]
+fn test_cursor_threads() {
+    let mut xarray_arc: XArray<Arc<i32>> = XArray::new();
+    xarray_arc.store(2, Arc::new(3));
+
+    let cursor = xarray_arc.cursor(2);
+    thread::scope(|scope| {
+        scope.spawn(|| {
+            assert_eq!(cursor.index(), 2);
+        });
+        scope.spawn(|| {
+            assert_eq!(cursor.index(), 2);
+        });
+    });
+    drop(cursor);
+
+    thread::scope(|scope| {
+        let cursor = xarray_arc.cursor(3);
+        scope.spawn(move || {
+            assert_eq!(cursor.index(), 3);
+        });
+    });
+}
+
 #[bench]
 fn benchmark_cursor_load(b: &mut Bencher) {
     b.iter(|| test_cursor_load());