Add constructor and fix traits

Author: gdalle

src/directedness.jl

@@ -1,3 +1,13 @@
+function Graphs.is_directed(::MetaGraph{Code,Graph}) where {Code,Graph<:AbstractGraph}
+    return is_directed(Graph)
+end
+
+function Graphs.is_directed(
+    ::Type{<:MetaGraph{Code,Graph}}
+) where {Code,Graph<:AbstractGraph}
+    return is_directed(Graph)
+end
+
 """
     arrange(graph, label_1, label_2)
 
@@ -6,14 +16,14 @@ Sort two vertex labels in a default order (useful to uniquely express undirected
 function arrange end
 
 @traitfn function arrange(
-    ::AG::IsDirected, label_1, label_2, _drop...
-) where {T,AG<:AbstractGraph{T}}
+    ::MG, label_1, label_2, _drop...
+) where {MG <: MetaGraph; IsDirected{MG}}
     return label_1, label_2
 end
 
 @traitfn function arrange(
-    ::AG::(!IsDirected), label_1, label_2, code_1, code_2
-) where {T,AG<:AbstractGraph{T}}
+    ::MG, label_1, label_2, code_1, code_2
+) where {MG <: MetaGraph; !IsDirected{MG}}
     if code_1 < code_2
         (label_1, label_2)
     else
@@ -22,8 +32,8 @@ end
 end
 
 @traitfn function arrange(
-    meta_graph::AG::(!IsDirected), label_1, label_2
-) where {T,AG<:AbstractGraph{T}}
+    meta_graph::MG, label_1, label_2
+) where {MG <: MetaGraph; !IsDirected{MG}}
     return arrange(
         meta_graph,
         label_1,

src/graphs.jl

@@ -10,29 +10,35 @@ end
 function Graphs.edgetype(meta_graph::MetaGraph)
     return edgetype(meta_graph.graph)
 end
+
 function Graphs.nv(meta_graph::MetaGraph)
     return nv(meta_graph.graph)
 end
+
 function Graphs.ne(meta_graph::MetaGraph)
     return ne(meta_graph.graph)
 end
+
 function Graphs.vertices(meta_graph::MetaGraph)
     return vertices(meta_graph.graph)
 end
+
 function Graphs.edges(meta_graph::MetaGraph)
     return edges(meta_graph.graph)
 end
 
 function Graphs.has_vertex(meta_graph::MetaGraph, code::Integer)
     return has_vertex(meta_graph.graph, code)
 end
+
 function Graphs.has_edge(meta_graph::MetaGraph, code_1::Integer, code_2::Integer)
     return has_edge(meta_graph.graph, code_1, code_2)
 end
 
 function Graphs.inneighbors(meta_graph::MetaGraph, code::Integer)
     return inneighbors(meta_graph.graph, code)
 end
+
 function Graphs.outneighbors(meta_graph::MetaGraph, code::Integer)
     return outneighbors(meta_graph.graph, code)
 end
@@ -41,18 +47,6 @@ function Base.issubset(meta_graph::MetaGraph, h::MetaGraph)
     return issubset(meta_graph.graph, h.graph)
 end
 
-function Graphs.is_directed(
-    ::MetaGraph{Code,Label,Graph}
-) where {Code,Label,Graph<:AbstractGraph}
-    return is_directed(Graph)
-end
-
-function Graphs.is_directed(
-    ::Type{<:MetaGraph{Code,Label,Graph}}
-) where {Code,Label,Graph<:AbstractGraph}
-    return is_directed(Graph)
-end
-
 ## Link between graph codes and metagraph labels
 
 """
@@ -205,6 +199,22 @@ end
 
 ## Miscellaneous
 
+function Base.copy(meta_graph::MetaGraph)
+    return deepcopy(meta_graph)
+end
+
+function Base.zero(meta_graph::MetaGraph)
+    return MetaGraph(
+        zero(meta_graph.graph),
+        empty(meta_graph.vertex_labels),
+        empty(meta_graph.vertex_properties),
+        empty(meta_graph.edge_data),
+        deepcopy(meta_graph.graph_data),
+        deepcopy(meta_graph.weight_function),
+        deepcopy(meta_graph.default_weight),
+    )
+end
+
 function Graphs.induced_subgraph(
     meta_graph::MetaGraph, vertex_codes::AbstractVector{<:Integer}
 )
