Generic graph representation for additional algorithms

Author: ATrefzer

CodeParser/Analysis/Cycles/CycleFinder.cs

@@ -1,5 +1,6 @@
 using CodeParser.Analysis.Shared;
 using Contracts.Graph;
+using GraphLib.Algorithms.StronglyConnectedComponents;
 
 namespace CodeParser.Analysis.Cycles;
 
@@ -35,7 +36,7 @@ public static List<CycleGroup> FindCycleGroups(CodeGraph originalGraph)
     ///     When determining the SCC we collected the relevant nodes, but did not
     ///     remove the orphaned dependencies, yet.
     /// </summary>
-    private static void RemoveOrphanedDependencies(Scc scc)
+    private static void RemoveOrphanedDependencies(Scc<SearchNode> scc)
     {
         var existingIds = scc.Vertices.Select(v => v.Id).ToHashSet();
         foreach (var vertex in scc.Vertices)

CodeParser/Analysis/Cycles/SearchGraph.cs

@@ -0,0 +1,36 @@
+using CodeParser.Analysis.Shared;
+using GraphLib.Contracts;
+
+namespace CodeParser.Analysis.Cycles;
+
+    public class SearchGraph : IGraphRepresentation<SearchNode>
+    {
+        public SearchGraph(List<SearchNode> vertices) 
+        {
+            Vertices = vertices;
+        }
+
+        public uint VertexCount => (uint)Vertices.Count();
+
+        public List<SearchNode> Vertices { get; }
+
+        public IReadOnlyCollection<SearchNode> GetNeighbors(SearchNode vertex)
+        {
+            return vertex.Dependencies;
+        }
+
+        public IReadOnlyCollection<SearchNode> GetVertices()
+        {
+            return Vertices;
+        }
+
+        public bool IsEdge(SearchNode source, SearchNode target)
+        {
+            return source.Dependencies.Contains(target);
+        }
+
+        public bool IsVertex(SearchNode vertex)
+        {
+            return Vertices.Contains(vertex);
+        }
+    }

CodeParser/Analysis/Cycles/SearchGraphBuilder.cs

@@ -3,9 +3,10 @@
 
 namespace CodeParser.Analysis.Cycles;
 
-public class SearchGraphBuilder
+public partial class SearchGraphBuilder
 {
-    public static List<SearchNode> BuildSearchGraph(CodeGraph codeGraph)
+
+    public static SearchGraph BuildSearchGraph(CodeGraph codeGraph)
     {
         var searchNodes = new Dictionary<string, SearchNode>();
 
@@ -41,7 +42,7 @@ public static List<SearchNode> BuildSearchGraph(CodeGraph codeGraph)
             searchSource.Dependencies.Add(searchTarget);
         }
 
-        return searchNodes.Values.ToList();
+        return new SearchGraph(searchNodes.Values.ToList());
     }
 
     private static bool IsMethod(CodeGraph codeGraph, string id)

CodeParser/Analysis/Shared/Tarjan.cs

@@ -1,41 +1,49 @@
-namespace CodeParser.Analysis.Shared;
+using GraphLib.Contracts;
 
-public class Scc
+namespace GraphLib.Algorithms.StronglyConnectedComponents;
+
+/// <summary>
+///     Returns the strongly connected components.
+///     Cycles are restricted by these components.
+/// </summary>
+public class Scc<TVertex>
 {
-    public HashSet<SearchNode> Vertices { get; } = [];
+    public HashSet<TVertex> Vertices = new();
 }
 
 public static class Tarjan
 {
     /// <summary>
-    ///     O(|E| + |V|)
+    /// O(|E| + |V|)
     /// </summary>
-    public static List<Scc> FindStronglyConnectedComponents(List<SearchNode> graph)
+    public static List<Scc<TVertex>> FindStronglyConnectedComponents<TVertex>(IGraphRepresentation<TVertex> graph)
+        where TVertex : notnull
     {
-        var sccs = new List<Scc>();
+        var sccs = new List<Scc<TVertex>>();
 
-        var idMap = new Dictionary<SearchNode, int>();
-        var lowMap = new Dictionary<SearchNode, int>();
-        var stack = new Stack<SearchNode>();
-        var inStack = new HashSet<SearchNode>();
+        var idMap = new Dictionary<TVertex, int>();
+        var lowMap = new Dictionary<TVertex, int>();
+        var stack = new Stack<TVertex>();
+        var inStack = new HashSet<TVertex>();
 
-        foreach (var vertex in graph)
+        foreach (var vertex in graph.GetVertices())
         {
             if (!idMap.ContainsKey(vertex))
             {
-                Dfs(vertex, idMap, lowMap, stack, inStack, sccs);
+                Dfs(graph, vertex, idMap, lowMap, stack, inStack, sccs);
             }
         }
 
         return sccs;
     }
 
-    private static void Dfs(SearchNode u,
-        Dictionary<SearchNode, int> idMap,
-        Dictionary<SearchNode, int> lowMap,
-        Stack<SearchNode> stack,
-        HashSet<SearchNode> inStack, // visited
-        List<Scc> sccs)
+    private static void Dfs<TVertex>(IGraphRepresentation<TVertex> graph,
+        TVertex u,
+        Dictionary<TVertex, int> idMap,
+        Dictionary<TVertex, int> lowMap,
+        Stack<TVertex> stack,
+        HashSet<TVertex> inStack, // visited
+        List<Scc<TVertex>> sccs) where TVertex : notnull
 
 
     {
@@ -45,12 +53,12 @@ private static void Dfs(SearchNode u,
         stack.Push(u);
         inStack.Add(u);
 
-        foreach (var v in u.Dependencies)
+        foreach (var v in graph.GetNeighbors(u))
         {
             if (idMap.ContainsKey(v) is false)
             {
                 // Unvisited vertex
-                Dfs(v, idMap, lowMap, stack, inStack, sccs);
+                Dfs(graph, v, idMap, lowMap, stack, inStack, sccs);
                 lowMap[u] = Math.Min(lowMap[u], lowMap[v]);
             }
             else if (inStack.Contains(v))
@@ -64,7 +72,7 @@ private static void Dfs(SearchNode u,
         if (lowMap[u] == idMap[u])
         {
             // Vertex is root of SCC.
-            var scc = new Scc();
+            var scc = new Scc<TVertex>();
             while (stack.Any())
             {
                 var popped = stack.Pop();

CodeParserTests/CodeGraphBuilderTests.cs

@@ -20,7 +20,7 @@ public void GenerateDetailedCodeGraph_SimpleClassDependency_PreservesDependency(
         originalGraph.Nodes["B"] = classB;
 
         var searchGraph = SearchGraphBuilder.BuildSearchGraph(originalGraph);
-        var detailedGraph = CodeGraphBuilder.GenerateDetailedCodeGraph(searchGraph, originalGraph);
+        var detailedGraph = CodeGraphBuilder.GenerateDetailedCodeGraph(searchGraph.Vertices, originalGraph);
 
         Assert.AreEqual(2, detailedGraph.Nodes.Count);
         Assert.IsTrue(detailedGraph.Nodes.ContainsKey("A"));
@@ -47,7 +47,7 @@ public void GenerateDetailedCodeGraph_MethodDependency_PreservesMethodLevelDepen
         originalGraph.Nodes["B.M"] = methodB;
 
         var searchGraph = SearchGraphBuilder.BuildSearchGraph(originalGraph);
-        var detailedGraph = CodeGraphBuilder.GenerateDetailedCodeGraph(searchGraph, originalGraph);
+        var detailedGraph = CodeGraphBuilder.GenerateDetailedCodeGraph(searchGraph.Vertices, originalGraph);
 
         Assert.AreEqual(4, detailedGraph.Nodes.Count);
         Assert.IsTrue(detailedGraph.Nodes.ContainsKey("A"));
@@ -79,7 +79,7 @@ public void GenerateDetailedCodeGraph_MultipleDependencies_PreservesAllDependenc
         originalGraph.Nodes["B.M"] = methodB;
 
         var searchGraph = SearchGraphBuilder.BuildSearchGraph(originalGraph);
-        var detailedGraph = CodeGraphBuilder.GenerateDetailedCodeGraph(searchGraph, originalGraph);
+        var detailedGraph = CodeGraphBuilder.GenerateDetailedCodeGraph(searchGraph.Vertices, originalGraph);
 
         Assert.AreEqual(5, detailedGraph.Nodes.Count);
         Assert.AreEqual(1, detailedGraph.Nodes["A.M1"].Dependencies.Count);

CodeParserTests/TarjanTests.cs

@@ -1,4 +1,6 @@
-using CodeParser.Analysis.Shared;
+using CodeParser.Analysis.Cycles;
+using CodeParser.Analysis.Shared;
+using GraphLib.Algorithms.StronglyConnectedComponents;
 
 namespace CodeParserTests;
 
@@ -18,7 +20,7 @@ public void FindStronglyConnectedComponents_SimpleCircularDependency_ReturnsSing
 
         var graph = new List<SearchNode> { nodeA, nodeB, nodeC };
 
-        var sccs = Tarjan.FindStronglyConnectedComponents(graph);
+        var sccs = Tarjan.FindStronglyConnectedComponents(new SearchGraph(graph));
 
         Assert.AreEqual(1, sccs.Count);
         Assert.AreEqual(3, sccs[0].Vertices.Count);

Contracts/Graph/CodeGraph.cs

@@ -1,9 +1,14 @@
-namespace Contracts.Graph;
+using GraphLib.Contracts;
+using System.Reflection.Metadata.Ecma335;
 
-public class CodeGraph
+namespace Contracts.Graph;
+
+public class CodeGraph : IGraphRepresentation<CodeElement>
 {
     public Dictionary<string, CodeElement> Nodes = new();
 
+    public uint VertexCount => (uint)Nodes.Count();
+
     public CodeElement? TryGetCodeElement(string? id)
     {
         if (string.IsNullOrEmpty(id))
@@ -111,4 +116,24 @@ public IEnumerable<Dependency> GetAllDependencies()
     {
         return Nodes.Values.SelectMany(n => n.Dependencies).ToList();
     }
+
+    public IReadOnlyCollection<CodeElement> GetNeighbors(CodeElement vertex)
+    {
+        return vertex.Dependencies.Select(d => Nodes[d.TargetId]).ToList();
+    }
+
+    public bool IsVertex(CodeElement vertex)
+    {
+        return Nodes.ContainsKey(vertex.Id);
+    }
+
+    public bool IsEdge(CodeElement source, CodeElement target)
+    {
+        return Nodes[source.Id].Dependencies.Any(d => d.TargetId == target.Id);
+    }
+
+    public IReadOnlyCollection<CodeElement> GetVertices()
+    {
+        return Nodes.Values;
+    }
 }

Contracts/GraphInterface/EdgeProperties.cs

@@ -0,0 +1,15 @@
+namespace GraphLib.Contracts;
+
+public class EdgeProperties
+{
+    public double Weight { get; set; } = 1;
+
+    public static EdgeProperties ForWeight(double weight)
+    {
+        var edgeProperties = new EdgeProperties
+        {
+            Weight = weight
+        };
+        return edgeProperties;
+    }
+}

Contracts/GraphInterface/IGraphRepresentation.cs

@@ -0,0 +1,10 @@
+namespace GraphLib.Contracts;
+
+public interface IGraphRepresentation<TVertex>
+{
+    uint VertexCount { get; }
+    IReadOnlyCollection<TVertex> GetNeighbors(TVertex vertex);
+    bool IsVertex(TVertex vertex);
+    bool IsEdge(TVertex source, TVertex target);
+    IReadOnlyCollection<TVertex> GetVertices();
+}

Contracts/GraphInterface/IGraphRepresentationWidthEdgeProperties.cs

@@ -0,0 +1,8 @@
+namespace GraphLib.Contracts;
+
+public interface IGraphRepresentationWidthEdgeProperties<TVertex> : IGraphRepresentation<TVertex>
+{
+    EdgeProperties GetEdgeProperties(TVertex source, TVertex target);
+
+    IGraphRepresentationWidthEdgeProperties<TVertex> Transpose();
+}