initial hyperedge impl

Author: SpectraL519

include/gl/edge_descriptor.hpp

@@ -68,13 +68,13 @@ class edge_descriptor final {
     ~edge_descriptor() = default;
 
     [[nodiscard]] bool operator==(const edge_descriptor& other) const noexcept
-    requires(type_traits::is_directed_v<type>)
+    requires(type_traits::c_directed_edge<type>)
     {
         return this->_id == other._id and (this->_vertices == other._vertices);
     }
 
     [[nodiscard]] bool operator==(const edge_descriptor& other) const noexcept
-    requires(type_traits::is_undirected_v<type>)
+    requires(type_traits::c_undirected_edge<type>)
     {
         return this->_id == other._id
            and (this->_vertices == other._vertices
@@ -86,11 +86,11 @@ class edge_descriptor final {
     }
 
     [[nodiscard]] constexpr bool is_directed() const noexcept {
-        return type_traits::is_directed_v<type>;
+        return type_traits::c_directed_edge<type>;
     }
 
     [[nodiscard]] constexpr bool is_undirected() const noexcept {
-        return type_traits::is_undirected_v<type>;
+        return type_traits::c_undirected_edge<type>;
     }
 
     [[nodiscard]] bool is_valid() const noexcept {
@@ -157,7 +157,7 @@ class edge_descriptor final {
         return this->_vertices.first == this->_vertices.second;
     }
 
-    [[nodiscard]] gl_attr_force_inline properties_ref_type properties() const {
+    [[nodiscard]] properties_ref_type properties() const {
         if (not this->is_valid())
             throw std::logic_error("Cannot access properties of an invalid edge");
 

include/gl/edge_tags.hpp

@@ -21,40 +21,38 @@ concept c_edge_directional_tag = c_one_of<T, directed_t, undirected_t>;
 
 } // namespace type_traits
 
-template <type_traits::c_edge_directional_tag EdgeTag, type_traits::c_properties Properties>
+template <type_traits::c_edge_directional_tag DirectionalTag, type_traits::c_properties Properties>
 class edge_descriptor;
 
 namespace type_traits {
 
-template <typename T>
-inline constexpr bool is_directed_v = false;
-
-template <c_instantiation_of<edge_descriptor> EdgeType>
-inline constexpr bool is_directed_v<EdgeType> =
-    std::is_same_v<typename EdgeType::directional_tag, directed_t>;
+// TODO: align docs
 
-template <typename T>
-inline constexpr bool is_undirected_v = false;
+template <typename E>
+concept c_directed_edge =
+    c_instantiation_of<E, edge_descriptor>
+    and std::same_as<typename E::directional_tag, directed_t>;
 
-template <c_instantiation_of<edge_descriptor> EdgeType>
-inline constexpr bool is_undirected_v<EdgeType> =
-    std::is_same_v<typename EdgeType::directional_tag, undirected_t>;
+template <typename E>
+concept c_undirected_edge =
+    c_instantiation_of<E, edge_descriptor>
+    and std::same_as<typename E::directional_tag, undirected_t>;
 
 } // namespace type_traits
 
 struct directed_t {
     using type = std::type_identity_t<directed_t>;
 
     template <type_traits::c_instantiation_of<edge_descriptor> EdgeType>
-    requires(type_traits::is_directed_v<EdgeType>)
+    requires(type_traits::c_directed_edge<EdgeType>)
     [[nodiscard]] gl_attr_force_inline static bool is_incident_from(
         const EdgeType& edge, const types::id_type vertex_id
     ) {
         return vertex_id == edge._vertices.first;
     }
 
     template <type_traits::c_instantiation_of<edge_descriptor> EdgeType>
-    requires(type_traits::is_directed_v<EdgeType>)
+    requires(type_traits::c_directed_edge<EdgeType>)
     [[nodiscard]] gl_attr_force_inline static bool is_incident_to(
         const EdgeType& edge, const types::id_type vertex_id
     ) {
@@ -66,15 +64,15 @@ struct undirected_t {
     using type = std::type_identity_t<undirected_t>;
 
     template <type_traits::c_instantiation_of<edge_descriptor> EdgeType>
-    requires(type_traits::is_undirected_v<EdgeType>)
+    requires(type_traits::c_undirected_edge<EdgeType>)
     [[nodiscard]] gl_attr_force_inline static bool is_incident_from(
         const EdgeType& edge, const types::id_type vertex_id
     ) {
         return edge.is_incident_with(vertex_id);
     }
 
     template <type_traits::c_instantiation_of<edge_descriptor> EdgeType>
-    requires(type_traits::is_undirected_v<EdgeType>)
+    requires(type_traits::c_undirected_edge<EdgeType>)
     [[nodiscard]] gl_attr_force_inline static bool is_incident_to(
         const EdgeType& edge, const types::id_type vertex_id
     ) {

include/gl/graph.hpp

@@ -443,7 +443,7 @@ class graph final {
 
         this->_verify_vertex_id(target_id);
 
-        if constexpr (type_traits::is_directed_v<edge_type>)
+        if constexpr (type_traits::c_directed_edge<edge_type>)
             return this->has_edge(source_id, target_id) or this->has_edge(target_id, source_id);
         else
             return this->has_edge(source_id, target_id);
@@ -528,7 +528,7 @@ class graph final {
 
 private:
     [[nodiscard]] static constexpr std::string _directed_type_str() {
-        return type_traits::is_directed_v<edge_type> ? "directed" : "undirected";
+        return type_traits::c_directed_edge<edge_type> ? "directed" : "undirected";
     }
 
     // --- graph element verification methods ---
@@ -605,7 +605,7 @@ class graph final {
         // print graph size
         os << std::format(
             "{} {} {} {} {}\n",
-            static_cast<int>(type_traits::is_directed_v<edge_type>),
+            static_cast<int>(type_traits::c_directed_edge<edge_type>),
             this->n_vertices(),
             this->n_unique_edges(),
             static_cast<int>(with_vertex_properties),
@@ -651,7 +651,7 @@ class graph final {
         bool directed;
         is >> directed;
 
-        if (directed != type_traits::is_directed_v<edge_type>)
+        if (directed != type_traits::c_directed_edge<edge_type>)
             throw std::ios_base::failure(std::format(
                 "Invalid graph specification: directional tag does not match - should be {}",
                 _directed_type_str()

include/gl/graph_utility.hpp

@@ -6,6 +6,8 @@
 
 #include "graph.hpp"
 
+// move to graph.hpp?
+
 namespace gl {
 
 // --- general graph utility ---
@@ -15,17 +17,13 @@ namespace type_traits {
 template <typename T>
 concept c_graph = c_instantiation_of<T, graph>;
 
-template <c_graph GraphType>
-inline constexpr bool is_directed_v<GraphType> = is_directed_v<typename GraphType::edge_type>;
-
-template <c_graph GraphType>
-inline constexpr bool is_undirected_v<GraphType> = is_undirected_v<typename GraphType::edge_type>;
+// TODO: align docs (removed is_{un}directed_v)
 
-template <typename T>
-concept c_directed_graph = c_graph<T> and is_directed_v<T>;
+template <typename G>
+concept c_directed_graph = c_graph<G> and c_directed_edge<typename G::edge_type>;
 
-template <typename T>
-concept c_undirected_graph = c_graph<T> and is_undirected_v<T>;
+template <typename G>
+concept c_undirected_graph = c_graph<G> and c_undirected_edge<typename G::edge_type>;
 
 } // namespace type_traits
 

include/gl/impl/specialized/adjacency_list.hpp

@@ -47,7 +47,7 @@ namespace detail {
 } // namespace detail
 
 template <type_traits::c_instantiation_of<adjacency_list> AdjacencyList>
-requires(type_traits::is_directed_v<typename AdjacencyList::edge_type>)
+requires(type_traits::c_directed_edge<typename AdjacencyList::edge_type>)
 struct directed_adjacency_list {
     using impl_type = AdjacencyList;
     using edge_type = typename impl_type::edge_type;
@@ -163,7 +163,7 @@ struct directed_adjacency_list {
 };
 
 template <type_traits::c_instantiation_of<adjacency_list> AdjacencyList>
-requires(type_traits::is_undirected_v<typename AdjacencyList::edge_type>)
+requires(type_traits::c_undirected_edge<typename AdjacencyList::edge_type>)
 struct undirected_adjacency_list {
     using impl_type = AdjacencyList;
     using edge_type = typename impl_type::edge_type;
@@ -276,13 +276,13 @@ struct list_impl_traits {
 };
 
 template <type_traits::c_instantiation_of<adjacency_list> AdjacencyList>
-requires(type_traits::is_directed_v<typename AdjacencyList::edge_type>)
+requires(type_traits::c_directed_edge<typename AdjacencyList::edge_type>)
 struct list_impl_traits<AdjacencyList> {
     using type = directed_adjacency_list<AdjacencyList>;
 };
 
 template <type_traits::c_instantiation_of<adjacency_list> AdjacencyList>
-requires(type_traits::is_undirected_v<typename AdjacencyList::edge_type>)
+requires(type_traits::c_undirected_edge<typename AdjacencyList::edge_type>)
 struct list_impl_traits<AdjacencyList> {
     using type = undirected_adjacency_list<AdjacencyList>;
 };

include/gl/impl/specialized/adjacency_matrix.hpp

@@ -45,7 +45,7 @@ inline void check_edge_override(
 } // namespace detail
 
 template <type_traits::c_instantiation_of<adjacency_matrix> AdjacencyMatrix>
-requires(type_traits::is_directed_v<typename AdjacencyMatrix::edge_type>)
+requires(type_traits::c_directed_edge<typename AdjacencyMatrix::edge_type>)
 struct directed_adjacency_matrix {
     using impl_type = AdjacencyMatrix;
     using vertex_type = typename impl_type::vertex_type;
@@ -165,7 +165,7 @@ struct directed_adjacency_matrix {
 };
 
 template <type_traits::c_instantiation_of<adjacency_matrix> AdjacencyMatrix>
-requires(type_traits::is_undirected_v<typename AdjacencyMatrix::edge_type>)
+requires(type_traits::c_undirected_edge<typename AdjacencyMatrix::edge_type>)
 struct undirected_adjacency_matrix {
     using impl_type = AdjacencyMatrix;
     using vertex_type = typename impl_type::vertex_type;
@@ -286,13 +286,13 @@ struct matrix_impl_traits {
 };
 
 template <type_traits::c_instantiation_of<adjacency_matrix> AdjacencyMatrix>
-requires(type_traits::is_directed_v<typename AdjacencyMatrix::edge_type>)
+requires(type_traits::c_directed_edge<typename AdjacencyMatrix::edge_type>)
 struct matrix_impl_traits<AdjacencyMatrix> {
     using type = directed_adjacency_matrix<AdjacencyMatrix>;
 };
 
 template <type_traits::c_instantiation_of<adjacency_matrix> AdjacencyMatrix>
-requires(type_traits::is_undirected_v<typename AdjacencyMatrix::edge_type>)
+requires(type_traits::c_undirected_edge<typename AdjacencyMatrix::edge_type>)
 struct matrix_impl_traits<AdjacencyMatrix> {
     using type = undirected_adjacency_matrix<AdjacencyMatrix>;
 };

include/gl/topology/binary_tree.hpp

@@ -46,7 +46,7 @@ template <type_traits::c_graph GraphType>
 
 template <type_traits::c_graph GraphType>
 [[nodiscard]] GraphType bidirectional_regular_binary_tree(const types::size_type depth) {
-    if constexpr (type_traits::is_directed_v<GraphType>) {
+    if constexpr (type_traits::c_directed_graph<GraphType>) {
         if (depth < detail::min_non_trivial_bin_tree_depth)
             return GraphType{depth};
 

include/gl/topology/bipartite.hpp

@@ -19,7 +19,7 @@ template <type_traits::c_graph GraphType>
     for (types::id_type source_id = constants::initial_id; source_id < n_vertices_a; ++source_id) {
         for (types::id_type target_id = n_vertices_a; target_id < n_vertices; ++target_id) {
             graph.add_edge(source_id, target_id);
-            if constexpr (type_traits::is_directed_v<GraphType>)
+            if constexpr (type_traits::c_directed_graph<GraphType>)
                 graph.add_edge(target_id, source_id);
         }
     }

include/gl/topology/clique.hpp

@@ -16,7 +16,7 @@ template <type_traits::c_graph GraphType>
     for (types::id_type source_id = constants::initial_id; source_id < n_vertices; ++source_id) {
         for (types::id_type target_id = constants::initial_id; target_id < source_id; ++target_id) {
             graph.add_edge(source_id, target_id);
-            if constexpr (type_traits::is_directed_v<GraphType>)
+            if constexpr (type_traits::c_directed_graph<GraphType>)
                 graph.add_edge(target_id, source_id);
         }
     }

include/gl/topology/cycle.hpp

@@ -21,7 +21,7 @@ template <type_traits::c_graph GraphType>
 
 template <type_traits::c_graph GraphType>
 [[nodiscard]] GraphType bidirectional_cycle(const types::size_type n_vertices) {
-    if constexpr (type_traits::is_directed_v<GraphType>) {
+    if constexpr (type_traits::c_directed_graph<GraphType>) {
         GraphType graph{n_vertices};
 
         for (types::id_type source_id = constants::initial_id; source_id < n_vertices;