feat(tools): Improved OrderedHashMap apis

Author: spmadden

libraries/graphing/src/fdp.rs

@@ -15,12 +15,12 @@ pub use edge::*;
 pub use repulsive::*;
 
 use crate::{Graph, SharedNode};
-use alloc::collections::BTreeMap;
 use alloc::rc::Rc;
 use core::cell::RefCell;
 use core::fmt::{Debug, Formatter};
 use irox_geometry::{Point, Vector};
 use irox_tools::identifier::{Identifier, SharedIdentifier};
+use irox_tools::map::OrderedHashMap;
 use irox_units::units::angle::Angle;
 
 const INITIAL_RADIUS: f64 = 1.0;
@@ -123,14 +123,30 @@ pub struct SimulationWorkingEdge {
 pub trait InitialNodePlacer {
     fn place_node(&mut self, node: &mut SharedNode, working: &mut SimulationWorkingNode);
 }
-#[derive(Debug, Default, Clone)]
+#[derive(Debug, Clone)]
 pub struct DefaultNodePlacement {
+    initial_radius: f64,
     last_idx: usize,
 }
+impl DefaultNodePlacement {
+    #[must_use]
+    pub fn with_initial_radius(mut self, radius: f64) -> Self {
+        self.initial_radius = radius;
+        self
+    }
+}
+impl Default for DefaultNodePlacement {
+    fn default() -> Self {
+        Self {
+            last_idx: 0,
+            initial_radius: INITIAL_RADIUS,
+        }
+    }
+}
 impl InitialNodePlacer for DefaultNodePlacement {
     fn place_node(&mut self, _node: &mut SharedNode, working: &mut SimulationWorkingNode) {
         let idx = self.last_idx;
-        let init_radius = INITIAL_RADIUS * (0.5 + idx as f64).sqrt();
+        let init_radius = self.initial_radius * (0.5 + idx as f64).sqrt();
         let init_angle = INITIAL_ANGLE * (idx as f64);
         let current_position = Vector {
             vx: init_radius * init_angle.cos(),
@@ -145,8 +161,8 @@ pub struct Simulation {
     pub graph: Shared<Graph>,
     pub forces: Vec<Force>,
 
-    pub working_nodes: BTreeMap<SharedIdentifier, SimulationWorkingNode>,
-    pub working_edges: BTreeMap<SharedIdentifier, SimulationWorkingEdge>,
+    pub working_nodes: OrderedHashMap<SharedIdentifier, SimulationWorkingNode>,
+    pub working_edges: OrderedHashMap<SharedIdentifier, SimulationWorkingEdge>,
 
     pub params: SimulationParams,
     pub placement: Box<dyn InitialNodePlacer>,

libraries/tools/src/map.rs

@@ -8,16 +8,24 @@ use alloc::collections::vec_deque::Iter;
 use alloc::collections::VecDeque;
 use core::borrow::Borrow;
 use core::hash::Hash;
+use std::collections::hash_map::{Entry, ValuesMut};
 use std::collections::HashMap;
 
 ///
 /// Tracks the insertion order of key/value pairs.  Backed by a [`HashMap`] for storage
 /// and a [`VecDeque`] for key insertion order.
-#[derive(Default)]
 pub struct OrderedHashMap<K, V> {
     map: HashMap<K, V>,
     key_order: VecDeque<K>,
 }
+impl<K, V> Default for OrderedHashMap<K, V> {
+    fn default() -> Self {
+        Self {
+            map: Default::default(),
+            key_order: Default::default()
+        }
+    }
+}
 
 impl<K, V> OrderedHashMap<K, V> {
     pub fn new() -> OrderedHashMap<K, V> {
@@ -69,6 +77,18 @@ impl<K: Eq + Hash + Clone, V> OrderedHashMap<K, V> {
     pub fn contains(&self, k: &K) -> bool {
         self.map.contains_key(k)
     }
+
+    pub fn entry(&mut self, k: K) -> Entry<'_, K, V>{
+        self.map.entry(k)
+    }
+
+    pub fn get_mut(&mut self, k: &K) -> Option<&mut V>{
+        self.map.get_mut(k)
+    }
+
+    pub fn values_mut(&mut self) -> ValuesMut<'_, K, V> {
+        self.map.values_mut()
+    }
 }
 impl<'a, K: Eq + Hash, V> OrderedHashMap<K, V> {
     pub fn iter(&'a self) -> OrderedMapIter<'a, K, V> {
@@ -84,6 +104,14 @@ impl<'a, K: Eq + Hash, V> OrderedHashMap<K, V> {
         }
     }
 }
+impl<'a, K: Eq + Hash, V> IntoIterator for &'a OrderedHashMap<K, V> {
+    type Item = (&'a K, &'a V);
+    type IntoIter = OrderedMapIter<'a, K, V>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
 
 pub struct OrderedMapIter<'a, K, V> {
     key_iter: Iter<'a, K>,