Simplify similar_graph via new struct VertexEdgeDataTypes.

Author: jack-dunham

src/abstractdatagraph.jl

@@ -10,6 +10,11 @@ using NamedGraphs: NamedGraphs, AbstractEdges, AbstractNamedEdge, AbstractNamedG
     similar_graph, subgraph_edges
 using SimpleTraits: SimpleTraits, @traitfn, Not
 
+struct VertexEdgeDataTypes{VD, ED}
+    vertex_data_type::VD
+    edge_data_type::ED
+end
+
 abstract type AbstractDataGraph{V, VD, ED} <: AbstractNamedGraph{V} end
 
 vertex_data_type(::Type{<:AbstractGraph}) = Any
@@ -145,21 +150,19 @@ end
 """
     similar_graph(datagraph::AbstractDataGraph, D::Type)
     similar_graph(datagraph::AbstractDataGraph, D::Type, vertices)
-    similar_graph(datagraph::AbstractDataGraph, VD::Type, ED::Type)
-    similar_graph(datagraph::AbstractDataGraph, VD::Type, ED::Type, vertices)
+    similar_graph(datagraph::AbstractDataGraph, D::VertexEdgeDataTypes)
+    similar_graph(datagraph::AbstractDataGraph, D::VertexEdgeDataTypes, vertices)
 
 Create an uninitialized data graph, similar to the provided `datagraph`, but with vertices
 defined by `vertices` and a vertex and edge data type `D`. One may also provide separate
-vertex and edge data types `VD` and `ED`.
+vertex and edge data types `VD` and `ED` by using the wrapper `VertexEdgeDataTypes(VD, ED)`.
 If vertices are not provided, then the graph is constructed with the same vertices and edges
 as the input graph.
 """
