From 9b45d69248f349791e0a692c343fb1e97bbc545d Mon Sep 17 00:00:00 2001 From: orxfun Date: Wed, 12 Feb 2025 10:54:38 +0100 Subject: [PATCH 1/7] parallel feature and optional dependencies are defined --- Cargo.toml | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index 864e06d..68eb66b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -17,6 +17,8 @@ orx-selfref-col = "2.7" orx-self-or = "1.1.1" orx-iterable = "1.2.0" serde = { version = "1.0.217", optional = true, default-features = false } +orx-concurrent-iter = { version = "1.30.0", optional = true } +orx-parallel = { version = "1.16.0", optional = true } [dev-dependencies] test-case = { version = "3.3.1", default-features = false } @@ -25,6 +27,7 @@ serde_json = { version = "1.0.138", default-features = false, features = [ ] } [features] -default = [] +default = ["parallel"] std = [] serde = ["dep:serde"] +parallel = ["std", "orx-concurrent-iter", "orx-parallel"] From c9f0d9b6a1ddf02bc7ea1083006ce5ace6528ffa Mon Sep 17 00:00:00 2001 From: orxfun Date: Wed, 12 Feb 2025 10:54:52 +0100 Subject: [PATCH 2/7] parallelization mod init --- src/lib.rs | 3 +++ src/parallelization/arbitrary_iter.rs | 1 + src/parallelization/mod.rs | 1 + 3 files changed, 5 insertions(+) create mode 100644 src/parallelization/arbitrary_iter.rs create mode 100644 src/parallelization/mod.rs diff --git a/src/lib.rs b/src/lib.rs index 545e695..7e028b3 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -29,6 +29,9 @@ pub mod memory; /// Module defining the choice over the pinned storage of the tree. pub mod pinned_storage; +#[cfg(feature = "parallel")] +mod parallelization; + mod aliases; mod common_traits; mod dary; diff --git a/src/parallelization/arbitrary_iter.rs b/src/parallelization/arbitrary_iter.rs new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/src/parallelization/arbitrary_iter.rs @@ -0,0 +1 @@ + diff --git a/src/parallelization/mod.rs b/src/parallelization/mod.rs new file mode 100644 index 0000000..b5a7594 --- /dev/null +++ b/src/parallelization/mod.rs @@ -0,0 +1 @@ +mod arbitrary_iter; From 4c37e3981609cc298d53d4ea9680f734964d54e8 Mon Sep 17 00:00:00 2001 From: orxfun Date: Wed, 12 Feb 2025 10:56:13 +0100 Subject: [PATCH 3/7] wip --- src/parallelization/arbitrary_iter.rs | 1 - src/parallelization/into_con_iter.rs | 9 +++++++++ src/parallelization/mod.rs | 2 +- 3 files changed, 10 insertions(+), 2 deletions(-) delete mode 100644 src/parallelization/arbitrary_iter.rs create mode 100644 src/parallelization/into_con_iter.rs diff --git a/src/parallelization/arbitrary_iter.rs b/src/parallelization/arbitrary_iter.rs deleted file mode 100644 index 8b13789..0000000 --- a/src/parallelization/arbitrary_iter.rs +++ /dev/null @@ -1 +0,0 @@ - diff --git a/src/parallelization/into_con_iter.rs b/src/parallelization/into_con_iter.rs new file mode 100644 index 0000000..7be984b --- /dev/null +++ b/src/parallelization/into_con_iter.rs @@ -0,0 +1,9 @@ +use crate::{aliases::N, TreeVariant}; + +pub struct TreeIntoConIter +where + V: TreeVariant, + I: Iterator>, +{ + iter: I, +} diff --git a/src/parallelization/mod.rs b/src/parallelization/mod.rs index b5a7594..6601313 100644 --- a/src/parallelization/mod.rs +++ b/src/parallelization/mod.rs @@ -1 +1 @@ -mod arbitrary_iter; +mod into_con_iter; From df6f236477b66f8f01ab13ba8e88325661ef52dc Mon Sep 17 00:00:00 2001 From: orxfun Date: Fri, 4 Apr 2025 19:47:40 +0200 Subject: [PATCH 4/7] migration to 2024edition --- Cargo.toml | 15 ++++++--------- src/lib.rs | 5 +---- src/parallelization/into_con_iter.rs | 9 --------- src/parallelization/mod.rs | 1 - 4 files changed, 7 insertions(+), 23 deletions(-) delete mode 100644 src/parallelization/into_con_iter.rs delete mode 100644 src/parallelization/mod.rs diff --git a/Cargo.toml b/Cargo.toml index 68eb66b..527806d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "orx-tree" -version = "1.3.0" -edition = "2021" +version = "2.0.0" +edition = "2024" authors = ["orxfun "] description = "A beautiful tree 🌳 with convenient and efficient growth, mutation and traversal features." license = "MIT OR Apache-2.0" @@ -11,14 +11,12 @@ categories = ["data-structures", "algorithms", "rust-patterns", "no-std"] [dependencies] orx-pseudo-default = { version = "2.0.0", default-features = false } -orx-pinned-vec = "3.15" -orx-split-vec = "3.15" -orx-selfref-col = "2.7" +orx-pinned-vec = { path = "../orx-pinned-vec" } +orx-split-vec = { path = "../orx-split-vec" } +orx-selfref-col = { path = "../orx-selfref-col" } orx-self-or = "1.1.1" orx-iterable = "1.2.0" serde = { version = "1.0.217", optional = true, default-features = false } -orx-concurrent-iter = { version = "1.30.0", optional = true } -orx-parallel = { version = "1.16.0", optional = true } [dev-dependencies] test-case = { version = "3.3.1", default-features = false } @@ -27,7 +25,6 @@ serde_json = { version = "1.0.138", default-features = false, features = [ ] } [features] -default = ["parallel"] +default = [] std = [] serde = ["dep:serde"] -parallel = ["std", "orx-concurrent-iter", "orx-parallel"] diff --git a/src/lib.rs b/src/lib.rs index 7e028b3..7dd5613 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -29,9 +29,6 @@ pub mod memory; /// Module defining the choice over the pinned storage of the tree. pub mod pinned_storage; -#[cfg(feature = "parallel")] -mod parallelization; - mod aliases; mod common_traits; mod dary; @@ -48,11 +45,11 @@ mod tree_variant; pub use common_traits::{DepthFirstSequence, DepthFirstSequenceError}; pub use dary::{Binary, BinaryNode, BinaryTree, Dary, DaryNode, DaryTree}; +pub use r#dyn::{Dyn, DynNode, DynTree}; pub use memory::{Auto, AutoWithThreshold, Lazy, MemoryPolicy}; pub use node::Node; pub use node_mut::{NodeMut, NodeMutDown, NodeMutOrientation, NodeMutUpAndDown, Side}; pub use node_ref::NodeRef; -pub use r#dyn::{Dyn, DynNode, DynTree}; pub use subtrees::SubTree; pub use traversal::{Bfs, Dfs, PostOrder, Traversal, Traverser}; pub use tree::Tree; diff --git a/src/parallelization/into_con_iter.rs b/src/parallelization/into_con_iter.rs deleted file mode 100644 index 7be984b..0000000 --- a/src/parallelization/into_con_iter.rs +++ /dev/null @@ -1,9 +0,0 @@ -use crate::{aliases::N, TreeVariant}; - -pub struct TreeIntoConIter -where - V: TreeVariant, - I: Iterator>, -{ - iter: I, -} diff --git a/src/parallelization/mod.rs b/src/parallelization/mod.rs deleted file mode 100644 index 6601313..0000000 --- a/src/parallelization/mod.rs +++ /dev/null @@ -1 +0,0 @@ -mod into_con_iter; From ac9a8152f9e8320b7d6d202f32201f4d2989646f Mon Sep 17 00:00:00 2001 From: orxfun Date: Fri, 11 Apr 2025 10:24:49 +0200 Subject: [PATCH 5/7] dependencies upgraded --- Cargo.toml | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 527806d..808538b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "orx-tree" -version = "2.0.0" +version = "1.4.0" edition = "2024" authors = ["orxfun "] description = "A beautiful tree 🌳 with convenient and efficient growth, mutation and traversal features." @@ -10,17 +10,18 @@ keywords = ["tree", "data-structures", "traversal", "traverse", "binarytree"] categories = ["data-structures", "algorithms", "rust-patterns", "no-std"] [dependencies] -orx-pseudo-default = { version = "2.0.0", default-features = false } -orx-pinned-vec = { path = "../orx-pinned-vec" } -orx-split-vec = { path = "../orx-split-vec" } -orx-selfref-col = { path = "../orx-selfref-col" } -orx-self-or = "1.1.1" -orx-iterable = "1.2.0" -serde = { version = "1.0.217", optional = true, default-features = false } +orx-iterable = { version = "1.3.0", default-features = false } +orx-pseudo-default = { version = "2.1.0", default-features = false } +orx-pinned-vec = "3.16.0" +orx-split-vec = "3.16.0" +orx-selfref-col = "2.8.0" +orx-self-or = "1.2.0" +serde = { version = "1.0.219", optional = true, default-features = false } + [dev-dependencies] test-case = { version = "3.3.1", default-features = false } -serde_json = { version = "1.0.138", default-features = false, features = [ +serde_json = { version = "1.0.140", default-features = false, features = [ "std", ] } From bb0a5db3885fa1d169723b8ede7a910e8aeb4922 Mon Sep 17 00:00:00 2001 From: orxfun Date: Fri, 11 Apr 2025 10:27:18 +0200 Subject: [PATCH 6/7] Create ci.yml --- .github/workflows/ci.yml | 58 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 58 insertions(+) create mode 100644 .github/workflows/ci.yml diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..4cd3ad4 --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,58 @@ +name: Rust + +on: + push: + branches: [ "main" ] + pull_request: + branches: [ "main" ] + +env: + CARGO_TERM_COLOR: always + +jobs: + build: + + runs-on: ubuntu-latest + strategy: + matrix: + toolchain: ["stable"] + + steps: + - uses: actions/checkout@v4 + + - name: Install toolchain + uses: dtolnay/rust-toolchain@master + with: + toolchain: ${{ matrix.toolchain }} + + - name: Install 32bit target + run: rustup target add i686-unknown-linux-musl + - name: Install wasm target + run: rustup target add wasm32v1-none + - name: Install miri + run: rustup component add --toolchain nightly-x86_64-unknown-linux-gnu miri + - name: Install no-std-check + run: cargo install cargo-no-std-check + + - name: Build + run: cargo build --features serde --verbose + - name: Build-32bit + run: cargo build --features serde --verbose --target i686-unknown-linux-musl + - name: Build-wasm + run: cargo build --features serde --verbose --target wasm32v1-none + + - name: Test + run: cargo test --features serde --verbose + - name: Test-32bit + run: cargo test --features serde --verbose --target i686-unknown-linux-musl + - name: Check-wasm + run: cargo check --features serde --verbose --target wasm32v1-none + + - name: Clippy + run: cargo clippy --features serde -- -D warnings --verbose + + - name: Miri + run: cargo +nightly miri test --features serde --verbose + + - name: NoStd + run: cargo +nightly no-std-check --features serde From 84f3f74761c8e4f411696d6aa4752c1740287c17 Mon Sep 17 00:00:00 2001 From: orxfun Date: Fri, 11 Apr 2025 10:29:14 +0200 Subject: [PATCH 7/7] fmt --- src/common_traits/clone.rs | 2 +- src/common_traits/debug.rs | 4 ++-- src/common_traits/display.rs | 4 ++-- src/common_traits/eq.rs | 2 +- src/common_traits/equality.rs | 4 ++-- src/common_traits/from_depth_first_iter.rs | 2 +- src/common_traits/into_iterator.rs | 2 +- src/common_traits/serde.rs | 14 ++++++++++---- src/dary/aliases.rs | 2 +- src/dyn/aliases.rs | 2 +- src/iter/children_mut.rs | 2 +- src/memory.rs | 2 +- src/node.rs | 2 +- src/node_mut.rs | 13 ++++++++----- src/node_ref.rs | 4 ++-- src/pinned_storage.rs | 2 +- src/subtrees/cloned_subtree.rs | 2 +- src/subtrees/copied_subtree.rs | 2 +- src/subtrees/mod.rs | 2 +- src/subtrees/moved_subtree.rs | 4 ++-- src/subtrees/subtree.rs | 4 ++-- src/subtrees/tree_as_subtree.rs | 2 +- src/subtrees_within/cloned_subtree.rs | 2 +- src/subtrees_within/copied_subtree.rs | 2 +- src/subtrees_within/moved_subtree.rs | 12 +++++++----- src/subtrees_within/subtree_within.rs | 4 ++-- src/traversal/breadth_first/into_iter.rs | 4 ++-- src/traversal/breadth_first/iter_mut.rs | 2 +- src/traversal/breadth_first/iter_ptr.rs | 2 +- src/traversal/breadth_first/iter_ref.rs | 2 +- src/traversal/breadth_first/queue.rs | 2 +- src/traversal/breadth_first/tests/bfs_into_iter.rs | 2 +- src/traversal/breadth_first/tests/bfs_iter_mut.rs | 6 ++++-- src/traversal/breadth_first/tests/bfs_iter_ptr.rs | 2 +- src/traversal/breadth_first/tests/bfs_iter_ref.rs | 2 +- src/traversal/breadth_first/tests/bfs_traverser.rs | 4 ++-- .../breadth_first/tests/bfs_traverser_mut.rs | 8 +++++--- src/traversal/breadth_first/traverser_core.rs | 8 ++++---- src/traversal/depth_first/into_iter.rs | 4 ++-- src/traversal/depth_first/iter_mut.rs | 2 +- src/traversal/depth_first/iter_ptr.rs | 2 +- src/traversal/depth_first/iter_ref.rs | 2 +- src/traversal/depth_first/stack.rs | 2 +- src/traversal/depth_first/tests/dfs_into_iter.rs | 2 +- src/traversal/depth_first/tests/dfs_iter_mut.rs | 6 ++++-- src/traversal/depth_first/tests/dfs_iter_ptr.rs | 2 +- src/traversal/depth_first/tests/dfs_iter_ref.rs | 2 +- src/traversal/depth_first/tests/dfs_traverser.rs | 4 ++-- .../depth_first/tests/dfs_traverser_mut.rs | 8 +++++--- src/traversal/depth_first/traverser_core.rs | 8 ++++---- src/traversal/enumeration.rs | 2 +- src/traversal/node_item.rs | 4 ++-- src/traversal/node_item_mut.rs | 2 +- src/traversal/over_mut.rs | 2 +- src/traversal/post_order/into_iter.rs | 2 +- src/traversal/post_order/iter_mut.rs | 2 +- src/traversal/post_order/iter_ptr.rs | 2 +- src/traversal/post_order/iter_ref.rs | 2 +- src/traversal/post_order/post_enumeration.rs | 2 +- .../post_order/tests/post_order_iter_into.rs | 2 +- .../post_order/tests/post_order_iter_mut.rs | 6 ++++-- .../post_order/tests/post_order_iter_ptr.rs | 2 +- .../post_order/tests/post_order_iter_ref.rs | 2 +- .../post_order/tests/post_order_traverser.rs | 4 ++-- .../post_order/tests/post_order_traverser_mut.rs | 8 +++++--- src/traversal/post_order/traverser.rs | 2 +- src/traversal/post_order/traverser_core.rs | 8 ++++---- src/traversal/traverser.rs | 2 +- src/traversal/traverser_core.rs | 6 +++--- src/tree.rs | 2 +- src/tree_node_idx.rs | 2 +- src/tree_variant.rs | 4 ++-- 72 files changed, 140 insertions(+), 117 deletions(-) diff --git a/src/common_traits/clone.rs b/src/common_traits/clone.rs index 08181a6..c38b5f6 100644 --- a/src/common_traits/clone.rs +++ b/src/common_traits/clone.rs @@ -1,4 +1,4 @@ -use crate::{memory::MemoryPolicy, pinned_storage::PinnedStorage, NodeRef, Tree, TreeVariant}; +use crate::{NodeRef, Tree, TreeVariant, memory::MemoryPolicy, pinned_storage::PinnedStorage}; impl Clone for Tree where diff --git a/src/common_traits/debug.rs b/src/common_traits/debug.rs index 51a3472..f997362 100644 --- a/src/common_traits/debug.rs +++ b/src/common_traits/debug.rs @@ -1,6 +1,6 @@ use crate::{ - memory::MemoryPolicy, pinned_storage::PinnedStorage, traversal::traverser_core::TraverserCore, - Node, NodeMut, NodeRef, Traversal, Traverser, Tree, TreeVariant, + Node, NodeMut, NodeRef, Traversal, Traverser, Tree, TreeVariant, memory::MemoryPolicy, + pinned_storage::PinnedStorage, traversal::traverser_core::TraverserCore, }; use core::fmt::Debug; diff --git a/src/common_traits/display.rs b/src/common_traits/display.rs index d778532..5f7c33f 100644 --- a/src/common_traits/display.rs +++ b/src/common_traits/display.rs @@ -1,6 +1,6 @@ use crate::{ - pinned_storage::PinnedStorage, traversal::OverDepthSiblingIdxNode, Dfs, MemoryPolicy, Node, - NodeMut, NodeRef, Traversal, Traverser, Tree, TreeVariant, + Dfs, MemoryPolicy, Node, NodeMut, NodeRef, Traversal, Traverser, Tree, TreeVariant, + pinned_storage::PinnedStorage, traversal::OverDepthSiblingIdxNode, }; use alloc::string::ToString; use alloc::vec::Vec; diff --git a/src/common_traits/eq.rs b/src/common_traits/eq.rs index b36a681..418d8b9 100644 --- a/src/common_traits/eq.rs +++ b/src/common_traits/eq.rs @@ -1,4 +1,4 @@ -use crate::{pinned_storage::PinnedStorage, Dfs, MemoryPolicy, NodeRef, Tree, TreeVariant}; +use crate::{Dfs, MemoryPolicy, NodeRef, Tree, TreeVariant, pinned_storage::PinnedStorage}; impl PartialEq> for Tree where diff --git a/src/common_traits/equality.rs b/src/common_traits/equality.rs index 69894a3..1faff32 100644 --- a/src/common_traits/equality.rs +++ b/src/common_traits/equality.rs @@ -1,6 +1,6 @@ use crate::{ - memory::MemoryPolicy, node_ref::NodeRefCore, pinned_storage::PinnedStorage, Node, NodeMut, - TreeVariant, + Node, NodeMut, TreeVariant, memory::MemoryPolicy, node_ref::NodeRefCore, + pinned_storage::PinnedStorage, }; impl PartialEq for Node<'_, V, M, P> diff --git a/src/common_traits/from_depth_first_iter.rs b/src/common_traits/from_depth_first_iter.rs index a66c7f6..33a608b 100644 --- a/src/common_traits/from_depth_first_iter.rs +++ b/src/common_traits/from_depth_first_iter.rs @@ -1,4 +1,4 @@ -use crate::{pinned_storage::PinnedStorage, MemoryPolicy, Tree, TreeVariant}; +use crate::{MemoryPolicy, Tree, TreeVariant, pinned_storage::PinnedStorage}; /// A depth first sequence is a representation of a tree in a linear storage of (depth, value) tuples. /// This is useful in collecting trees from iterators, (de)-serializing trees or converting its variant diff --git a/src/common_traits/into_iterator.rs b/src/common_traits/into_iterator.rs index 161b216..3c043d7 100644 --- a/src/common_traits/into_iterator.rs +++ b/src/common_traits/into_iterator.rs @@ -1,4 +1,4 @@ -use crate::{aliases::N, pinned_storage::PinnedStorage, MemoryPolicy, Tree, TreeVariant}; +use crate::{MemoryPolicy, Tree, TreeVariant, aliases::N, pinned_storage::PinnedStorage}; use core::iter::FusedIterator; use orx_iterable::{Collection, CollectionMut, Iterable}; diff --git a/src/common_traits/serde.rs b/src/common_traits/serde.rs index 12b3061..b6700bc 100644 --- a/src/common_traits/serde.rs +++ b/src/common_traits/serde.rs @@ -1,8 +1,8 @@ use crate::{ - pinned_storage::PinnedStorage, MemoryPolicy, NodeRef, Traversal, Traverser, Tree, TreeVariant, + MemoryPolicy, NodeRef, Traversal, Traverser, Tree, TreeVariant, pinned_storage::PinnedStorage, }; use core::marker::PhantomData; -use serde::{de::Visitor, ser::SerializeSeq, Deserialize, Serialize}; +use serde::{Deserialize, Serialize, de::Visitor, ser::SerializeSeq}; // Serialize @@ -104,7 +104,10 @@ where if let Some(x) = seq.next_element()? { let (depth, value): (usize, V::Item) = x; if depth != 0 { - return err(format!("First element of DepthFirstSequence (root of the tree) must have depth 0; however, received a depth of {}. Following is an example valid sequence of (depth, value) pairs: [[0, 0], [1, 1], [2, 3], [3, 6], [1, 2], [2, 4], [2, 5], [3, 7]].", depth)); + return err(format!( + "First element of DepthFirstSequence (root of the tree) must have depth 0; however, received a depth of {}. Following is an example valid sequence of (depth, value) pairs: [[0, 0], [1, 1], [2, 3], [3, 6], [1, 2], [2, 4], [2, 5], [3, 7]].", + depth + )); } tree.push_root(value); @@ -116,7 +119,10 @@ where match depth > current_depth { true => { if depth > current_depth + 1 { - return err(format!("Let d1 and d2 be two consecutive depths in the depth-first sequence. Then, (i) d2=d1+1, (ii) d2=d1 or (iii) d2d1+1 (d1={}, d2={}). Please see DepthFirstSequenceError documentation for details. Following is an example valid sequence of (depth, value) pairs: [[0, 0], [1, 1], [2, 3], [3, 6], [1, 2], [2, 4], [2, 5], [3, 7]].", current_depth, depth)); + return err(format!( + "Let d1 and d2 be two consecutive depths in the depth-first sequence. Then, (i) d2=d1+1, (ii) d2=d1 or (iii) d2d1+1 (d1={}, d2={}). Please see DepthFirstSequenceError documentation for details. Following is an example valid sequence of (depth, value) pairs: [[0, 0], [1, 1], [2, 3], [3, 6], [1, 2], [2, 4], [2, 5], [3, 7]].", + current_depth, depth + )); } } false => { diff --git a/src/dary/aliases.rs b/src/dary/aliases.rs index b2aa0e0..1f4ee4e 100644 --- a/src/dary/aliases.rs +++ b/src/dary/aliases.rs @@ -1,5 +1,5 @@ use super::Dary; -use crate::{memory::Auto, pinned_storage::SplitRecursive, Node, Tree}; +use crate::{Node, Tree, memory::Auto, pinned_storage::SplitRecursive}; /// A binary tree where each of the nodes might have at most 2 children. pub type Binary = Dary<2, T>; diff --git a/src/dyn/aliases.rs b/src/dyn/aliases.rs index 629f748..fa67497 100644 --- a/src/dyn/aliases.rs +++ b/src/dyn/aliases.rs @@ -1,5 +1,5 @@ use super::Dyn; -use crate::{memory::Auto, pinned_storage::SplitRecursive, Node, Tree}; +use crate::{Node, Tree, memory::Auto, pinned_storage::SplitRecursive}; /// A dynamic tree where each of the nodes might have any number of child nodes. /// diff --git a/src/iter/children_mut.rs b/src/iter/children_mut.rs index 85e80af..a2215b5 100644 --- a/src/iter/children_mut.rs +++ b/src/iter/children_mut.rs @@ -1,10 +1,10 @@ use crate::{ + NodeMut, TreeVariant, aliases::{Col, N}, memory::MemoryPolicy, node_mut::NodeMutDown, pinned_storage::PinnedStorage, tree_variant::RefsChildren, - NodeMut, TreeVariant, }; use orx_selfref_col::NodePtr; diff --git a/src/memory.rs b/src/memory.rs index 3cb4759..4bc7a38 100644 --- a/src/memory.rs +++ b/src/memory.rs @@ -1,4 +1,4 @@ -use crate::{pinned_storage::PinnedStorage, Tree, TreeVariant}; +use crate::{Tree, TreeVariant, pinned_storage::PinnedStorage}; use orx_selfref_col::{MemoryReclaimNever, MemoryReclaimOnThreshold, MemoryReclaimer, Utilization}; /// Trees use a pinned vector ([`PinnedVec`]) as its underlying storage. diff --git a/src/node.rs b/src/node.rs index fb0809c..033a43f 100644 --- a/src/node.rs +++ b/src/node.rs @@ -1,9 +1,9 @@ use crate::{ + TreeVariant, aliases::Col, memory::{Auto, MemoryPolicy}, node_ref::NodeRefCore, pinned_storage::{PinnedStorage, SplitRecursive}, - TreeVariant, }; use orx_selfref_col::NodePtr; diff --git a/src/node_mut.rs b/src/node_mut.rs index d32d79d..ac083d2 100644 --- a/src/node_mut.rs +++ b/src/node_mut.rs @@ -1,4 +1,5 @@ use crate::{ + NodeIdx, NodeRef, SubTree, Traverser, Tree, TreeVariant, aliases::{Col, N}, iter::ChildrenMutIter, memory::{Auto, MemoryPolicy}, @@ -7,14 +8,13 @@ use crate::{ subtrees::{MovedSubTree, SubTreeCore}, subtrees_within::SubTreeWithin, traversal::{ + OverData, OverMut, enumerations::Val, over_mut::{OverItemInto, OverItemMut}, post_order::iter_ptr::PostOrderIterPtr, - OverData, OverMut, }, tree_node_idx::INVALID_IDX_ERROR, tree_variant::RefsChildren, - NodeIdx, NodeRef, SubTree, Traverser, Tree, TreeVariant, }; use core::{fmt::Debug, marker::PhantomData}; use orx_selfref_col::{NodePtr, Refs}; @@ -1627,7 +1627,10 @@ where /// assert_eq!(bfs, [1, 4, 5, 3, 8, 6, 10, 11, 9]); /// ``` pub fn take_out(self) -> V::Item { - assert!(!self.is_root() || self.num_children() == 1, "If taken out node is the root, it must have only one child which will be the new root."); + assert!( + !self.is_root() || self.num_children() == 1, + "If taken out node is the root, it must have only one child which will be the new root." + ); let parent_ptr = self.parent_ptr(); let sibling_idx = self.sibling_idx(); @@ -1968,8 +1971,8 @@ where pub fn children_mut( &mut self, ) -> impl ExactSizeIterator> - + DoubleEndedIterator - + use<'_, 'a, V, M, P, MO> { + + DoubleEndedIterator + + use<'_, 'a, V, M, P, MO> { ChildrenMutIter::new(self.col, self.node_ptr.ptr()) } diff --git a/src/node_ref.rs b/src/node_ref.rs index 392d357..41289f1 100644 --- a/src/node_ref.rs +++ b/src/node_ref.rs @@ -1,18 +1,18 @@ use crate::{ + Dfs, Node, NodeIdx, Traverser, Tree, TreeVariant, aliases::{Col, N}, iter::AncestorsIterPtr, memory::MemoryPolicy, pinned_storage::PinnedStorage, subtrees::{ClonedSubTree, CopiedSubTree}, traversal::{ + Over, OverData, enumeration::Enumeration, enumerations::Val, over::{OverDepthPtr, OverItem}, traverser_core::TraverserCore, - Over, OverData, }, tree_variant::RefsChildren, - Dfs, Node, NodeIdx, Traverser, Tree, TreeVariant, }; use orx_selfref_col::{NodePtr, Refs}; diff --git a/src/pinned_storage.rs b/src/pinned_storage.rs index 359d72a..f5e90e6 100644 --- a/src/pinned_storage.rs +++ b/src/pinned_storage.rs @@ -1,4 +1,4 @@ -use crate::{aliases::N, TreeVariant}; +use crate::{TreeVariant, aliases::N}; use orx_split_vec::{PinnedVec, Recursive, SplitVec}; /// Trait defining the underlying pinned vector storage of the tree. diff --git a/src/subtrees/cloned_subtree.rs b/src/subtrees/cloned_subtree.rs index 4673264..a205a10 100644 --- a/src/subtrees/cloned_subtree.rs +++ b/src/subtrees/cloned_subtree.rs @@ -1,8 +1,8 @@ use super::subtree::sealed::SubTreeCore; use crate::{ + Dfs, MemoryPolicy, NodeRef, TreeVariant, pinned_storage::PinnedStorage, traversal::{over::OverDepthPtr, traverser_core::TraverserCore}, - Dfs, MemoryPolicy, NodeRef, TreeVariant, }; use core::marker::PhantomData; use orx_selfref_col::NodePtr; diff --git a/src/subtrees/copied_subtree.rs b/src/subtrees/copied_subtree.rs index 8bef93b..8ba9d3f 100644 --- a/src/subtrees/copied_subtree.rs +++ b/src/subtrees/copied_subtree.rs @@ -1,8 +1,8 @@ use super::subtree::sealed::SubTreeCore; use crate::{ + Dfs, MemoryPolicy, NodeRef, TreeVariant, pinned_storage::PinnedStorage, traversal::{over::OverDepthPtr, traverser_core::TraverserCore}, - Dfs, MemoryPolicy, NodeRef, TreeVariant, }; use core::marker::PhantomData; use orx_selfref_col::NodePtr; diff --git a/src/subtrees/mod.rs b/src/subtrees/mod.rs index e2bd16c..e52392e 100644 --- a/src/subtrees/mod.rs +++ b/src/subtrees/mod.rs @@ -7,5 +7,5 @@ mod tree_as_subtree; pub use cloned_subtree::ClonedSubTree; pub use copied_subtree::CopiedSubTree; pub use moved_subtree::MovedSubTree; -pub(crate) use subtree::sealed::SubTreeCore; pub use subtree::SubTree; +pub(crate) use subtree::sealed::SubTreeCore; diff --git a/src/subtrees/moved_subtree.rs b/src/subtrees/moved_subtree.rs index e3e8aba..e28e4f5 100644 --- a/src/subtrees/moved_subtree.rs +++ b/src/subtrees/moved_subtree.rs @@ -1,9 +1,9 @@ use super::subtree::sealed::SubTreeCore; use crate::{ + Dfs, MemoryPolicy, NodeMut, NodeMutOrientation, NodeRef, TreeVariant, node_ref::NodeRefCore, pinned_storage::PinnedStorage, - traversal::{traverser_core::TraverserCore, OverDepthData}, - Dfs, MemoryPolicy, NodeMut, NodeMutOrientation, NodeRef, TreeVariant, + traversal::{OverDepthData, traverser_core::TraverserCore}, }; use orx_selfref_col::NodePtr; diff --git a/src/subtrees/subtree.rs b/src/subtrees/subtree.rs index 749cfcb..35fec59 100644 --- a/src/subtrees/subtree.rs +++ b/src/subtrees/subtree.rs @@ -3,8 +3,8 @@ use crate::TreeVariant; pub(crate) mod sealed { use crate::{ - pinned_storage::PinnedStorage, DepthFirstSequence, MemoryPolicy, NodeIdx, NodeMut, - NodeMutOrientation, Tree, TreeVariant, + DepthFirstSequence, MemoryPolicy, NodeIdx, NodeMut, NodeMutOrientation, Tree, TreeVariant, + pinned_storage::PinnedStorage, }; use orx_selfref_col::NodePtr; diff --git a/src/subtrees/tree_as_subtree.rs b/src/subtrees/tree_as_subtree.rs index e8a1fbf..3db0286 100644 --- a/src/subtrees/tree_as_subtree.rs +++ b/src/subtrees/tree_as_subtree.rs @@ -1,9 +1,9 @@ use super::subtree::sealed::SubTreeCore; use crate::{ + Dfs, MemoryPolicy, Tree, TreeVariant, node_ref::NodeRefCore, pinned_storage::PinnedStorage, traversal::{over::OverDepthData, traverser_core::TraverserCore}, - Dfs, MemoryPolicy, Tree, TreeVariant, }; use orx_selfref_col::NodePtr; diff --git a/src/subtrees_within/cloned_subtree.rs b/src/subtrees_within/cloned_subtree.rs index 7ed3255..0335544 100644 --- a/src/subtrees_within/cloned_subtree.rs +++ b/src/subtrees_within/cloned_subtree.rs @@ -1,8 +1,8 @@ use super::subtree_within::sealed::SubTreeWithinCore; use crate::{ + Dfs, MemoryPolicy, NodeIdx, NodeMut, NodeMutOrientation, TreeVariant, pinned_storage::PinnedStorage, traversal::{over::OverDepthPtr, traverser_core::TraverserCore}, - Dfs, MemoryPolicy, NodeIdx, NodeMut, NodeMutOrientation, TreeVariant, }; pub struct ClonedSubTreeWithin diff --git a/src/subtrees_within/copied_subtree.rs b/src/subtrees_within/copied_subtree.rs index f805393..0add042 100644 --- a/src/subtrees_within/copied_subtree.rs +++ b/src/subtrees_within/copied_subtree.rs @@ -1,8 +1,8 @@ use super::subtree_within::sealed::SubTreeWithinCore; use crate::{ + Dfs, MemoryPolicy, NodeIdx, NodeMut, NodeMutOrientation, TreeVariant, pinned_storage::PinnedStorage, traversal::{over::OverDepthPtr, traverser_core::TraverserCore}, - Dfs, MemoryPolicy, NodeIdx, NodeMut, NodeMutOrientation, TreeVariant, }; pub struct CopiedSubTreeWithin diff --git a/src/subtrees_within/moved_subtree.rs b/src/subtrees_within/moved_subtree.rs index 4db8059..ad59abb 100644 --- a/src/subtrees_within/moved_subtree.rs +++ b/src/subtrees_within/moved_subtree.rs @@ -1,8 +1,8 @@ use super::subtree_within::sealed::SubTreeWithinCore; use crate::{ - iter::AncestorsIterPtr, node_ref::NodeRefCore, pinned_storage::PinnedStorage, - tree_node_idx::INVALID_IDX_ERROR, tree_variant::RefsChildren, MemoryPolicy, NodeIdx, NodeMut, - NodeMutOrientation, TreeVariant, + MemoryPolicy, NodeIdx, NodeMut, NodeMutOrientation, TreeVariant, iter::AncestorsIterPtr, + node_ref::NodeRefCore, pinned_storage::PinnedStorage, tree_node_idx::INVALID_IDX_ERROR, + tree_variant::RefsChildren, }; use orx_selfref_col::Refs; @@ -33,8 +33,10 @@ impl SubTreeWithinCore for MovedSubTreeWithin { .col() .try_get_ptr(&self.idx.0) .expect(INVALID_IDX_ERROR); - assert!(AncestorsIterPtr::new(root_ptr.clone(), ptr_parent.clone()).all(|x| x != ptr_child), - "Node to be moved as a child of this node (with the given child_idx) is an ancestor of this tree. Cannot perform the move."); + assert!( + AncestorsIterPtr::new(root_ptr.clone(), ptr_parent.clone()).all(|x| x != ptr_child), + "Node to be moved as a child of this node (with the given child_idx) is an ancestor of this tree. Cannot perform the move." + ); let node_child = unsafe { &mut *ptr_child.ptr_mut() }; diff --git a/src/subtrees_within/subtree_within.rs b/src/subtrees_within/subtree_within.rs index 1859d9f..3388162 100644 --- a/src/subtrees_within/subtree_within.rs +++ b/src/subtrees_within/subtree_within.rs @@ -2,8 +2,8 @@ use crate::TreeVariant; pub(crate) mod sealed { use crate::{ - pinned_storage::PinnedStorage, MemoryPolicy, NodeIdx, NodeMut, NodeMutOrientation, - TreeVariant, + MemoryPolicy, NodeIdx, NodeMut, NodeMutOrientation, TreeVariant, + pinned_storage::PinnedStorage, }; pub trait SubTreeWithinCore: Sized { diff --git a/src/traversal/breadth_first/into_iter.rs b/src/traversal/breadth_first/into_iter.rs index 1eb1690..33039b0 100644 --- a/src/traversal/breadth_first/into_iter.rs +++ b/src/traversal/breadth_first/into_iter.rs @@ -1,10 +1,10 @@ +use super::BreadthFirstEnumeration; use super::iter_ptr::BfsIterPtr; use super::queue::Item; -use super::BreadthFirstEnumeration; +use crate::TreeVariant; use crate::aliases::Col; use crate::memory::MemoryPolicy; use crate::pinned_storage::PinnedStorage; -use crate::TreeVariant; use alloc::collections::VecDeque; use orx_self_or::SoM; use orx_selfref_col::{NodePtr, Refs}; diff --git a/src/traversal/breadth_first/iter_mut.rs b/src/traversal/breadth_first/iter_mut.rs index 8168203..e8321ba 100644 --- a/src/traversal/breadth_first/iter_mut.rs +++ b/src/traversal/breadth_first/iter_mut.rs @@ -1,11 +1,11 @@ use super::bfs_enumeration::BreadthFirstEnumeration; use super::iter_ptr::BfsIterPtr; use super::queue::Item; +use crate::TreeVariant; use crate::aliases::Col; use crate::memory::MemoryPolicy; use crate::pinned_storage::PinnedStorage; use crate::traversal::node_item_mut::NodeItemMut; -use crate::TreeVariant; use alloc::collections::VecDeque; use core::marker::PhantomData; use orx_self_or::SoM; diff --git a/src/traversal/breadth_first/iter_ptr.rs b/src/traversal/breadth_first/iter_ptr.rs index 2a93f65..38e9b0c 100644 --- a/src/traversal/breadth_first/iter_ptr.rs +++ b/src/traversal/breadth_first/iter_ptr.rs @@ -1,7 +1,7 @@ use super::bfs_enumeration::BreadthFirstEnumeration; use super::queue::Item; -use crate::tree_variant::RefsChildren; use crate::TreeVariant; +use crate::tree_variant::RefsChildren; use alloc::collections::VecDeque; use core::marker::PhantomData; use orx_self_or::SoM; diff --git a/src/traversal/breadth_first/iter_ref.rs b/src/traversal/breadth_first/iter_ref.rs index 4d0152f..5c6537e 100644 --- a/src/traversal/breadth_first/iter_ref.rs +++ b/src/traversal/breadth_first/iter_ref.rs @@ -1,11 +1,11 @@ use super::bfs_enumeration::BreadthFirstEnumeration; use super::iter_ptr::BfsIterPtr; use super::queue::Item; +use crate::TreeVariant; use crate::aliases::Col; use crate::memory::MemoryPolicy; use crate::pinned_storage::PinnedStorage; use crate::traversal::node_item::NodeItem; -use crate::TreeVariant; use alloc::collections::VecDeque; use core::marker::PhantomData; use orx_self_or::SoM; diff --git a/src/traversal/breadth_first/queue.rs b/src/traversal/breadth_first/queue.rs index 21f3d3e..c960b62 100644 --- a/src/traversal/breadth_first/queue.rs +++ b/src/traversal/breadth_first/queue.rs @@ -1,4 +1,4 @@ -use crate::{traversal::enumeration::Enumeration, Dyn, TreeVariant}; +use crate::{Dyn, TreeVariant, traversal::enumeration::Enumeration}; use alloc::collections::VecDeque; use orx_selfref_col::NodePtr; diff --git a/src/traversal/breadth_first/tests/bfs_into_iter.rs b/src/traversal/breadth_first/tests/bfs_into_iter.rs index b512917..e0fd38a 100644 --- a/src/traversal/breadth_first/tests/bfs_into_iter.rs +++ b/src/traversal/breadth_first/tests/bfs_into_iter.rs @@ -1,4 +1,5 @@ use crate::{ + Bfs, DynTree, NodeRef, memory::Auto, node_ref::NodeRefCore, pinned_storage::SplitRecursive, @@ -6,7 +7,6 @@ use crate::{ breadth_first::{into_iter::BfsIterInto, iter_ptr::BfsIterPtr}, enumerations::{DepthSiblingIdxVal, DepthVal, SiblingIdxVal, Val}, }, - Bfs, DynTree, NodeRef, }; use alloc::collections::VecDeque; use alloc::string::{String, ToString}; diff --git a/src/traversal/breadth_first/tests/bfs_iter_mut.rs b/src/traversal/breadth_first/tests/bfs_iter_mut.rs index c4792ed..4fd36e5 100644 --- a/src/traversal/breadth_first/tests/bfs_iter_mut.rs +++ b/src/traversal/breadth_first/tests/bfs_iter_mut.rs @@ -1,4 +1,5 @@ use crate::{ + Dyn, DynTree, memory::Auto, node_ref::NodeRefCore, pinned_storage::SplitRecursive, @@ -6,7 +7,6 @@ use crate::{ breadth_first::{iter_mut::BfsIterMut, iter_ptr::BfsIterPtr, iter_ref::BfsIterRef}, enumerations::{DepthSiblingIdxVal, DepthVal, SiblingIdxVal, Val}, }, - Dyn, DynTree, }; use alloc::collections::VecDeque; use alloc::vec::Vec; @@ -151,6 +151,8 @@ fn bfs_iter_mut_depth_sibling() { let iter = BfsIterRef::<_, Auto, SplitRecursive, Val, _, &i32>::from((root.col(), iter)); assert_eq!( iter.copied().collect::>(), - [1, 10002, 10103, 20004, 20105, 20006, 20107, 30008, 30009, 30010, 30111] + [ + 1, 10002, 10103, 20004, 20105, 20006, 20107, 30008, 30009, 30010, 30111 + ] ); } diff --git a/src/traversal/breadth_first/tests/bfs_iter_ptr.rs b/src/traversal/breadth_first/tests/bfs_iter_ptr.rs index 61e3fd4..bf85ef8 100644 --- a/src/traversal/breadth_first/tests/bfs_iter_ptr.rs +++ b/src/traversal/breadth_first/tests/bfs_iter_ptr.rs @@ -1,7 +1,7 @@ use crate::{ + Dyn, DynTree, NodeRef, TreeVariant, node_ref::NodeRefCore, traversal::{breadth_first::iter_ptr::BfsIterPtr, enumerations::Val}, - Dyn, DynTree, NodeRef, TreeVariant, }; use alloc::collections::VecDeque; use alloc::vec::Vec; diff --git a/src/traversal/breadth_first/tests/bfs_iter_ref.rs b/src/traversal/breadth_first/tests/bfs_iter_ref.rs index 5cce28c..331b732 100644 --- a/src/traversal/breadth_first/tests/bfs_iter_ref.rs +++ b/src/traversal/breadth_first/tests/bfs_iter_ref.rs @@ -1,4 +1,5 @@ use crate::{ + Dyn, DynTree, NodeRef, memory::Auto, node_ref::NodeRefCore, pinned_storage::SplitRecursive, @@ -8,7 +9,6 @@ use crate::{ node_item::NodeItem, over::{Over, OverData, OverNode, OverPtr}, }, - Dyn, DynTree, NodeRef, }; use alloc::collections::VecDeque; use alloc::vec::Vec; diff --git a/src/traversal/breadth_first/tests/bfs_traverser.rs b/src/traversal/breadth_first/tests/bfs_traverser.rs index 0b65f42..528cb84 100644 --- a/src/traversal/breadth_first/tests/bfs_traverser.rs +++ b/src/traversal/breadth_first/tests/bfs_traverser.rs @@ -1,7 +1,9 @@ use crate::{ + Dyn, DynTree, NodeRef, memory::Auto, pinned_storage::SplitRecursive, traversal::{ + Traversal, Traverser, breadth_first::traverser::Bfs, enumerations::Val, node_item::NodeItem, @@ -10,9 +12,7 @@ use crate::{ OverSiblingIdxData, }, traverser_core::TraverserCore, - Traversal, Traverser, }, - Dyn, DynTree, NodeRef, }; use alloc::vec::Vec; use orx_selfref_col::Variant; diff --git a/src/traversal/breadth_first/tests/bfs_traverser_mut.rs b/src/traversal/breadth_first/tests/bfs_traverser_mut.rs index 13726ce..81f00f8 100644 --- a/src/traversal/breadth_first/tests/bfs_traverser_mut.rs +++ b/src/traversal/breadth_first/tests/bfs_traverser_mut.rs @@ -1,11 +1,11 @@ use crate::{ + DynTree, traversal::{ + Traversal, Traverser, breadth_first::traverser::Bfs, over::{OverData, OverDepthData, OverDepthSiblingIdxData, OverSiblingIdxData}, traverser_core::TraverserCore, - Traversal, Traverser, }, - DynTree, }; use alloc::vec::Vec; @@ -126,7 +126,9 @@ fn bfs_iter_mut_depth_sibling() { let iter = traverser.iter(&root); assert_eq!( iter.map(|x| *x.2).collect::>(), - [1, 10002, 10103, 20004, 20105, 20006, 20107, 30008, 30009, 30010, 30111] + [ + 1, 10002, 10103, 20004, 20105, 20006, 20107, 30008, 30009, 30010, 30111 + ] ); } diff --git a/src/traversal/breadth_first/traverser_core.rs b/src/traversal/breadth_first/traverser_core.rs index 308bf88..df2e370 100644 --- a/src/traversal/breadth_first/traverser_core.rs +++ b/src/traversal/breadth_first/traverser_core.rs @@ -1,18 +1,18 @@ use super::{ - into_iter::BfsIterInto, iter_mut::BfsIterMut, iter_ptr::BfsIterPtr, iter_ref::BfsIterRef, - queue::Item, Bfs, + Bfs, into_iter::BfsIterInto, iter_mut::BfsIterMut, iter_ptr::BfsIterPtr, iter_ref::BfsIterRef, + queue::Item, }; use crate::{ + MemoryPolicy, NodeMut, NodeMutOrientation, NodeRef, TreeVariant, node_ref::NodeRefCore, pinned_storage::PinnedStorage, traversal::{ + Over, OverMut, enumeration::Enumeration, over::OverItem, over_mut::{OverItemInto, OverItemMut}, traverser_core::TraverserCore, - Over, OverMut, }, - MemoryPolicy, NodeMut, NodeMutOrientation, NodeRef, TreeVariant, }; use alloc::collections::VecDeque; use orx_self_or::SoM; diff --git a/src/traversal/depth_first/into_iter.rs b/src/traversal/depth_first/into_iter.rs index 2ba89cf..322475f 100644 --- a/src/traversal/depth_first/into_iter.rs +++ b/src/traversal/depth_first/into_iter.rs @@ -1,10 +1,10 @@ +use super::DepthFirstEnumeration; use super::iter_ptr::DfsIterPtr; use super::stack::Item; -use super::DepthFirstEnumeration; +use crate::TreeVariant; use crate::aliases::Col; use crate::memory::MemoryPolicy; use crate::pinned_storage::PinnedStorage; -use crate::TreeVariant; use alloc::vec::Vec; use orx_self_or::SoM; use orx_selfref_col::{NodePtr, Refs}; diff --git a/src/traversal/depth_first/iter_mut.rs b/src/traversal/depth_first/iter_mut.rs index 41b5b56..5181adf 100644 --- a/src/traversal/depth_first/iter_mut.rs +++ b/src/traversal/depth_first/iter_mut.rs @@ -1,11 +1,11 @@ use super::dfs_enumeration::DepthFirstEnumeration; use super::iter_ptr::DfsIterPtr; use super::stack::Item; +use crate::TreeVariant; use crate::aliases::Col; use crate::memory::MemoryPolicy; use crate::pinned_storage::PinnedStorage; use crate::traversal::node_item_mut::NodeItemMut; -use crate::TreeVariant; use alloc::vec::Vec; use core::marker::PhantomData; use orx_self_or::SoM; diff --git a/src/traversal/depth_first/iter_ptr.rs b/src/traversal/depth_first/iter_ptr.rs index 4f850c6..1cf2d6f 100644 --- a/src/traversal/depth_first/iter_ptr.rs +++ b/src/traversal/depth_first/iter_ptr.rs @@ -1,7 +1,7 @@ use super::dfs_enumeration::DepthFirstEnumeration; use super::stack::Item; -use crate::tree_variant::RefsChildren; use crate::TreeVariant; +use crate::tree_variant::RefsChildren; use alloc::vec::Vec; use core::marker::PhantomData; use orx_self_or::SoM; diff --git a/src/traversal/depth_first/iter_ref.rs b/src/traversal/depth_first/iter_ref.rs index 9ffc4a6..e64b526 100644 --- a/src/traversal/depth_first/iter_ref.rs +++ b/src/traversal/depth_first/iter_ref.rs @@ -1,11 +1,11 @@ use super::dfs_enumeration::DepthFirstEnumeration; use super::iter_ptr::DfsIterPtr; use super::stack::Item; +use crate::TreeVariant; use crate::aliases::Col; use crate::memory::MemoryPolicy; use crate::pinned_storage::PinnedStorage; use crate::traversal::node_item::NodeItem; -use crate::TreeVariant; use alloc::vec::Vec; use core::marker::PhantomData; use orx_self_or::SoM; diff --git a/src/traversal/depth_first/stack.rs b/src/traversal/depth_first/stack.rs index 50c88ab..deb401b 100644 --- a/src/traversal/depth_first/stack.rs +++ b/src/traversal/depth_first/stack.rs @@ -1,4 +1,4 @@ -use crate::{traversal::enumeration::Enumeration, Dyn, TreeVariant}; +use crate::{Dyn, TreeVariant, traversal::enumeration::Enumeration}; use alloc::vec::Vec; use orx_selfref_col::NodePtr; diff --git a/src/traversal/depth_first/tests/dfs_into_iter.rs b/src/traversal/depth_first/tests/dfs_into_iter.rs index 80b8e8e..14ee65e 100644 --- a/src/traversal/depth_first/tests/dfs_into_iter.rs +++ b/src/traversal/depth_first/tests/dfs_into_iter.rs @@ -1,4 +1,5 @@ use crate::{ + Bfs, DynTree, NodeRef, memory::Auto, node_ref::NodeRefCore, pinned_storage::SplitRecursive, @@ -6,7 +7,6 @@ use crate::{ depth_first::{into_iter::DfsIterInto, iter_ptr::DfsIterPtr}, enumerations::{DepthSiblingIdxVal, DepthVal, SiblingIdxVal, Val}, }, - Bfs, DynTree, NodeRef, }; use alloc::string::{String, ToString}; use alloc::vec::Vec; diff --git a/src/traversal/depth_first/tests/dfs_iter_mut.rs b/src/traversal/depth_first/tests/dfs_iter_mut.rs index 08ea1e4..b6aaabd 100644 --- a/src/traversal/depth_first/tests/dfs_iter_mut.rs +++ b/src/traversal/depth_first/tests/dfs_iter_mut.rs @@ -1,4 +1,5 @@ use crate::{ + Dyn, DynTree, memory::Auto, node_ref::NodeRefCore, pinned_storage::SplitRecursive, @@ -6,7 +7,6 @@ use crate::{ depth_first::{iter_mut::DfsIterMut, iter_ptr::DfsIterPtr, iter_ref::DfsIterRef}, enumerations::{DepthSiblingIdxVal, DepthVal, SiblingIdxVal, Val}, }, - Dyn, DynTree, }; use alloc::vec::Vec; @@ -150,6 +150,8 @@ fn dfs_iter_mut_depth_sibling() { let iter = DfsIterRef::<_, Auto, SplitRecursive, Val, _, &i32>::from((root.col(), iter)); assert_eq!( iter.copied().collect::>(), - [1, 10002, 20004, 30008, 20105, 10103, 20006, 30009, 20107, 30010, 30111] + [ + 1, 10002, 20004, 30008, 20105, 10103, 20006, 30009, 20107, 30010, 30111 + ] ); } diff --git a/src/traversal/depth_first/tests/dfs_iter_ptr.rs b/src/traversal/depth_first/tests/dfs_iter_ptr.rs index b6b5b54..2e541bc 100644 --- a/src/traversal/depth_first/tests/dfs_iter_ptr.rs +++ b/src/traversal/depth_first/tests/dfs_iter_ptr.rs @@ -1,7 +1,7 @@ use crate::{ + Dyn, DynTree, NodeRef, TreeVariant, node_ref::NodeRefCore, traversal::{depth_first::iter_ptr::DfsIterPtr, enumerations::Val}, - Dyn, DynTree, NodeRef, TreeVariant, }; use alloc::vec::Vec; use orx_selfref_col::NodePtr; diff --git a/src/traversal/depth_first/tests/dfs_iter_ref.rs b/src/traversal/depth_first/tests/dfs_iter_ref.rs index e9e5ae9..a5b7b6a 100644 --- a/src/traversal/depth_first/tests/dfs_iter_ref.rs +++ b/src/traversal/depth_first/tests/dfs_iter_ref.rs @@ -1,4 +1,5 @@ use crate::{ + Dyn, DynTree, NodeRef, memory::Auto, node_ref::NodeRefCore, pinned_storage::SplitRecursive, @@ -8,7 +9,6 @@ use crate::{ node_item::NodeItem, over::{Over, OverData, OverNode, OverPtr}, }, - Dyn, DynTree, NodeRef, }; use alloc::vec::Vec; use orx_selfref_col::{NodePtr, Variant}; diff --git a/src/traversal/depth_first/tests/dfs_traverser.rs b/src/traversal/depth_first/tests/dfs_traverser.rs index da347fd..acd7ffa 100644 --- a/src/traversal/depth_first/tests/dfs_traverser.rs +++ b/src/traversal/depth_first/tests/dfs_traverser.rs @@ -1,7 +1,9 @@ use crate::{ + Dyn, DynTree, NodeRef, memory::Auto, pinned_storage::SplitRecursive, traversal::{ + Traversal, Traverser, depth_first::{dfs_enumeration::DepthFirstEnumeration, traverser::Dfs}, enumerations::Val, node_item::NodeItem, @@ -10,9 +12,7 @@ use crate::{ OverSiblingIdxData, }, traverser_core::TraverserCore, - Traversal, Traverser, }, - Dyn, DynTree, NodeRef, }; use alloc::vec::Vec; use orx_selfref_col::Variant; diff --git a/src/traversal/depth_first/tests/dfs_traverser_mut.rs b/src/traversal/depth_first/tests/dfs_traverser_mut.rs index 42b3e43..b4c9c11 100644 --- a/src/traversal/depth_first/tests/dfs_traverser_mut.rs +++ b/src/traversal/depth_first/tests/dfs_traverser_mut.rs @@ -1,11 +1,11 @@ use crate::{ + DynTree, traversal::{ + Traversal, Traverser, depth_first::traverser::Dfs, over::{OverDepthData, OverDepthSiblingIdxData, OverSiblingIdxData}, traverser_core::TraverserCore, - Traversal, Traverser, }, - DynTree, }; use alloc::vec::Vec; @@ -127,7 +127,9 @@ fn dfs_iter_mut_depth_sibling() { let iter = traverser.iter(&root); assert_eq!( iter.map(|x| *x.2).collect::>(), - [1, 10002, 20004, 30008, 20105, 10103, 20006, 30009, 20107, 30010, 30111] + [ + 1, 10002, 20004, 30008, 20105, 10103, 20006, 30009, 20107, 30010, 30111 + ] ); } diff --git a/src/traversal/depth_first/traverser_core.rs b/src/traversal/depth_first/traverser_core.rs index 62f714e..e2e1bae 100644 --- a/src/traversal/depth_first/traverser_core.rs +++ b/src/traversal/depth_first/traverser_core.rs @@ -1,18 +1,18 @@ use super::{ - into_iter::DfsIterInto, iter_mut::DfsIterMut, iter_ptr::DfsIterPtr, iter_ref::DfsIterRef, - stack::Item, Dfs, + Dfs, into_iter::DfsIterInto, iter_mut::DfsIterMut, iter_ptr::DfsIterPtr, iter_ref::DfsIterRef, + stack::Item, }; use crate::{ + MemoryPolicy, NodeMut, NodeMutOrientation, NodeRef, TreeVariant, node_ref::NodeRefCore, pinned_storage::PinnedStorage, traversal::{ + Over, OverMut, enumeration::Enumeration, over::OverItem, over_mut::{OverItemInto, OverItemMut}, traverser_core::TraverserCore, - Over, OverMut, }, - MemoryPolicy, NodeMut, NodeMutOrientation, NodeRef, TreeVariant, }; use alloc::vec::Vec; use orx_self_or::SoM; diff --git a/src/traversal/enumeration.rs b/src/traversal/enumeration.rs index 02a5976..542c569 100644 --- a/src/traversal/enumeration.rs +++ b/src/traversal/enumeration.rs @@ -1,5 +1,5 @@ use super::{node_item::NodeItem, node_item_mut::NodeItemMut}; -use crate::{aliases::Col, memory::MemoryPolicy, pinned_storage::PinnedStorage, TreeVariant}; +use crate::{TreeVariant, aliases::Col, memory::MemoryPolicy, pinned_storage::PinnedStorage}; use orx_selfref_col::NodePtr; pub trait Enumeration: Clone { diff --git a/src/traversal/node_item.rs b/src/traversal/node_item.rs index 9e90304..6cedf85 100644 --- a/src/traversal/node_item.rs +++ b/src/traversal/node_item.rs @@ -1,8 +1,8 @@ +use crate::Node; +use crate::TreeVariant; use crate::aliases::Col; use crate::memory::{Auto, MemoryPolicy}; use crate::pinned_storage::{PinnedStorage, SplitRecursive}; -use crate::Node; -use crate::TreeVariant; use orx_selfref_col::NodePtr; pub trait NodeItem<'a, V, M = Auto, P = SplitRecursive> diff --git a/src/traversal/node_item_mut.rs b/src/traversal/node_item_mut.rs index 8a781ce..8fcb4b8 100644 --- a/src/traversal/node_item_mut.rs +++ b/src/traversal/node_item_mut.rs @@ -1,7 +1,7 @@ +use crate::TreeVariant; use crate::aliases::Col; use crate::memory::{Auto, MemoryPolicy}; use crate::pinned_storage::{PinnedStorage, SplitRecursive}; -use crate::TreeVariant; use orx_selfref_col::NodePtr; pub trait NodeItemMut<'a, V, M = Auto, P = SplitRecursive> diff --git a/src/traversal/over_mut.rs b/src/traversal/over_mut.rs index dae2cce..650de16 100644 --- a/src/traversal/over_mut.rs +++ b/src/traversal/over_mut.rs @@ -4,9 +4,9 @@ use super::{ over::{Over, OverData, OverDepthData, OverDepthSiblingIdxData, OverSiblingIdxData}, }; use crate::{ + TreeVariant, memory::{Auto, MemoryPolicy}, pinned_storage::{PinnedStorage, SplitRecursive}, - TreeVariant, }; use orx_selfref_col::Variant; diff --git a/src/traversal/post_order/into_iter.rs b/src/traversal/post_order/into_iter.rs index eb901bb..6343c9e 100644 --- a/src/traversal/post_order/into_iter.rs +++ b/src/traversal/post_order/into_iter.rs @@ -1,10 +1,10 @@ use super::iter_ptr::PostOrderIterPtr; use super::post_enumeration::PostOrderEnumeration; use super::states::State; +use crate::TreeVariant; use crate::aliases::Col; use crate::memory::MemoryPolicy; use crate::pinned_storage::PinnedStorage; -use crate::TreeVariant; use alloc::vec::Vec; use orx_self_or::SoM; use orx_selfref_col::{NodePtr, Refs}; diff --git a/src/traversal/post_order/iter_mut.rs b/src/traversal/post_order/iter_mut.rs index e9e7c38..6d92b6e 100644 --- a/src/traversal/post_order/iter_mut.rs +++ b/src/traversal/post_order/iter_mut.rs @@ -1,11 +1,11 @@ use super::iter_ptr::PostOrderIterPtr; use super::states::State; use super::{iter_ptr::Item, post_enumeration::PostOrderEnumeration}; +use crate::TreeVariant; use crate::aliases::Col; use crate::memory::MemoryPolicy; use crate::pinned_storage::PinnedStorage; use crate::traversal::node_item_mut::NodeItemMut; -use crate::TreeVariant; use alloc::vec::Vec; use core::marker::PhantomData; use orx_self_or::SoM; diff --git a/src/traversal/post_order/iter_ptr.rs b/src/traversal/post_order/iter_ptr.rs index 530b32c..bcb394e 100644 --- a/src/traversal/post_order/iter_ptr.rs +++ b/src/traversal/post_order/iter_ptr.rs @@ -1,5 +1,5 @@ use super::{post_enumeration::PostOrderEnumeration, states::State}; -use crate::{traversal::enumeration::Enumeration, tree_variant::RefsChildren, TreeVariant}; +use crate::{TreeVariant, traversal::enumeration::Enumeration, tree_variant::RefsChildren}; use alloc::vec::Vec; use core::marker::PhantomData; use orx_self_or::SoM; diff --git a/src/traversal/post_order/iter_ref.rs b/src/traversal/post_order/iter_ref.rs index 837f010..9b0a55d 100644 --- a/src/traversal/post_order/iter_ref.rs +++ b/src/traversal/post_order/iter_ref.rs @@ -2,11 +2,11 @@ use super::iter_ptr::Item; use super::iter_ptr::PostOrderIterPtr; use super::post_enumeration::PostOrderEnumeration; use super::states::State; +use crate::TreeVariant; use crate::aliases::Col; use crate::memory::MemoryPolicy; use crate::pinned_storage::PinnedStorage; use crate::traversal::node_item::NodeItem; -use crate::TreeVariant; use alloc::vec::Vec; use core::marker::PhantomData; use orx_self_or::SoM; diff --git a/src/traversal/post_order/post_enumeration.rs b/src/traversal/post_order/post_enumeration.rs index 931c852..1f87e68 100644 --- a/src/traversal/post_order/post_enumeration.rs +++ b/src/traversal/post_order/post_enumeration.rs @@ -1,7 +1,7 @@ use super::states::State; +use crate::TreeVariant; use crate::traversal::enumeration::Enumeration; use crate::traversal::enumerations::{DepthSiblingIdxVal, DepthVal, SiblingIdxVal, Val}; -use crate::TreeVariant; pub trait PostOrderEnumeration: Enumeration { fn create_post_item(node_value: D, depth: usize, states: &[State]) -> Self::Item diff --git a/src/traversal/post_order/tests/post_order_iter_into.rs b/src/traversal/post_order/tests/post_order_iter_into.rs index b183d3b..f3e0ddf 100644 --- a/src/traversal/post_order/tests/post_order_iter_into.rs +++ b/src/traversal/post_order/tests/post_order_iter_into.rs @@ -1,4 +1,5 @@ use crate::{ + Bfs, DynTree, NodeRef, memory::Auto, node_ref::NodeRefCore, pinned_storage::SplitRecursive, @@ -6,7 +7,6 @@ use crate::{ enumerations::{DepthSiblingIdxVal, DepthVal, SiblingIdxVal, Val}, post_order::{into_iter::PostOrderIterInto, iter_ptr::PostOrderIterPtr}, }, - Bfs, DynTree, NodeRef, }; use alloc::string::{String, ToString}; use alloc::vec::Vec; diff --git a/src/traversal/post_order/tests/post_order_iter_mut.rs b/src/traversal/post_order/tests/post_order_iter_mut.rs index ba5cb59..62a2a02 100644 --- a/src/traversal/post_order/tests/post_order_iter_mut.rs +++ b/src/traversal/post_order/tests/post_order_iter_mut.rs @@ -1,4 +1,5 @@ use crate::{ + Dyn, DynTree, memory::Auto, node_ref::NodeRefCore, pinned_storage::SplitRecursive, @@ -8,7 +9,6 @@ use crate::{ iter_mut::PostOrderIterMut, iter_ptr::PostOrderIterPtr, iter_ref::PostOrderIterRef, }, }, - Dyn, DynTree, }; use alloc::vec::Vec; @@ -161,6 +161,8 @@ fn post_order_iter_mut_depth_sibling() { let iter = PostOrderIterRef::<_, Auto, SplitRecursive, Val, _, &i32>::from((root.col(), iter)); assert_eq!( iter.copied().collect::>(), - [30008, 20004, 20105, 10002, 30009, 20006, 30010, 30111, 20107, 10103, 1] + [ + 30008, 20004, 20105, 10002, 30009, 20006, 30010, 30111, 20107, 10103, 1 + ] ); } diff --git a/src/traversal/post_order/tests/post_order_iter_ptr.rs b/src/traversal/post_order/tests/post_order_iter_ptr.rs index 1025d53..d2b801c 100644 --- a/src/traversal/post_order/tests/post_order_iter_ptr.rs +++ b/src/traversal/post_order/tests/post_order_iter_ptr.rs @@ -1,7 +1,7 @@ use crate::{ + Dyn, DynTree, NodeRef, TreeVariant, node_ref::NodeRefCore, traversal::{enumerations::Val, post_order::iter_ptr::PostOrderIterPtr}, - Dyn, DynTree, NodeRef, TreeVariant, }; use alloc::vec::Vec; use orx_selfref_col::NodePtr; diff --git a/src/traversal/post_order/tests/post_order_iter_ref.rs b/src/traversal/post_order/tests/post_order_iter_ref.rs index 9e9c505..391a9bb 100644 --- a/src/traversal/post_order/tests/post_order_iter_ref.rs +++ b/src/traversal/post_order/tests/post_order_iter_ref.rs @@ -1,4 +1,5 @@ use crate::{ + Dyn, DynTree, NodeRef, memory::Auto, node_ref::NodeRefCore, pinned_storage::SplitRecursive, @@ -8,7 +9,6 @@ use crate::{ over::{Over, OverData, OverNode, OverPtr}, post_order::{iter_ptr::PostOrderIterPtr, iter_ref::PostOrderIterRef}, }, - Dyn, DynTree, NodeRef, }; use alloc::vec::Vec; use orx_selfref_col::{NodePtr, Variant}; diff --git a/src/traversal/post_order/tests/post_order_traverser.rs b/src/traversal/post_order/tests/post_order_traverser.rs index 3483bcd..4ea3249 100644 --- a/src/traversal/post_order/tests/post_order_traverser.rs +++ b/src/traversal/post_order/tests/post_order_traverser.rs @@ -1,7 +1,9 @@ use crate::{ + Dyn, DynTree, NodeRef, memory::Auto, pinned_storage::SplitRecursive, traversal::{ + Traversal, Traverser, enumerations::Val, node_item::NodeItem, over::{ @@ -10,9 +12,7 @@ use crate::{ }, post_order::{post_enumeration::PostOrderEnumeration, traverser::PostOrder}, traverser_core::TraverserCore, - Traversal, Traverser, }, - Dyn, DynTree, NodeRef, }; use alloc::vec::Vec; use orx_selfref_col::Variant; diff --git a/src/traversal/post_order/tests/post_order_traverser_mut.rs b/src/traversal/post_order/tests/post_order_traverser_mut.rs index 3ca7380..e0aa9b2 100644 --- a/src/traversal/post_order/tests/post_order_traverser_mut.rs +++ b/src/traversal/post_order/tests/post_order_traverser_mut.rs @@ -1,11 +1,11 @@ use crate::{ + DynTree, traversal::{ + Traversal, Traverser, over::{OverData, OverDepthData, OverDepthSiblingIdxData, OverSiblingIdxData}, post_order::traverser::PostOrder, traverser_core::TraverserCore, - Traversal, Traverser, }, - DynTree, }; use alloc::vec::Vec; @@ -132,7 +132,9 @@ fn post_order_iter_mut_depth_sibling() { let iter = traverser.iter(&root); assert_eq!( iter.map(|x| *x.2).collect::>(), - [30008, 20004, 20105, 10002, 30009, 20006, 30010, 30111, 20107, 10103, 1] + [ + 30008, 20004, 20105, 10002, 30009, 20006, 30010, 30111, 20107, 10103, 1 + ] ); } diff --git a/src/traversal/post_order/traverser.rs b/src/traversal/post_order/traverser.rs index 64ba0dd..46648c7 100644 --- a/src/traversal/post_order/traverser.rs +++ b/src/traversal/post_order/traverser.rs @@ -1,7 +1,7 @@ use super::states::States; use crate::traversal::{ - over::{Over, OverData}, Traverser, + over::{Over, OverData}, }; use core::marker::PhantomData; diff --git a/src/traversal/post_order/traverser_core.rs b/src/traversal/post_order/traverser_core.rs index a05a126..8183b74 100644 --- a/src/traversal/post_order/traverser_core.rs +++ b/src/traversal/post_order/traverser_core.rs @@ -1,18 +1,18 @@ use super::{ - into_iter::PostOrderIterInto, iter_mut::PostOrderIterMut, iter_ptr::PostOrderIterPtr, - iter_ref::PostOrderIterRef, states::State, PostOrder, + PostOrder, into_iter::PostOrderIterInto, iter_mut::PostOrderIterMut, + iter_ptr::PostOrderIterPtr, iter_ref::PostOrderIterRef, states::State, }; use crate::{ + MemoryPolicy, NodeMut, NodeMutOrientation, NodeRef, TreeVariant, node_ref::NodeRefCore, pinned_storage::PinnedStorage, traversal::{ + Over, OverMut, enumeration::Enumeration, over::OverItem, over_mut::{OverItemInto, OverItemMut}, traverser_core::TraverserCore, - Over, OverMut, }, - MemoryPolicy, NodeMut, NodeMutOrientation, NodeRef, TreeVariant, }; use alloc::vec::Vec; use orx_self_or::SoM; diff --git a/src/traversal/traverser.rs b/src/traversal/traverser.rs index 1d2aa83..4f5b8d0 100644 --- a/src/traversal/traverser.rs +++ b/src/traversal/traverser.rs @@ -1,4 +1,4 @@ -use super::{over::Over, traverser_core::TraverserCore, OverData}; +use super::{OverData, over::Over, traverser_core::TraverserCore}; /// A tree traverser that creates iterators which walk over a given node and all of its descendants; /// i.e., over all nodes of the subtree rooted at the given node. diff --git a/src/traversal/traverser_core.rs b/src/traversal/traverser_core.rs index 0e9754b..26ad56e 100644 --- a/src/traversal/traverser_core.rs +++ b/src/traversal/traverser_core.rs @@ -1,12 +1,12 @@ use super::{ + OverData, OverMut, enumeration::Enumeration, over::{Over, OverItem}, over_mut::{OverItemInto, OverItemMut}, - OverData, OverMut, }; use crate::{ - memory::MemoryPolicy, pinned_storage::PinnedStorage, NodeMut, NodeMutOrientation, NodeRef, - TreeVariant, + NodeMut, NodeMutOrientation, NodeRef, TreeVariant, memory::MemoryPolicy, + pinned_storage::PinnedStorage, }; use orx_self_or::SoM; use orx_selfref_col::NodePtr; diff --git a/src/tree.rs b/src/tree.rs index adeb784..6987f10 100644 --- a/src/tree.rs +++ b/src/tree.rs @@ -1,11 +1,11 @@ use crate::{ + Node, NodeIdx, NodeMut, NodeSwapError, TreeVariant, aliases::Col, iter::AncestorsIterPtr, memory::{Auto, MemoryPolicy}, pinned_storage::{PinnedStorage, SplitRecursive}, tree_node_idx::INVALID_IDX_ERROR, tree_variant::RefsChildren, - Node, NodeIdx, NodeMut, NodeSwapError, TreeVariant, }; use orx_selfref_col::{NodeIdxError, NodePtr, RefsSingle}; diff --git a/src/tree_node_idx.rs b/src/tree_node_idx.rs index ecab5ae..132addd 100644 --- a/src/tree_node_idx.rs +++ b/src/tree_node_idx.rs @@ -1,6 +1,6 @@ use crate::{ - subtrees_within::{ClonedSubTreeWithin, CopiedSubTreeWithin, MovedSubTreeWithin}, TreeVariant, + subtrees_within::{ClonedSubTreeWithin, CopiedSubTreeWithin, MovedSubTreeWithin}, }; use core::fmt::Debug; diff --git a/src/tree_variant.rs b/src/tree_variant.rs index 6eb9cea..4425ce9 100644 --- a/src/tree_variant.rs +++ b/src/tree_variant.rs @@ -1,6 +1,6 @@ use orx_selfref_col::{ - references::iter::ArrayLeftMostPtrIter, MemoryReclaimer, NodePtr, Refs, RefsArrayLeftMost, - RefsSingle, RefsVec, Variant, + MemoryReclaimer, NodePtr, Refs, RefsArrayLeftMost, RefsSingle, RefsVec, Variant, + references::iter::ArrayLeftMostPtrIter, }; /// Variant of a tree.