Merge pull request #118 from stdgraph/edge_id

Remove edge_id(g,uv) and edge_id_t<G>

Author: pratzl

include/graph/detail/graph_cpo.hpp

@@ -1333,101 +1333,6 @@ inline namespace _Cpos {
 }
 
 
-//
-// edge_id(g,uv) -> edge_id_t<G>
-//      default = edge_id_t<G>(source_id(g,uv),target_id(g,uv))
-//
-// edge_id_t<G> = edge_descriptor<vertex_id_t<_G>, true, void, void>
-//
-template <class _G>
-using edge_id_t = edge_descriptor<vertex_id_t<_G>, true, void, void>; // {source_id, target_id}
-
-namespace _Edge_id {
-#  if defined(__clang__) || defined(__EDG__) // TRANSITION, VSO-1681199
-  void edge_id() = delete;                   // Block unqualified name lookup
-#  else                                      // ^^^ no workaround / workaround vvv
-  void edge_id();
-#  endif                                     // ^^^ workaround ^^^
-
-  template <class _G>
-  concept _Has_ref_member = requires(_G&& __g, edge_reference_t<_G> uv) {
-    { uv.edge_id(__g) } -> convertible_to<edge_id_t<_G>>;
-  };
-  template <class _G>
-  concept _Has_ref_ADL = _Has_class_or_enum_type<_G> //
-                         && requires(_G&& __g, const edge_reference_t<_G>& uv) {
-                              { _Fake_copy_init(edge_id(__g, uv)) } -> convertible_to<edge_id_t<_G>>; // intentional ADL
-                            };
-
-  template <class _G>
-  concept _Can_id_eval = _Has_class_or_enum_type<_G> //
-                         && requires(_G&& __g, edge_reference_t<_G> uv) {
-                              { _Fake_copy_init(edge_id_t<_G>{source_id(__g, uv), target_id(__g, uv)}) };
-                            };
-  class _Cpo {
-  private:
-    enum class _St_ref { _None, _Member, _Non_member, _Auto_eval };
-
-    template <class _G>
-    [[nodiscard]] static consteval _Choice_t<_St_ref> _Choose_ref() noexcept {
-      static_assert(is_lvalue_reference_v<_G>);
-      if constexpr (_Has_ref_member<_G>) {
-        return {_St_ref::_Member, noexcept(_Fake_copy_init(declval<edge_reference_t<_G>>().edge_id(declval<_G>())))};
-      } else if constexpr (_Has_ref_ADL<_G>) {
-        return {_St_ref::_Non_member,
-                noexcept(_Fake_copy_init(edge_id(declval<_G>(), declval<edge_reference_t<_G>>())))}; // intentional ADL
-      } else if constexpr (_Can_id_eval<_G>) {
-        return {_St_ref::_Auto_eval,
-                noexcept(_Fake_copy_init(edge_id_t<_G>{source_id(declval<_G>(), declval<edge_reference_t<_G>>()),
-                                                       target_id(declval<_G>(), declval<edge_reference_t<_G>>())}))};
-      } else {
-        return {_St_ref::_None};
-      }
-    }
-
-    template <class _G>
-    static constexpr _Choice_t<_St_ref> _Choice_ref = _Choose_ref<_G>();
-
-  public:
-    /**
-     * @brief The id of an edge, made from its source_id and target_id.
-     * 
-     * Complexity: O(1)
-     * 
-     * Default implementation: 
-     *      edge_descriptor<vertex_id_t<G>,true>{source_id(g,uv), target_id(g,uv)}
-     *      given that source_id(g,uv) is defined.
-     * 
-     * @tparam G The graph type.
-     * @param g  A graph instance.
-     * @param uv An edge reference.
-     * @return An edge_descriptor with the source_id and target_id.
-    */
-    template <class _G>
-    requires(_Choice_ref<_G&>._Strategy != _St_ref::_None)
-    [[nodiscard]] constexpr auto operator()(_G&& __g, edge_reference_t<_G> uv) const
-          noexcept(_Choice_ref<_G&>._No_throw) {
-      constexpr _St_ref _Strat_ref = _Choice_ref<_G&>._Strategy;
-
-      if constexpr (_Strat_ref == _St_ref::_Member) {
-        return uv.edge_id(__g);
-      } else if constexpr (_Strat_ref == _St_ref::_Non_member) {
-        return edge_id(__g, uv); // intentional ADL
-      } else if constexpr (_Strat_ref == _St_ref::_Auto_eval) {
-        return edge_id_t<_G>{source_id(__g, uv), target_id(__g, uv)};
-      } else {
-        static_assert(_Always_false<_G>,
-                      "edge_id(g,uv) is not defined, or target_id(g,uv) and source_id(g,uv) are not defined");
-      }
-    }
-  };
-} // namespace _Edge_id
-
-inline namespace _Cpos {
-  inline constexpr _Edge_id::_Cpo edge_id;
-}
-
-
 //
 // find_vertex_edge(g,u,vid) -> vertex_edge_iterator<G>
 //      default = find(edges(g,u), [](uv) {target_id(g,uv)==vid;}

