glib: Make glib::Slice API more complete and similar to Vec

Author: sdroege

glib/src/collections/mod.rs

@@ -1,274 +1,21 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
-use std::{fmt, iter::FusedIterator, marker::PhantomData, mem, ptr};
+use std::{iter::FusedIterator, marker::PhantomData, mem, ptr};
 
 use crate::translate::*;
 
 pub mod ptr_slice;
 pub use ptr_slice::PtrSlice;
 
+pub mod slice;
+pub use slice::Slice;
+
 #[derive(Debug, PartialEq, Eq)]
 enum ContainerTransfer {
     Full,
     Container,
 }
 
-// rustdoc-stripper-ignore-next
-/// Slice of elements of type `T` allocated by the GLib allocator.
-///
-/// This can be used like a `&[T]`.
-pub struct Slice<T: 'static> {
-    ptr: ptr::NonNull<T>,
-    len: usize,
-    transfer: ContainerTransfer,
-}
-
-unsafe impl<T: Send + 'static> Send for Slice<T> {}
-
-unsafe impl<T: Sync + 'static> Sync for Slice<T> {}
-
-impl<T: fmt::Debug + 'static> fmt::Debug for Slice<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.as_slice().fmt(f)
-    }
-}
-
-impl<T: PartialEq + 'static> PartialEq for Slice<T> {
-    fn eq(&self, other: &Self) -> bool {
-        self.as_slice() == other.as_slice()
-    }
-}
-
-impl<T: Eq + 'static> Eq for Slice<T> {}
-
-impl<T: PartialOrd + 'static> PartialOrd for Slice<T> {
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        self.as_slice().partial_cmp(other.as_slice())
-    }
-}
-
-impl<T: Ord + 'static> Ord for Slice<T> {
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        self.as_slice().cmp(other.as_slice())
-    }
-}
-
-impl<T: std::hash::Hash + 'static> std::hash::Hash for Slice<T> {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.as_slice().hash(state)
-    }
-}
-
-impl<T: PartialEq + 'static> PartialEq<[T]> for Slice<T> {
-    fn eq(&self, other: &[T]) -> bool {
-        self.as_slice() == other
-    }
-}
-
-impl<T: PartialEq + 'static> PartialEq<Slice<T>> for [T] {
-    fn eq(&self, other: &Slice<T>) -> bool {
-        self == other.as_slice()
-    }
-}
-
-impl<T: 'static> Slice<T> {
-    // rustdoc-stripper-ignore-next
-    /// Borrows a static C array.
-    #[inline]
-    pub unsafe fn from_glib_borrow_num<'a>(ptr: *const T, len: usize) -> &'a [T] {
-        debug_assert!(!ptr.is_null() || len == 0);
-
-        if len == 0 {
-            &[]
-        } else {
-            std::slice::from_raw_parts(ptr, len)
-        }
-    }
-
-    // rustdoc-stripper-ignore-next
-    /// Borrows a static mutable C array.
-    #[inline]
-    pub unsafe fn from_glib_borrow_num_mut<'a>(ptr: *mut T, len: usize) -> &'a mut [T] {
-        debug_assert!(!ptr.is_null() || len == 0);
-
-        if len == 0 {
-            &mut []
-        } else {
-            std::slice::from_raw_parts_mut(ptr, len)
-        }
-    }
-
-    // rustdoc-stripper-ignore-next
-    /// Create a new `Slice` around a C array of which the items are static.
-    ///
-    /// Must only be called for static items that are never invalidated.
-    #[inline]
-    pub unsafe fn from_glib_container_num_static(ptr: *mut T, len: usize) -> Self {
-        debug_assert!(!ptr.is_null() || len == 0);
-
-        Slice {
-            ptr: if len == 0 {
-                ffi::g_free(ptr as ffi::gpointer);
-                ptr::NonNull::dangling()
-            } else {
-                ptr::NonNull::new_unchecked(ptr)
-            },
-            len,
-            transfer: ContainerTransfer::Container,
-        }
-    }
-
-    // rustdoc-stripper-ignore-next
-    /// Create a new `Slice` around a C array where the items are `Copy`.
-    #[inline]
-    pub unsafe fn from_glib_container_num_copy(ptr: *mut T, len: usize) -> Self
-    where
-        T: Copy,
-    {
-        debug_assert!(!ptr.is_null() || len == 0);
-
-        Slice {
-            ptr: if len == 0 {
-                ffi::g_free(ptr as ffi::gpointer);
-                ptr::NonNull::dangling()
-            } else {
-                ptr::NonNull::new_unchecked(ptr)
-            },
-            len,
-            transfer: ContainerTransfer::Container,
-        }
-    }
-
-    // rustdoc-stripper-ignore-next
-    /// Create a new `Slice` around a C array where the items are borrowed.
-    #[inline]
-    pub unsafe fn from_glib_container_num<P: Ptr>(ptr: *mut T, len: usize) -> Self
-    where
-        T: FromGlibPtrNone<P>,
-    {
-        debug_assert!(!ptr.is_null() || len == 0);
-
-        for i in 0..len {
-            let p = ptr.add(i);
-            let v = from_glib_none(Ptr::from(p));
-            ptr::write(p, v);
-        }
-
-        Slice {
-            ptr: if len == 0 {
-                ffi::g_free(ptr as ffi::gpointer);
-                ptr::NonNull::dangling()
-            } else {
-                ptr::NonNull::new_unchecked(ptr)
-            },
-            len,
-            transfer: ContainerTransfer::Full,
-        }
-    }
-
-    // rustdoc-stripper-ignore-next
-    /// Create a new `Slice` around a C array where the items are `Copy`.
-    #[inline]
-    pub unsafe fn from_glib_full_num_copy(ptr: *mut T, len: usize) -> Self
-    where
-        T: Copy,
-    {
-        debug_assert!(!ptr.is_null() || len == 0);
-
-        Slice {
-            ptr: if len == 0 {
-                ffi::g_free(ptr as ffi::gpointer);
-                ptr::NonNull::dangling()
-            } else {
-                ptr::NonNull::new_unchecked(ptr)
-            },
-            len,
-            transfer: ContainerTransfer::Container,
-        }
-    }
-
-    // rustdoc-stripper-ignore-next
-    /// Create a new `Slice` around a C array.
-    #[inline]
-    pub unsafe fn from_glib_full_num(ptr: *mut T, len: usize) -> Self {
-        debug_assert!(!ptr.is_null() || len == 0);
-
-        Slice {
-            ptr: if len == 0 {
-                ffi::g_free(ptr as ffi::gpointer);
-                ptr::NonNull::dangling()
-            } else {
-                ptr::NonNull::new_unchecked(ptr)
-            },
-            len,
-            transfer: ContainerTransfer::Full,
-        }
-    }
-
-    // rustdoc-stripper-ignore-next
-    /// Borrows this slice as a `&[T]`.
-    #[inline]
-    pub fn as_slice(&self) -> &[T] {
-        self.as_ref()
-    }
-}
-
-impl<T: 'static> Drop for Slice<T> {
-    #[inline]
-    fn drop(&mut self) {
-        unsafe {
-            if self.transfer == ContainerTransfer::Full && mem::needs_drop::<T>() {
-                for i in 0..self.len {
-                    ptr::drop_in_place::<T>(self.ptr.as_ptr().add(i));
-                }
-            }
-
-            if self.len != 0 {
-                ffi::g_free(self.ptr.as_ptr() as ffi::gpointer);
-            }
-        }
-    }
-}
-
-impl<T: 'static> AsRef<[T]> for Slice<T> {
-    #[inline]
-    fn as_ref(&self) -> &[T] {
-        unsafe {
-            if self.len == 0 {
-                &[]
-            } else {
-                std::slice::from_raw_parts(self.ptr.as_ptr() as *const T, self.len)
-            }
-        }
-    }
-}
-
-impl<T: 'static> std::ops::Deref for Slice<T> {
-    type Target = [T];
-
-    #[inline]
-    fn deref(&self) -> &[T] {
-        self.as_ref()
-    }
-}
-
-// FIXME: Ideally FromGlibPtrNone would not be needed for from_glib_full()
-impl<T: FromGlibPtrNone<*mut T> + 'static> FromGlibContainer<T, *mut T> for Slice<T> {
-    unsafe fn from_glib_none_num(_ptr: *mut T, _num: usize) -> Self {
-        unimplemented!()
-    }
-
-    #[inline]
-    unsafe fn from_glib_container_num(ptr: *mut T, num: usize) -> Self {
-        Self::from_glib_container_num(ptr, num)
-    }
-
-    #[inline]
-    unsafe fn from_glib_full_num(ptr: *mut T, num: usize) -> Self {
-        Self::from_glib_full_num(ptr, num)
-    }
-}
-
 // rustdoc-stripper-ignore-next
 /// A list of items of type `T`.
 ///
@@ -793,28 +540,6 @@ impl<
 mod test {
     use super::*;
 
-    #[test]
-    fn slice() {
-        let items = [
-            crate::Date::from_dmy(20, crate::DateMonth::November, 2021).unwrap(),
-            crate::Date::from_dmy(21, crate::DateMonth::November, 2021).unwrap(),
-            crate::Date::from_dmy(22, crate::DateMonth::November, 2021).unwrap(),
-            crate::Date::from_dmy(23, crate::DateMonth::November, 2021).unwrap(),
-        ];
-
-        let slice = unsafe {
-            let ptr = ffi::g_malloc(mem::size_of::<ffi::GDate>() * 4) as *mut ffi::GDate;
-            ptr::write(ptr.add(0), *items[0].to_glib_none().0);
-            ptr::write(ptr.add(1), *items[1].to_glib_none().0);
-            ptr::write(ptr.add(2), *items[2].to_glib_none().0);
-            ptr::write(ptr.add(3), *items[3].to_glib_none().0);
-
-            Slice::<crate::Date>::from_glib_full_num(ptr as *mut crate::Date, 4)
-        };
-
-        assert_eq!(&items[..], &*slice);
-    }
-
     #[test]
     // checker-ignore-item
     fn list() {