Switch to a no_std library

mr-adult · Oct 25, 2023 · 0ccd4f3 · 0ccd4f3
1 parent 3ad8d4a
commit 0ccd4f3
Show file tree

Hide file tree

Showing 28 changed files with 134 additions and 135 deletions.
diff --git a/Cargo.toml b/Cargo.toml
@@ -10,7 +10,7 @@ documentation = "https://docs.rs/tree_iterators_rs/latest/tree_iterators_rs/"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-streaming-iterator = "0.1.9"
+streaming-iterator = { version = "0.1.9", features = ["alloc"] }
 serde = { version = "1.0.189",  optional = true }
 serde_derive = { version = "1.0.189",  optional = true }
 

diff --git a/src/bfs_iterators/borrow.rs b/src/bfs_iterators/borrow.rs
@@ -1,4 +1,7 @@
-use std::collections::VecDeque;
+use alloc::{
+    collections::VecDeque, 
+    vec::Vec
+};
 use streaming_iterator::StreamingIterator;
 
 use crate::{

diff --git a/src/bfs_iterators/mod.rs b/src/bfs_iterators/mod.rs
@@ -5,7 +5,7 @@ pub mod borrow;
 macro_rules! bfs_next {
     ($get_value_and_children: ident) => {
         fn next(&mut self) -> Option<Self::Item> {
-            match std::mem::take(&mut self.root) {
+            match core::mem::take(&mut self.root) {
                 Some(root) => {
                     let (value, children) = root.$get_value_and_children();
                     match children {
@@ -96,7 +96,7 @@ macro_rules! bfs_advance_iterator {
                                             .push_back(Some(popped));
                                     }
                                     Some(mut value) => {
-                                        self.item_stack.push(std::mem::take(&mut value.value).unwrap());
+                                        self.item_stack.push(core::mem::take(&mut value.value).unwrap());
                                         let has_children = !value.children.is_none();
                                         self.traversal_stack.push(value);
                                         stack_len += 1;
@@ -249,5 +249,5 @@ pub(crate) use get_mut;
 #[derive(Debug, Default, Clone)]
 struct TreeNodeVecDeque<T> {
     value: Option<T>,
-    children: Option<std::collections::VecDeque<Option<Self>>>,
+    children: Option<alloc::collections::VecDeque<Option<Self>>>,
 }
diff --git a/src/bfs_iterators/mut_borrow.rs b/src/bfs_iterators/mut_borrow.rs
@@ -1,4 +1,7 @@
-use std::collections::VecDeque;
+use alloc::{
+    collections::VecDeque, 
+    vec::Vec
+};
 use streaming_iterator::{
     StreamingIterator, 
     StreamingIteratorMut

diff --git a/src/bfs_iterators/owned.rs b/src/bfs_iterators/owned.rs
@@ -1,4 +1,7 @@
-use std::collections::VecDeque;
+use alloc::{
+    collections::VecDeque, 
+    vec::Vec
+};
 use streaming_iterator::{
     StreamingIterator, 
     StreamingIteratorMut

diff --git a/src/dfs_inorder_iterators/borrow.rs b/src/dfs_inorder_iterators/borrow.rs
@@ -1,3 +1,4 @@
+use alloc::vec::Vec;
 use streaming_iterator::StreamingIterator;
 
 use crate::{

diff --git a/src/dfs_inorder_iterators/mut_borrow.rs b/src/dfs_inorder_iterators/mut_borrow.rs
@@ -1,3 +1,4 @@
+use alloc::vec::Vec;
 use streaming_iterator::{
     StreamingIterator,
     StreamingIteratorMut

diff --git a/src/dfs_inorder_iterators/owned.rs b/src/dfs_inorder_iterators/owned.rs
@@ -1,3 +1,4 @@
+use alloc::vec::Vec;
 use crate::{
     prelude::OwnedBinaryTreeNode, 
     leaves_iterators::depth_first::owned::OwnedBinaryLeavesIterator,

diff --git a/src/dfs_postorder_iterators/borrow.rs b/src/dfs_postorder_iterators/borrow.rs
@@ -1,3 +1,4 @@
+use alloc::vec::Vec;
 use streaming_iterator::StreamingIterator;
 use crate::{
     prelude::{

diff --git a/src/dfs_postorder_iterators/mod.rs b/src/dfs_postorder_iterators/mod.rs
@@ -6,7 +6,7 @@ macro_rules! dfs_postorder_next {
     ($get_value_and_children: ident) => {
         fn next(&mut self) -> Option<Self::Item> {
             loop {
-                match std::mem::take(&mut self.root) {
+                match core::mem::take(&mut self.root) {
                     Some(next) => {
                         let (value, children) = next.$get_value_and_children();
                         match children {
@@ -53,7 +53,7 @@ macro_rules! postorder_streaming_iterator_impl {
         fn advance(&mut self) {
             let mut is_first_iteration = true;
             loop {
-                match std::mem::take(&mut self.root) {
+                match core::mem::take(&mut self.root) {
                     Some(next) => {
                         let (value, children) = next.$get_value_and_children();
                         match children {

diff --git a/src/dfs_postorder_iterators/mut_borrow.rs b/src/dfs_postorder_iterators/mut_borrow.rs
@@ -1,3 +1,4 @@
+use alloc::vec::Vec;
 use streaming_iterator::{
     StreamingIterator,
     StreamingIteratorMut

diff --git a/src/dfs_postorder_iterators/owned.rs b/src/dfs_postorder_iterators/owned.rs
@@ -1,3 +1,4 @@
+use alloc::vec::Vec;
 use streaming_iterator::{
     StreamingIterator,
     StreamingIteratorMut

diff --git a/src/dfs_preorder_iterators/borrow.rs b/src/dfs_preorder_iterators/borrow.rs
@@ -1,3 +1,4 @@
+use alloc::vec::Vec;
 use streaming_iterator::StreamingIterator;
 use crate::{
     prelude::{

diff --git a/src/dfs_preorder_iterators/mod.rs b/src/dfs_preorder_iterators/mod.rs
@@ -5,7 +5,7 @@ pub mod borrow;
 macro_rules! dfs_preorder_next {
     ($get_value_and_children: ident) => {
         fn next(&mut self) -> Option<Self::Item> {
-            match std::mem::take(&mut self.root) {
+            match core::mem::take(&mut self.root) {
                 Some(next) => {
                     let (value, children) = next.$get_value_and_children();
                     match children {
@@ -60,7 +60,7 @@ macro_rules! dfs_preorder_next {
 macro_rules! advance_dfs {
     ($get_value_and_children: ident) => {
         fn advance_dfs(&mut self) {
-            match std::mem::take(&mut self.root) {
+            match core::mem::take(&mut self.root) {
                 Some(next) => {
                     let (value, children) = next.$get_value_and_children();
                     match children {

diff --git a/src/dfs_preorder_iterators/mut_borrow.rs b/src/dfs_preorder_iterators/mut_borrow.rs
@@ -1,3 +1,4 @@
+use alloc::vec::Vec;
 use streaming_iterator::{
     StreamingIterator,
     StreamingIteratorMut

diff --git a/src/dfs_preorder_iterators/owned.rs b/src/dfs_preorder_iterators/owned.rs
@@ -1,3 +1,4 @@
+use alloc::vec::Vec;
 use streaming_iterator::{
     StreamingIterator,
     StreamingIteratorMut

diff --git a/src/examples.rs b/src/examples.rs
@@ -1,8 +1,13 @@
 #[cfg(test)]
-pub (crate) mod tests {
-    use super::{create_example_binary_tree, create_example_tree};
+pub mod tests {
+    extern crate std;
+    use std::println;
+    use alloc::string::String;
     use super::super::prelude::*;
-    use std::collections::VecDeque;
+    use alloc::collections::VecDeque;
+    use alloc::boxed::Box;
+    use alloc::vec;
+    use super::{create_example_binary_tree, create_example_tree};
 
     #[test]
     fn bfs_example() {
@@ -258,6 +263,8 @@ pub (crate) mod tests {
         println!("{}", result);
     }
 
+    use alloc::string::ToString;
+    use alloc::vec::Vec;
     use streaming_iterator::StreamingIterator;
 
     #[test]
@@ -339,9 +346,68 @@ pub (crate) mod tests {
         // result: 0 2 6
         println!("{}", result);
     }
+
+    mod custom_implemenation {
+        use crate::prelude::*;
+        use alloc::collections::LinkedList;
+
+        struct LLTreeNode<T> {
+            value: T,
+            children: LinkedList<LLTreeNode<T>>
+        }
+
+        use alloc::collections::linked_list::IntoIter;
+
+        impl<T> OwnedTreeNode for LLTreeNode<T> {
+            type OwnedValue = T;
+            type OwnedChildren = IntoIter<LLTreeNode<T>>;
+
+            fn get_value_and_children(self) -> (Self::OwnedValue, Option<Self::OwnedChildren>) {
+                (
+                    self.value,
+                    Some(self.children.into_iter())
+                )
+            }
+        }
+
+        use alloc::collections::linked_list::IterMut;
+
+        impl<'a, T> MutBorrowedTreeNode<'a> for LLTreeNode<T> 
+            where Self: 'a {
+
+            type MutBorrowedValue = &'a mut T;
+            type MutBorrowedChildren = IterMut<'a, LLTreeNode<T>>;
+
+            fn get_value_and_children_iter_mut(&'a mut self) -> (Self::MutBorrowedValue, Option<Self::MutBorrowedChildren>) {
+                (
+                    &mut self.value,
+                    Some(self.children.iter_mut())
+                )
+            }
+        }
+
+        use alloc::collections::linked_list::Iter;
+
+        impl<'a, T> BorrowedTreeNode<'a> for LLTreeNode<T> 
+            where Self: 'a {
+
+            type BorrowedValue = &'a T;
+            type BorrowedChildren = Iter<'a, LLTreeNode<T>>;
+
+            fn get_value_and_children_iter(&'a self) -> (Self::BorrowedValue, Option<Self::BorrowedChildren>) {
+                (
+                    &self.value,
+                    Some(self.children.iter())
+                )
+            }
+        }
+    }
+
+
 }
 
 use crate::prelude::*;
+use alloc::{boxed::Box, vec};
 
 pub fn create_example_binary_tree() -> BinaryTreeNode<usize> {
     BinaryTreeNode { 
@@ -483,61 +549,4 @@ pub fn create_example_tree() -> TreeNode<usize> {
             }
         ])
     }
-}
-
-mod custom_implemenation {
-    use crate::prelude::*;
-    use std::collections::LinkedList;
-
-    struct LLTreeNode<T> {
-        value: T,
-        children: LinkedList<LLTreeNode<T>>
-    }
-
-    use std::collections::linked_list::IntoIter;
-
-    impl<T> OwnedTreeNode for LLTreeNode<T> {
-        type OwnedValue = T;
-        type OwnedChildren = IntoIter<LLTreeNode<T>>;
-
-        fn get_value_and_children(self) -> (Self::OwnedValue, Option<Self::OwnedChildren>) {
-            (
-                self.value,
-                Some(self.children.into_iter())
-            )
-        }
-    }
-
-    use std::collections::linked_list::IterMut;
-
-    impl<'a, T> MutBorrowedTreeNode<'a> for LLTreeNode<T> 
-        where Self: 'a {
-
-        type MutBorrowedValue = &'a mut T;
-        type MutBorrowedChildren = IterMut<'a, LLTreeNode<T>>;
-
-        fn get_value_and_children_iter_mut(&'a mut self) -> (Self::MutBorrowedValue, Option<Self::MutBorrowedChildren>) {
-            (
-                &mut self.value,
-                Some(self.children.iter_mut())
-            )
-        }
-    }
-
-    use std::collections::linked_list::Iter;
-
-    impl<'a, T> BorrowedTreeNode<'a> for LLTreeNode<T> 
-        where Self: 'a {
-
-        type BorrowedValue = &'a T;
-        type BorrowedChildren = Iter<'a, LLTreeNode<T>>;
-
-        fn get_value_and_children_iter(&'a self) -> (Self::BorrowedValue, Option<Self::BorrowedChildren>) {
-            (
-                &self.value,
-                Some(self.children.iter())
-            )
-        }
-    }
-}
-
+}
diff --git a/src/leaves_iterators/breadth_first/borrow.rs b/src/leaves_iterators/breadth_first/borrow.rs
@@ -1,12 +1,12 @@
-use std::collections::VecDeque;
+use alloc::collections::VecDeque;
 
 use crate::prelude::{
     BorrowedTreeNode, 
     BinaryChildren, 
     BorrowedBinaryTreeNode
 };
 
-use crate::make_peekable_iterator::MakePeekableIterator;
+use core::iter::Peekable;
 
 use super::{
     bfs_next, 
@@ -18,7 +18,7 @@ pub struct BorrowedLeavesIterator<'a, Node>
 
     pub (crate) root: Option<&'a Node>,
     pub (crate) old_traversal_queue: VecDeque<Node::BorrowedChildren>,
-    pub (crate) new_traversal_queue: VecDeque<MakePeekableIterator<Node::BorrowedChildren>>,
+    pub (crate) new_traversal_queue: VecDeque<Peekable<Node::BorrowedChildren>>,
 }
 
 impl<'a, Node> BorrowedLeavesIterator<'a, Node> 
@@ -39,7 +39,7 @@ pub struct BorrowedBinaryLeavesIterator<'a, Node>
 
     pub (crate) root: Option<&'a Node>,
     pub (crate) old_traversal_queue: VecDeque<BinaryChildren<&'a Node>>,
-    pub (crate) new_traversal_queue: VecDeque<MakePeekableIterator<BinaryChildren<&'a Node>>>,
+    pub (crate) new_traversal_queue: VecDeque<Peekable<BinaryChildren<&'a Node>>>,
 }
 
 impl<'a, Node> BorrowedBinaryLeavesIterator<'a, Node> 

diff --git a/src/leaves_iterators/breadth_first/mod.rs b/src/leaves_iterators/breadth_first/mod.rs
@@ -5,15 +5,15 @@ pub mod borrow;
 macro_rules! bfs_next {
     ($get_value_and_children: ident, $value_type: ty) => {
         fn bfs_next(&mut self) -> Option<(bool, $value_type)> {
-            match std::mem::take(&mut self.root) {
+            match core::mem::take(&mut self.root) {
                 Some(root) => {
                     let (value, children) = root.$get_value_and_children();
 
                     let has_children;
                     match children {
                         None => { has_children = false; }
                         Some(children) => {
-                            let mut peekable = MakePeekableIterator::new(children);
+                            let mut peekable = children.peekable();
                             has_children = peekable.peek().is_some();
                             self.new_traversal_queue.push_back(peekable);
                         }
@@ -41,7 +41,7 @@ macro_rules! bfs_next {
                                                 match children {
                                                     None => { has_children = false; }
                                                     Some(children) => { 
-                                                        let mut peekable = MakePeekableIterator::new(children);
+                                                        let mut peekable = children.peekable();
                                                         has_children = peekable.peek().is_some();
                                                         self.new_traversal_queue.push_back(peekable);
                                                     }
@@ -66,7 +66,7 @@ macro_rules! bfs_next {
                                         match children {
                                             None => { has_children = false; }
                                             Some(children) => { 
-                                                let mut peekable = MakePeekableIterator::new(children);
+                                                let mut peekable = children.peekable();
                                                 has_children = peekable.peek().is_some();
                                                 self.new_traversal_queue.push_back(peekable);
                                             }