-function NamedGraphs.similar_graph(
-        graph::AbstractDataGraph
-    )
-    VD = vertex_data_type(graph)
-    ED = edge_data_type(graph)
-    return similar_graph(graph, VD, ED)
+
+NamedGraphs.similar_graph(graph::AbstractDataGraph, D::Type) = similar_datagraph(graph, D)
+function NamedGraphs.similar_graph(graph::AbstractDataGraph, D::VertexEdgeDataTypes)
+    return similar_datagraph(graph, D)
 end
 
 function NamedGraphs.similar_graph(
@@ -168,37 +171,36 @@ function NamedGraphs.similar_graph(
     )
     VD = vertex_data_type(graph)
     ED = edge_data_type(graph)
-    return similar_graph(graph, VD, ED, vertices)
-end
-function NamedGraphs.similar_graph(
-        graph::AbstractDataGraph,
-        D::Type
-    )
-    return similar_graph(graph, D, D)
+
+    return similar_graph(graph, VertexEdgeDataTypes(VD, ED), vertices)
 end
 
+# Base case(s) (overload these if fallback not wanted).
 function NamedGraphs.similar_graph(
         graph::AbstractDataGraph,
         D::Type,
         vertices
     )
-    return similar_graph(graph, D, D, vertices)
+    return similar_datagraph(graph, D, D, vertices)
 end
-
 function NamedGraphs.similar_graph(
         graph::AbstractDataGraph,
-        VD::Type,
-        ED::Type
+        D::VertexEdgeDataTypes,
+        vertices
     )
-    new_graph = similar_graph(graph, VD, ED, vertices(graph))
+    return similar_datagraph(graph, D.vertex_data_type, D.edge_data_type, vertices)
+end
+
+# Internal implementation functions,
+function similar_datagraph(graph::AbstractGraph, D)
+    new_graph = similar_graph(graph, D, vertices(graph))
     add_edges!(new_graph, edges(graph))
 
     return new_graph
 end
 
-# Base case(s) (overload these if fallback not wanted).
-@traitfn function NamedGraphs.similar_graph(
-        graph::AbstractDataGraph::(!IsDirected),
+@traitfn function similar_datagraph(
+        graph::AbstractGraph::(!IsDirected),
         VD::Type,
         ED::Type,
         vertices
@@ -207,8 +209,8 @@ end
 
     return DataGraph(underlying_graph; vertex_data_type = VD, edge_data_type = ED)
 end
-@traitfn function NamedGraphs.similar_graph(
-        graph::AbstractDataGraph::IsDirected,
+@traitfn function similar_datagraph(
+        graph::AbstractGraph::IsDirected,
         VD::Type,
         ED::Type,
         vertices

src/abstractedgeorvertexdatagraph.jl

@@ -18,25 +18,6 @@ function NamedGraphs.similar_graph(
     )
     return similar_graph(graph, valtype(graph), vertices)
 end
-function NamedGraphs.similar_graph(
-        graph::AbstractVertexOrEdgeDataGraph,
-        T::Type,
-        vertices
-    )
-    return similar_graph(graph, T, Vertices(vertices))
-end
-
-# For ambiguity resolution only.
-function NamedGraphs.similar_graph(
-        graph::AbstractVertexOrEdgeDataGraph,
-        VD::Type,
-        ED::Type
-    )
-    # No notion of both vertex and edge data, will go to `AbstractDataGraph` fallback.
-    new_graph = similar_graph(graph, VD, ED, vertices(graph)) # -> DataGraph
-    add_edges!(new_graph, edges(graph))
-    return new_graph
-end
 
 function Base.copy(graph::AbstractVertexOrEdgeDataGraph)
     graph_dst = similar_graph(graph)
@@ -94,6 +75,11 @@ Base.keytype(::Type{<:AbstractVertexDataGraph{T, V}}) where {T, V} = V
 
 is_edge_assigned(::AbstractVertexDataGraph, _edge) = false
 
+# For method ambiguity resolution,
+# TODO: remove this method once generic `AbstractDataGraph` method is upgraded.
+function set_index_data!(graph::AbstractVertexDataGraph, data, vertex::AbstractEdge)
+    return throw(MethodError(graph, (data, vertex)))
+end
 # `setindex!`
 function set_index_data!(graph::AbstractVertexDataGraph, data, vertex)
     if !has_vertex(graph, vertex)
@@ -145,7 +131,7 @@ end
 function NamedGraphs.similar_graph(
         ::AbstractVertexDataGraph,
         T::Type,
-        vertices::Vertices
+        vertices
     )
     return similar_graph(VertexDataGraph{T}, vertices)
 end
@@ -251,9 +237,9 @@ end
 function NamedGraphs.similar_graph(
         ::AbstractEdgeDataGraph,
         T::Type,
-        vertices::Vertices
+        vertices
     )
-    return similar_graph(EdgeDataGraph{T}, collect(vertices))
+    return similar_graph(EdgeDataGraph{T}, vertices)
 end
 
 function NamedGraphs.induced_subgraph_from_vertices(

src/datagraph.jl

@@ -54,7 +54,7 @@ edge_data_type(G::Type{<:DataGraph}) = eltype(fieldtype(G, :edge_data))
 # Extras
 
 # Overwrite the `AbstractDataGraph` fallback (even though they coincide for `DataGraph`)
-function NamedGraphs.similar_graph(
+function similar_datagraph(
         graph::DataGraph,
         vertex_data_type::Type,
         edge_data_type::Type,

src/edgedatagraph.jl

@@ -110,8 +110,8 @@ for GType in (:EdgeDataGraph, :EdgeDataDiGraph)
             return position_graph(graph.underlying_graph)
         end
 
-        function NamedGraphs.similar_graph(graph::$GType, T::Type, vertices::Vertices)
-            new_graph = $GType{T}(undef, collect(vertices))
+        function NamedGraphs.similar_graph(graph::$GType, T::Type, vertices)
+            new_graph = $GType{T}(undef, vertices)
             return new_graph
         end
 

src/vertexdatagraph.jl

@@ -104,8 +104,8 @@ for GType in (:VertexDataGraph, :VertexDataDiGraph)
             return position_graph(graph.underlying_graph)
         end
 
-        function NamedGraphs.similar_graph(graph::$GType, T::Type, vertices::Vertices)
-            new_graph = $GType{T}(undef, collect(vertices))
+        function NamedGraphs.similar_graph(graph::$GType, T::Type, vertices)
+            new_graph = $GType{T}(undef, vertices)
             return new_graph
         end
 

test/test_basics.jl

@@ -1,15 +1,16 @@
-using DataGraphs: DataGraphs, DataGraph, EdgeDataView, VertexDataView, edge_data,
-    edge_data_type, underlying_graph, vertex_data, vertex_data_type
+using DataGraphs: DataGraphs, DataGraph, EdgeDataView, VertexDataView, VertexEdgeDataTypes,
+    edge_data, edge_data_type, underlying_graph, vertex_data, vertex_data_type
 using Dictionaries: Dictionaries, AbstractDictionary, AbstractIndices, Dictionary,
     IndexError, Indices, dictionary, unset!
 using Graphs: SimpleDiGraph, a_star, add_edge!, bfs_tree, connected_components, degree,
     dfs_tree, dijkstra_shortest_paths, dst, edges, edgetype, grid, has_edge, has_vertex,
     indegree, is_directed, ne, nv, outdegree, path_graph, src, steiner_tree, vertices
 using GraphsFlows: GraphsFlows
-using NamedGraphs.GraphsExtensions: directed_graph, rename_vertices, subgraph, vertextype, ⊔
+using NamedGraphs.GraphsExtensions:
+    directed_graph, empty_graph, rename_vertices, subgraph, vertextype, ⊔
 using NamedGraphs.NamedGraphGenerators: named_grid, named_path_graph
 using NamedGraphs.OrdinalIndexing: nd, rd, st, th
-using NamedGraphs: NamedDiGraph, NamedEdge, NamedGraph, empty_graph, similar_graph
+using NamedGraphs: NamedDiGraph, NamedEdge, NamedGraph, similar_graph
 using Test: @test, @test_broken, @testset
 
 @testset "DataGraphs.jl" begin
@@ -626,13 +627,13 @@ using Test: @test, @test_broken, @testset
         @test has_vertex(g2, "v")
         @test ne(g2) == 0
 
-        g2 = similar_graph(g, Float64, Int)
+        g2 = similar_graph(g, VertexEdgeDataTypes(Float64, Int))
         @test has_vertex(g2, "a")
         @test has_edge(g2, "a" => "b")
         @test vertex_data_type(g2) === Float64
         @test edge_data_type(g2) === Int
 
-        g2 = similar_graph(g, String, Tuple, [:a, :b])
+        g2 = similar_graph(g, VertexEdgeDataTypes(String, Tuple), [:a, :b])
         @test vertex_data_type(g2) === String
         @test edge_data_type(g2) === Tuple
         @test has_vertex(g2, :a)