@@ -222,7 +232,7 @@ function Graphs.induced_subgraph(
     return new_graph, code_map
 end
 
-@traitfn function Graphs.reverse(meta_graph::MetaGraph::IsDirected)
+@traitfn function Graphs.reverse(meta_graph::MG) where {MG <: MetaGraph; IsDirected{MG}}
     edge_data = meta_graph.edge_data
     reverse_edge_data = empty(edge_data)
     for (label_1, label_2) in keys(edge_data)

src/metagraph.jl

@@ -1,13 +1,13 @@
 """
     MetaGraph{
         Code<:Integer,
+        Graph<:AbstractGraph{Code},
         Label,
-        Graph,
         VertexData,
         EdgeData,
         GraphData,
         WeightFunction,
-        Weight<:Real
+        Weight
     } <: AbstractGraph{Code}
 
 A graph type with custom vertex labels containing vertex-, edge- and graph-level metadata.
@@ -19,13 +19,20 @@ It is recommended not to set `Label` to an integer type, so as to avoid confusio
 - `graph::Graph`: underlying, data-less graph with vertex indices of type `Code`
 - `vertex_labels::Dict{Code,Label}`: dictionary mapping vertex codes to vertex labels
 - `vertex_properties::Dict{Label,Tuple{Code,VertexData}}`: dictionary mapping vertex labels to vertex codes & data
-- `edge_data::Dict{Tuple{Label,Label},EdgeData}`: dictionary mapping edge labels such as `(label_u, label_v)` to edge metadata
-- `graph_data::GraphData`: graph metadata
-- `weight_function::WeightFunction`: function defining edge weight from edge metadata
-- `default_weight::Weight`: default weight for the edges
+- `edge_data::Dict{Tuple{Label,Label},EdgeData}`: dictionary mapping edge labels such as `(label_u, label_v)` to edge data
+- `graph_data::GraphData`: global data for the graph object
+- `weight_function::WeightFunction`: function computing edge weight from edge data, its output must have the same type as `default_weight`
+- `default_weight::Weight`: default weight used when an edge doesn't exist
 """
 struct MetaGraph{
-    Code<:Integer,Label,Graph,VertexData,EdgeData,GraphData,WeightFunction,Weight<:Real
+    Code<:Integer,
+    Graph<:AbstractGraph{Code},
+    Label,
+    VertexData,
+    EdgeData,
+    GraphData,
+    WeightFunction,
+    Weight,
 } <: AbstractGraph{Code}
     graph::Graph
     vertex_labels::Dict{Code,Label}
@@ -36,68 +43,107 @@ struct MetaGraph{
     default_weight::Weight
 end
 
+"""
+    MetaGraph(
+        graph,
+        vertices_description,
+        edges_description,
+        graph_data=nothing,
+        weight_function=edge_data -> 1.0,
+        default_weight=1.0,
+    )
+
+Construct a non-empty `MetaGraph` based on lists of vertices and edges with their labels and data.
+
+These lists must be constructed as follows:
+- `vertices_description` is a vector of pairs `label => data` (the code of a vertex will correspond to its rank in the list)
+- `edges_description` is a vector of pairs `(label1, label2) => data`
+
+Furthermore, they must be coherent with the `graph` argument, i.e. describe the same set of vertices and edges.
+"""
+function MetaGraph(
+    graph::AbstractGraph{Code},
+    vertices_description::Vector{Pair{Label,VertexData}},
+    edges_description::Vector{Pair{Tuple{Label,Label},EdgeData}},
+    graph_data=nothing,
+    weight_function=edge_data -> 1.0,
+    default_weight=1.0,
+) where {Code,Label,VertexData,EdgeData}
+    # Construct vertex data
+    @assert length(vertices_description) == nv(graph)
+    vertex_labels = Dict{Code,Label}()
+    vertex_properties = Dict{Label,Tuple{Code,VertexData}}()
+    for (code, (label, data)) in enumerate(vertices_description)
+        vertex_labels[code] = label
+        vertex_properties[label] = (code, data)
+    end
+    # Construct edge data
+    @assert length(edges_description) == ne(graph)
+    for ((label_1, label_2), _) in edges_description
+        code_1 = vertex_properties[label_1][1]
+        code_2 = vertex_properties[label_2][1]
+        @assert has_edge(graph, code_1, code_2)
+    end
+    edge_data = Dict{Tuple{Label,Label},EdgeData}()
+    for ((label_1, label_2), data) in edges_description
+        edge_data[label_1, label_2] = data
+    end
+    return MetaGraph(
+        graph,
+        vertex_labels,
+        vertex_properties,
+        edge_data,
+        graph_data,
+        weight_function,
+        default_weight,
+    )
+end
+
 """
     MetaGraph(
         graph;
-        Label = Symbol,
-        VertexData = Nothing,
-        EdgeData = Nothing,
-        graph_data = nothing,
-        weight_function = edge_data -> 1.0,
-        default_weight = 1.0
+        Label=Symbol,
+        VertexData=Nothing,
+        EdgeData=Nothing,
+        graph_data=nothing,
+        weight_function=edge_data -> 1.0,
+        default_weight=1.0
     )
 
 Construct an empty `MetaGraph` with the given metadata types and weights.
+
+!!! danger "Warning"
+    This constructor is not type-stable, it is only there for convenience.
 """
 function MetaGraph(
     graph::AbstractGraph{Code};
     Label=Symbol,
     VertexData=Nothing,
     EdgeData=Nothing,
     graph_data=nothing,
-    weight_function=edata -> 1.0,
+    weight_function=edge_data -> 1.0,
     default_weight=1.0,
 ) where {Code}
+    @assert nv(graph) == 0
     if Label <: Integer
         @warn "Constructing a MetaGraph with integer labels is not advised."
-    elseif nv(graph) > 0
-        @warn "Constructing a MetaGraph with a nonempty underlying graph is not advised."
     end
+    vertex_labels = Dict{Code,Label}()
+    vertex_properties = Dict{Label,Tuple{Code,VertexData}}()
+    edge_data = Dict{Tuple{Label,Label},EdgeData}()
     return MetaGraph(
         graph,
-        Dict{Code,Label}(),
-        Dict{Label,Tuple{Code,VertexData}}(),
-        Dict{Tuple{Label,Label},EdgeData}(),
+        vertex_labels,
+        vertex_properties,
+        edge_data,
         graph_data,
         weight_function,
         default_weight,
     )
 end
 
-function Base.zero(
-    meta_graph::MetaGraph{Code,Label,Graph,VertexData,EdgeData}
-) where {Code,Label,Graph,VertexData,EdgeData}
-    return MetaGraph(
-        Graph();
-        Label=Label,
-        VertexData=VertexData,
-        EdgeData=EdgeData,
-        graph_data=meta_graph.graph_data,
-        weight_function=meta_graph.weight_function,
-        default_weight=meta_graph.default_weight,
-    )
-end
-
-function Base.:(==)(meta_graph_1::MetaGraph, meta_graph_2::MetaGraph)
-    return meta_graph_1.graph == meta_graph_2.graph
-end
-
-function Base.copy(meta_graph::MetaGraph)
-    return deepcopy(meta_graph)
-end
-
 function Base.show(
-    io::IO, meta_graph::MetaGraph{<:Any,Label,<:Any,VertexData,EdgeData}
+    io::IO, meta_graph::MetaGraph{<:Any,<:Any,Label,VertexData,EdgeData}
 ) where {Label,VertexData,EdgeData}
     print(
         io,

test/tutorial/2_graphs.jl

@@ -81,7 +81,7 @@ has_edge(cities, 2, 3)
 # From this initial graph, we can create some others:
 
 copy(cities)
-@test copy(cities) == cities  #src
+@test copy(cities).graph == cities.graph  #src
 #-
 zero(cities)
 @test nv(zero(cities)) == 0  #src

test/tutorial/3_files.jl

@@ -16,8 +16,8 @@ example2 = mktemp() do file, io
     loadgraph(file, "something", MGFormat())
 end
 
-example2 == example
-@test example2 == example  #src
+example2.graph == example.graph
+@test example2.graph == example.graph  #src
 
 # ## DOTFormat