include/graph/edgelist.hpp

@@ -43,7 +43,6 @@
 // source_id(e)
 // target_id(e)
 // edge_value(e)
-// edge_id(e) (todo)
 //
 // Edge definitions supported without overrides
 // -----------------------------------------------------------------------------
@@ -132,9 +131,6 @@ namespace edgelist {
   template <basic_sourced_edgelist EL> // For exposition only
   using edge_value_t = decltype(edge_value(declval<edge_t<edge_range_t<EL>>>()));
 
-  template <basic_sourced_edgelist EL> // For exposition only
-  using edge_id_t = decltype(edge_id(declval<edge_t<edge_range_t<EL>>>()));
-
   template <basic_sourced_edgelist EL> // For exposition only
   using vertex_id_t = decltype(source_id(declval<edge_t<edge_range_t<EL>>>()));
 

include/graph/graph.hpp

@@ -79,10 +79,8 @@ concept basic_targeted_edge = requires(G&& g, edge_reference_t<G> uv) { target_i
 template <class G> // For exposition only
 concept basic_sourced_edge = requires(G&& g, edge_reference_t<G> uv) { source_id(g, uv); };
 
-template <class G>                                              // For exposition only
-concept basic_sourced_targeted_edge = basic_targeted_edge<G> && //
-                                      basic_sourced_edge<G> &&  //
-                                      requires(G&& g, edge_reference_t<G> uv) { edge_id(g, uv); };
+template <class G> // For exposition only
+concept basic_sourced_targeted_edge = basic_targeted_edge<G> && basic_sourced_edge<G>;
 
 
 /**
@@ -102,10 +100,8 @@ template <class G>                              // For exposition only
 concept sourced_edge = basic_sourced_edge<G> && //
                        requires(G&& g, edge_reference_t<G> uv) { source(g, uv); };
 
-template <class G>                                  // For exposition only
-concept sourced_targeted_edge = targeted_edge<G> && //
-                                sourced_edge<G> &&  //
-                                requires(G&& g, edge_reference_t<G> uv) { edge_id(g, uv); };
+template <class G> // For exposition only
+concept sourced_targeted_edge = targeted_edge<G> && sourced_edge<G>;
 
 
 /**
@@ -380,7 +376,7 @@ concept has_contains_edge = requires(G&& g, vertex_id_t<G> uid, vertex_id_t<G> v
 template <class G>
 struct define_unordered_edge : public false_type {}; // specialized for graph container edge
 
-template <class G> // For exposition only
+template <class G>                                   // For exposition only
 concept unordered_edge = basic_sourced_edge<G> && define_unordered_edge<G>::value;
 
 //