Rename Index to ToAppendable and move to stitching module

Author: Hendrik van Antwerpen

stack-graphs/src/cycles.rs

@@ -43,7 +43,7 @@ use crate::partial::PartialPath;
 use crate::partial::PartialPaths;
 use crate::paths::PathResolutionError;
 use crate::stitching::Appendable;
-use crate::stitching::Database;
+use crate::stitching::ToAppendable;
 
 /// Helps detect similar paths in the path-finding algorithm.
 pub struct SimilarPathDetector<P> {
@@ -128,25 +128,6 @@ where
 // ----------------------------------------------------------------------------
 // Cycle detector
 
-pub trait Index<H, A>
-where
-    A: Appendable,
-{
-    fn get<'a>(&'a self, handle: &'a H) -> &'a A;
-}
-
-impl Index<Handle<PartialPath>, PartialPath> for Database {
-    fn get<'a>(&'a self, handle: &'a Handle<PartialPath>) -> &'a PartialPath {
-        &self[*handle]
-    }
-}
-
-impl<A: Appendable + Clone> Index<A, A> for () {
-    fn get<'a>(&'a self, value: &'a A) -> &'a A {
-        value
-    }
-}
-
 pub struct Appendables<H>(pub(crate) ListArena<PathOrAppendable<H>>);
 
 impl<H> Appendables<H> {
@@ -174,33 +155,33 @@ where
     ) -> Result<(), PathResolutionError>
     where
         A: Appendable + 'a,
-        Db: Index<H, A>,
+        Db: ToAppendable<H, A>,
     {
         match self {
             Self::Path(other) => other.append_to(graph, partials, path),
-            Self::Handle(h) => db.get(h).append_to(graph, partials, path),
+            Self::Handle(h) => db.get_appendable(h).append_to(graph, partials, path),
         }
     }
 
     fn start_node<'a, A, Db>(&self, db: &'a Db) -> Handle<Node>
     where
         A: Appendable + 'a,
-        Db: Index<H, A>,
+        Db: ToAppendable<H, A>,
     {
         match self {
             Self::Path(path) => path.start_node,
-            Self::Handle(h) => db.get(h).start_node(),
+            Self::Handle(h) => db.get_appendable(h).start_node(),
         }
     }
 
     fn end_node<'a, A, Db>(&self, db: &'a Db) -> Handle<Node>
     where
         A: Appendable + 'a,
-        Db: Index<H, A>,
+        Db: ToAppendable<H, A>,
     {
         match self {
             Self::Path(path) => path.end_node,
-            Self::Handle(h) => db.get(h).end_node(),
+            Self::Handle(h) => db.get_appendable(h).end_node(),
         }
     }
 }
@@ -246,7 +227,7 @@ where
     ) -> Result<EnumSet<Cyclicity>, PathResolutionError>
     where
         A: Appendable + 'a,
-        Db: Index<H, A>,
+        Db: ToAppendable<H, A>,
     {
         let mut cycles = EnumSet::new();
 

stack-graphs/src/stitching.rs

@@ -39,7 +39,6 @@ use std::collections::HashMap;
 use std::collections::VecDeque;
 #[cfg(feature = "copious-debugging")]
 use std::fmt::Display;
-use std::ops::Index;
 
 use crate::arena::Arena;
 use crate::arena::Handle;
@@ -153,6 +152,28 @@ impl Appendable for PartialPath {
     }
 }
 
+//-------------------------------------------------------------------------------------------------
+// ToAppendable
+
+pub trait ToAppendable<H, A>
+where
+    A: Appendable,
+{
+    fn get_appendable<'a>(&'a self, handle: &'a H) -> &'a A;
+}
+
+impl ToAppendable<Handle<PartialPath>, PartialPath> for Database {
+    fn get_appendable<'a>(&'a self, handle: &'a Handle<PartialPath>) -> &'a PartialPath {
+        &self[*handle]
+    }
+}
+
+impl<A: Appendable + Clone> ToAppendable<A, A> for () {
+    fn get_appendable<'a>(&'a self, value: &'a A) -> &'a A {
+        value
+    }
+}
+
 //-------------------------------------------------------------------------------------------------
 // Candidates
 
@@ -440,7 +461,7 @@ impl Database {
     }
 }
 
-impl Index<Handle<PartialPath>> for Database {
+impl std::ops::Index<Handle<PartialPath>> for Database {
     type Output = PartialPath;
     #[inline(always)]
     fn index(&self, handle: Handle<PartialPath>) -> &PartialPath {
@@ -734,7 +755,7 @@ impl<H: Clone> ForwardPartialPathStitcher<H> {
     ) -> usize
     where
         A: Appendable + 'a,
-        Db: Candidates<H> + crate::cycles::Index<H, A>,
+        Db: Candidates<H> + ToAppendable<H, A>,
     {
         self.candidates.clear();
         db.find_candidates(graph, partials, partial_path, &mut self.candidates);
@@ -743,7 +764,7 @@ impl<H: Clone> ForwardPartialPathStitcher<H> {
         self.next_iteration.0.reserve(extension_count);
         self.next_iteration.1.reserve(extension_count);
         for extension in &self.candidates {
-            let extension_path = db.get(extension);
+            let extension_path = db.get_appendable(extension);
             copious_debugging!("    Extend {}", partial_path.display(graph, partials));
             copious_debugging!("      with {}", extension_path.display(graph, partials));
 
@@ -809,7 +830,7 @@ impl<H: Clone> ForwardPartialPathStitcher<H> {
         db: &mut Db,
     ) where
         A: Appendable + 'a,
-        Db: Candidates<H> + crate::cycles::Index<H, A>,
+        Db: Candidates<H> + ToAppendable<H, A>,
     {
         copious_debugging!("==> Start phase {}", self.phase_number);
         self.queue.extend(