Implemented an overload of the graph::isConnected() function which reports whether a Graph is a strongly-connected component.

Author: Mandrenkov

src/h/graph.h

@@ -43,6 +43,10 @@ namespace ctgl {
         template <typename G, typename N>
         constexpr auto getOutgoingEdges(G, N) noexcept;
 
+        // Reports whether the provided Graph is a strongly-connected component.
+        template <typename G>
+        constexpr bool isConnected(G) noexcept;
+
         // Reports whether Node |T| is reachable from Node |S| in the provided Graph.
         template <typename G, typename S, typename T>
         constexpr bool isConnected(G, S, T) noexcept;
@@ -126,6 +130,24 @@ namespace ctgl {
             return List<>{};
         }
 
+        template <typename G>
+        constexpr bool isConnected(G) noexcept {
+            // A Graph is a strongly-connected component if there exists a cycle
+            // which includes all Nodes in the Graph.
+            constexpr auto nodes = typename G::Nodes{};
+            return isConnected(G{}, nodes + nodes);
+        }
+
+        template <typename G, typename T1, typename T2, typename... Ts>
+        constexpr bool isConnected(G, List<T1, T2, Ts...>) noexcept {
+            return isConnected(G{}, T1{}, T2{}) && isConnected(G{}, List<T2, Ts...>{});
+        }
+
+        template <typename G, typename... Ts>
+        constexpr bool isConnected(G, List<Ts...>) noexcept {
+            return true;
+        }
+
         template <typename G, typename S, typename T>
         constexpr bool isConnected(G, S, T) noexcept {
             constexpr auto nodes = typename G::Nodes{};

src/test/graph_test.cpp

@@ -84,38 +84,54 @@ TEST(GraphTest, GetOutgoingEdges) {
     EXPECT_EQ(getOutgoingEdges(Leap{}, N3{}), List<>{});
 }
 
-// Unit tests for the ctgl::graph::isConnected() function.
+// Unit tests for the ctgl::graph::isConnected() functions.
 TEST(GraphTest, IsConnected) {
     // Empty
+    EXPECT_TRUE(isConnected(Empty{}));
     EXPECT_FALSE(isConnected(Empty{}, N1{}, N1{}));
     EXPECT_FALSE(isConnected(Empty{}, N1{}, N2{}));
 
     // Island
+    EXPECT_TRUE(isConnected(Island{}));
     EXPECT_TRUE(isConnected(Island{}, N1{}, N1{}));
     EXPECT_FALSE(isConnected(Island{}, N1{}, N2{}));
     EXPECT_FALSE(isConnected(Island{}, N2{}, N1{}));
 
     // Loopback
+    EXPECT_TRUE(isConnected(Loopback{}));
     EXPECT_TRUE(isConnected(Loopback{}, N1{}, N1{}));
     EXPECT_FALSE(isConnected(Loopback{}, N1{}, N2{}));
 
     // Arrow
+    EXPECT_FALSE(isConnected(Arrow{}));
     EXPECT_TRUE(isConnected(Arrow{}, N1{}, N2{}));
     EXPECT_FALSE(isConnected(Arrow{}, N2{}, N1{}));
 
     // Bridge
+    EXPECT_TRUE(isConnected(Bridge{}));
     EXPECT_TRUE(isConnected(Bridge{}, N1{}, N2{}));
     EXPECT_TRUE(isConnected(Bridge{}, N2{}, N1{}));
 
     // Leap
+    EXPECT_FALSE(isConnected(Leap{}));
     EXPECT_TRUE(isConnected(Leap{}, N1{}, N2{}));
     EXPECT_TRUE(isConnected(Leap{}, N1{}, N3{}));
     EXPECT_TRUE(isConnected(Leap{}, N2{}, N3{}));
     EXPECT_FALSE(isConnected(Leap{}, N2{}, N1{}));
     EXPECT_FALSE(isConnected(Leap{}, N3{}, N1{}));
     EXPECT_FALSE(isConnected(Leap{}, N3{}, N2{}));
 
+    // Triangle
+    EXPECT_TRUE(isConnected(Triangle{}));
+    EXPECT_TRUE(isConnected(Triangle{}, N1{}, N2{}));
+    EXPECT_TRUE(isConnected(Triangle{}, N1{}, N3{}));
+    EXPECT_TRUE(isConnected(Triangle{}, N2{}, N1{}));
+    EXPECT_TRUE(isConnected(Triangle{}, N2{}, N3{}));
+    EXPECT_TRUE(isConnected(Triangle{}, N3{}, N1{}));
+    EXPECT_TRUE(isConnected(Triangle{}, N3{}, N2{}));
+
     // Pan
+    EXPECT_FALSE(isConnected(Pan{}));
     EXPECT_TRUE(isConnected(Pan{}, N1{}, N2{}));
     EXPECT_TRUE(isConnected(Pan{}, N1{}, N3{}));
     EXPECT_TRUE(isConnected(Pan{}, N1{}, N4{}));