RawList as public vis

-------
1 update to 0.2.1
2 RawList as a public type

Signed-off-by: guoweikang <[email protected]>

Author: guoweikang

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "linked_list_r4l"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2021"
 authors = ["Wedson Almeida Filho <[email protected]>", "WeiKang Guo <[email protected]>"]
 description = "Linked lists that supports arbitrary removal in constant time"

src/lib.rs

@@ -4,7 +4,7 @@
 mod linked_list;
 mod raw_list;
 pub use linked_list::List;
-pub use raw_list::{GetLinks, Links};
+pub use raw_list::{GetLinks, Links, RawList};
 
 #[macro_export(local_inner_macros)]
 #[doc(hidden)]

src/raw_list.rs

@@ -90,21 +90,21 @@ impl<T: ?Sized> ListEntry<T> {
 /// # Invariants
 ///
 /// The links of objects added to a list are owned by the list.
-pub(crate) struct RawList<G: GetLinks> {
+pub struct RawList<G: GetLinks> {
     head: Option<NonNull<G::EntryType>>,
 }
 
 impl<G: GetLinks> RawList<G> {
-    pub(crate) const fn new() -> Self {
+    pub const fn new() -> Self {
         Self { head: None }
     }
 
     /// Returns an iterator for the list starting at the first entry.
-    pub(crate) fn iter(&self) -> Iterator<'_, G> {
+    pub fn iter(&self) -> Iterator<'_, G> {
         Iterator::new(self.cursor_front(), self.cursor_back())
     }
 
-    pub(crate) const fn is_empty(&self) -> bool {
+    pub const fn is_empty(&self) -> bool {
         self.head.is_none()
     }
 
@@ -135,11 +135,7 @@ impl<G: GetLinks> RawList<G> {
     /// # Safety
     ///
     /// Callers must ensure that `existing` points to a valid entry that is on the list.
-    pub(crate) unsafe fn insert_after(
-        &mut self,
-        existing: &G::EntryType,
-        new: &G::EntryType,
-    ) -> bool {
+    pub unsafe fn insert_after(&mut self, existing: &G::EntryType, new: &G::EntryType) -> bool {
         let links = G::get_links(new);
         if !links.acquire_for_insertion() {
             // Nothing to do if already inserted.
@@ -180,11 +176,11 @@ impl<G: GetLinks> RawList<G> {
         true
     }
 
-    pub(crate) unsafe fn push_back(&mut self, new: &G::EntryType) -> bool {
+    pub unsafe fn push_back(&mut self, new: &G::EntryType) -> bool {
         self.push_back_internal(new, false)
     }
 
-    pub(crate) unsafe fn push_front(&mut self, new: &G::EntryType) -> bool {
+    pub unsafe fn push_front(&mut self, new: &G::EntryType) -> bool {
         self.push_back_internal(new, true)
     }
 
@@ -232,7 +228,7 @@ impl<G: GetLinks> RawList<G> {
     ///
     /// Callers must ensure that `data` is either on this list or in no list. It being on another
     /// list leads to memory unsafety.
-    pub(crate) unsafe fn remove(&mut self, data: &G::EntryType) -> bool {
+    pub unsafe fn remove(&mut self, data: &G::EntryType) -> bool {
         self.remove_internal(data)
     }
 
@@ -244,7 +240,7 @@ impl<G: GetLinks> RawList<G> {
     }
 
     /// Get and Remove the first element of the list.
-    pub(crate) fn pop_front(&mut self) -> Option<NonNull<G::EntryType>> {
+    pub fn pop_front(&mut self) -> Option<NonNull<G::EntryType>> {
         self.pop_front_internal()
     }
 
@@ -270,7 +266,7 @@ impl<G: GetLinks> RawList<G> {
     }
 
     /// Returns a mut cursor starting on the first element of the list.
-    pub(crate) fn cursor_front_mut(&mut self) -> CursorMut<'_, G> {
+    pub fn cursor_front_mut(&mut self) -> CursorMut<'_, G> {
         CursorMut::new(self, self.front())
     }
 }
@@ -361,7 +357,7 @@ impl<'a, G: GetLinks> Cursor<'a, G> {
     }
 }
 
-pub(crate) struct CursorMut<'a, G: GetLinks> {
+pub struct CursorMut<'a, G: GetLinks> {
     cursor: CommonCursor<G>,
     list: &'a mut RawList<G>,
 }
@@ -374,42 +370,42 @@ impl<'a, G: GetLinks> CursorMut<'a, G> {
         }
     }
 
-    pub(crate) fn current(&mut self) -> Option<&mut G::EntryType> {
+    pub fn current(&mut self) -> Option<&mut G::EntryType> {
         let cur = self.cursor.cur?;
         // SAFETY: Objects must be kept alive while on the list.
         Some(unsafe { &mut *cur.as_ptr() })
     }
 
     /// Removes the entry the cursor is pointing to and advances the cursor to the next entry. It
     /// returns a raw pointer to the removed element (if one is removed).
-    pub(crate) fn remove_current(&mut self) -> Option<NonNull<G::EntryType>> {
+    pub fn remove_current(&mut self) -> Option<NonNull<G::EntryType>> {
         let entry = self.cursor.cur?;
         self.cursor.move_next(self.list);
         // SAFETY: The entry is on the list as we just got it from there and it cannot change.
         unsafe { self.list.remove(entry.as_ref()) };
         Some(entry)
     }
 
-    pub(crate) fn peek_next(&mut self) -> Option<&mut G::EntryType> {
+    pub fn peek_next(&mut self) -> Option<&mut G::EntryType> {
         let mut new = CommonCursor::new(self.cursor.cur);
         new.move_next(self.list);
         // SAFETY: Objects must be kept alive while on the list.
         Some(unsafe { &mut *new.cur?.as_ptr() })
     }
 
-    pub(crate) fn peek_prev(&mut self) -> Option<&mut G::EntryType> {
+    pub fn peek_prev(&mut self) -> Option<&mut G::EntryType> {
         let mut new = CommonCursor::new(self.cursor.cur);
         new.move_prev(self.list);
         // SAFETY: Objects must be kept alive while on the list.
         Some(unsafe { &mut *new.cur?.as_ptr() })
     }
 
-    pub(crate) fn move_next(&mut self) {
+    pub fn move_next(&mut self) {
         self.cursor.move_next(self.list);
     }
 
     #[allow(dead_code)]
-    pub(crate) fn move_prev(&mut self) {
+    pub fn move_prev(&mut self) {
         self.cursor.move_prev(self.list);
     }
 }
@@ -423,7 +419,7 @@ impl<'a, G: GetLinks> iter::IntoIterator for &'a RawList<G> {
 }
 
 /// An iterator for the linked list.
-pub(crate) struct Iterator<'a, G: GetLinks> {
+pub struct Iterator<'a, G: GetLinks> {
     cursor_front: Cursor<'a, G>,
     cursor_back: Cursor<'a, G>,
 }