Rename fields and types

Author: gdalle

README.md

@@ -4,4 +4,4 @@
 [![Build Status](https://github.com/JuliaGraphs/MetaGraphsNext.jl/actions/workflows/test.yml/badge.svg?branch=master)](https://github.com/JuliaGraphs/MetaGraphsNext.jl/actions/workflows/test.yml?query=branch%3Amaster)
 [![CodeCov](https://codecov.io/gh/JuliaGraphs/MetaGraphsNext.jl/branch/master/graph/badge.svg)](https://codecov.io/gh/JuliaGraphs/MetaGraphsNext.jl)
 
-Welcome to `MetaGraphsNext.jl`, an experimental, type-stable replacement for [MetaGraphs](https://github.com/JuliaGraphs/MetaGraphs.jl). Take a look at the [documentation](https://juliagraphs.org/MetaGraphsNext.jl/dev/) to know more!
+Welcome to MetaGraphsNext, an experimental, type-stable replacement for [MetaGraphs](https://github.com/JuliaGraphs/MetaGraphs.jl). This package will let you store metadata on the vertices and edges of your graphs. Take a look at the [documentation](https://juliagraphs.org/MetaGraphsNext.jl/dev/) to learn more!

docs/src/tutorial_basics.md

@@ -11,7 +11,7 @@ julia> using MetaGraphsNext
 We provide a default constructor in which you only need to specify types:
 
 ```jldoctest example
-julia> colors = MetaGraph( Graph(), VertexMeta = String, EdgeMeta = Symbol, gprops = "graph_of_colors")
+julia> colors = MetaGraph( Graph(), VertexData = String, EdgeData = Symbol, graph_data = "graph_of_colors")
 Meta graph based on a {0, 0} undirected simple Int64 graph with vertex labels of type Symbol, vertex metadata of type String, edge metadata of type Symbol, graph metadata given by "graph_of_colors", and default weight 1.0
 ```
 
@@ -109,19 +109,19 @@ julia> label_for(colors, 3)
 The most simple way to add edge weights is to speficy a default weight for all of them.
 
 ```jldoctest example
-julia> weighted_default = MetaGraph(Graph(), defaultweight = 2);
+julia> weighted_default = MetaGraph(Graph(), default_weight = 2);
 
-julia> defaultweight(weighted_default)
+julia> default_weight(weighted_default)
 2
 
 julia> weighttype(weighted_default)
 Int64
 ```
 
-You can use the `weightfunction` keyword to specify a function which will transform edge metadata into a weight. This weight must always be the same type as the `defaultweight`.
+You can use the `weight_function` keyword to specify a function which will transform edge metadata into a weight. This weight must always be the same type as the `default_weight`.
 
 ```jldoctest example
-julia> weighted = MetaGraph(Graph(), EdgeMeta = Float64, weightfunction = identity);
+julia> weighted = MetaGraph(Graph(), EdgeData = Float64, weight_function = identity);
 
 julia> weighted[:red] = nothing; weighted[:blue] = nothing; weighted[:yellow] = nothing;
 
@@ -136,7 +136,7 @@ julia> size(weight_matrix)
 julia> weight_matrix[1, 3]
 1.0
 
-julia> weightfunction(weighted)(0)
+julia> weight_function(weighted)(0)
 0
 ```
 

docs/src/tutorial_files.md

@@ -24,9 +24,9 @@ graph T {
 }
 
 julia> complicated = MetaGraph(DiGraph(),
-            VertexMeta = Dict{Symbol, Int},
-            EdgeMeta = Dict{Symbol, Int},
-            gprops = (tagged = true,)
+            VertexData = Dict{Symbol, Int},
+            EdgeData = Dict{Symbol, Int},
+            graph_data = (tagged = true,)
         );
 
 julia> complicated[:a] = Dict(:code_1 => 1, :code_2 => 2);

docs/src/tutorial_graphs.md

@@ -15,7 +15,7 @@ Note that vertex codes get reassigned after `rem_vertex!` operations to remain c
 We can make `MetaGraph`s based on (undirected) `Graph`s.
 
 ```jldoctest graphs
-julia> cities = MetaGraph(Graph(), VertexMeta = String, EdgeMeta = Int, gprops = nothing, weightfunction = identity, defaultweight = 0);
+julia> cities = MetaGraph(Graph(), VertexData = String, EdgeData = Int, weight_function = identity, default_weight = 0);
 ```
 
 Let us add some cities and the distance between them:
@@ -127,7 +127,7 @@ false
 We can make `MetaGraph`s based on `DiGraph`s as well.
 
 ```jldoctest graphs
-julia> rock_paper_scissors = MetaGraph(DiGraph(), Label = Symbol, EdgeMeta = Symbol);
+julia> rock_paper_scissors = MetaGraph(DiGraph(), Label = Symbol, EdgeData = Symbol);
 
 julia> for label in [:rock, :paper, :scissors]; rock_paper_scissors[label] = nothing; end;
 

src/MetaGraphsNext.jl

@@ -5,7 +5,7 @@ using Graphs
 
 export MetaGraph, MetaDiGraph, MetaUndirectedGraph
 export label_for, code_for, set_data
-export weighttype, defaultweight, weightfunction
+export weighttype, default_weight, weight_function
 export MGFormat, DOTFormat
 
 include("metagraph.jl")

src/dict_utils.jl

@@ -3,28 +3,28 @@
 
 Return graph metadata.
 """
-Base.getindex(g::MetaGraph) = g.gprops
+Base.getindex(g::MetaGraph) = g.graph_data
 
 """
     getindex(g, label)
 
 Return vertex metadata for `label`.
 """
-Base.getindex(g::MetaGraph, label) = g.vprops[label]
+Base.getindex(g::MetaGraph, label) = g.vertex_data[label]
 
 """
     getindex(g, label_1, label_2)
 
 Return edge metadata for the edge between `label_1` and `label_2`.
 """
-Base.getindex(g::MetaGraph, label_1, label_2) = g.eprops[arrange(g, label_1, label_2)]
+Base.getindex(g::MetaGraph, label_1, label_2) = g.edge_data[arrange(g, label_1, label_2)]
 
 """
     haskey(g, label)
 
 Determine whether a graph `g` contains the vertex `label`.
 """
-Base.haskey(g::MetaGraph, label) = haskey(g.vprops, label)
+Base.haskey(g::MetaGraph, label) = haskey(g.vertex_data, label)
 
 """
     haskey(g, label_1, label_2)
@@ -37,7 +37,7 @@ function Base.haskey(g::MetaGraph, label_1, label_2)
     return (
         haskey(g, label_1) &&
         haskey(g, label_2) &&
-        haskey(g.eprops, arrange(g, label_1, label_2))
+        haskey(g.edge_data, arrange(g, label_1, label_2))
     )
 end
 
@@ -100,18 +100,18 @@ Copy properties from `oldg` to `newg` following vertex map `vmap`.
 """
 function _copy_props!(oldg::G, newg::G, vmap) where {G<:MetaGraph}
     for (newv, oldv) in enumerate(vmap)
-        oldl = oldg.labels[oldv]
-        data = oldg.vprops[oldl]
-        newg.labels[newv] = oldl
-        newg.vcodes[oldl] = newv
-        newg.vprops[oldl] = data
+        oldl = oldg.vertex_labels[oldv]
+        data = oldg.vertex_data[oldl]
+        newg.vertex_labels[newv] = oldl
+        newg.vertex_codes[oldl] = newv
+        newg.vertex_data[oldl] = data
     end
     for newe in edges(newg.graph)
-        labels = newg.labels
+        vertex_labels = newg.vertex_labels
         v1, v2 = Tuple(newe)
-        label_1 = labels[v1]
-        label_2 = labels[v2]
-        newg.eprops[arrange(newg, label_1, label_2, v1, v2)] = oldg.eprops[arrange(
+        label_1 = vertex_labels[v1]
+        label_2 = vertex_labels[v2]
+        newg.edge_data[arrange(newg, label_1, label_2, v1, v2)] = oldg.edge_data[arrange(
             oldg, label_1, label_2
         )]
     end

src/graphs.jl

@@ -24,7 +24,7 @@ Find the vertex code (or index) associated with label `label`.
 
 This can be useful to pass to methods inherited from `Graphs`. Note, however, that vertex codes can be reassigned after vertex deletion.
 """
-code_for(g::MetaGraph, label) = g.vcodes[label]
+code_for(g::MetaGraph, label) = g.vertex_codes[label]
 
 """
     label_for(g::MetaGraph, v)
@@ -33,7 +33,7 @@ Find the label associated with code `v`.
 
 This can be useful to interpret the results of methods inherited from `Graphs`. Note, however, that vertex codes can be reassigned after vertex deletion.
 """
-label_for(g::MetaGraph, v::Integer) = g.labels[v]
+label_for(g::MetaGraph, v::Integer) = g.vertex_labels[v]
 
 ## Set vertex and edge data
 
@@ -45,8 +45,8 @@ Set vertex metadata for `label` to `data`.
 Return `true` if the operation succeeds, and `false` if `g` has no such vertex.
 """
 function set_data!(g::MetaGraph, label, data)
-    if haskey(g.vprops, label)
-        g.vprops[label] = data
+    if haskey(g.vertex_data, label)
+        g.vertex_data[label] = data
         return true
     else
         return false
@@ -62,8 +62,8 @@ Return `true` if the operation succeeds, and `false` if `g` has no such edge.
 """
 function set_data!(g::MetaGraph, label_1, label_2, data)
     edge_labels = arrange(g, label_1, label_2)
-    if haskey(g.eprops, edge_labels)
-        g.eprops[edge_labels] = data
+    if haskey(g.edge_data, edge_labels)
+        g.edge_data[edge_labels] = data
         return true
     else
         return false
@@ -83,9 +83,9 @@ function Graphs.add_vertex!(g::MetaGraph, label, data)
     added = add_vertex!(g.graph)
     if added
         v = nv(g)
-        g.labels[v] = label
-        g.vcodes[label] = v
-        g.vprops[label] = data
+        g.vertex_labels[v] = label
+        g.vertex_codes[label] = v
+        g.vertex_data[label] = data
     end
     return added
 end
@@ -101,36 +101,36 @@ function Graphs.add_edge!(g::MetaGraph, label_1, label_2, data)
     v1, v2 = code_for(g, label_1), code_for(g, label_2)
     added = add_edge!(g.graph, v1, v2)
     if added
-        g.eprops[arrange(g, label_1, label_2, v1, v2)] = data
+        g.edge_data[arrange(g, label_1, label_2, v1, v2)] = data
     end
     return added
 end
 
 ## Remove vertex
 
 function _rem_vertex!(g::MetaGraph, label, v)
-    labels = g.labels
-    vcodes = g.vcodes
-    vprops = g.vprops
-    eprops = g.eprops
+    vertex_labels = g.vertex_labels
+    vertex_codes = g.vertex_codes
+    vertex_data = g.vertex_data
+    edge_data = g.edge_data
     lastv = nv(g)
     for n in outneighbors(g, v)
-        delete!(eprops, arrange(g, label, labels[n], v, n))
+        delete!(edge_data, arrange(g, label, vertex_labels[n], v, n))
     end
     for n in inneighbors(g, v)
-        delete!(eprops, arrange(g, labels[n], label, n, v))
+        delete!(edge_data, arrange(g, vertex_labels[n], label, n, v))
     end
     removed = rem_vertex!(g.graph, v)
     if removed
         if v != lastv # ignore if we're removing the last vertex.
-            lastl = labels[lastv]
-            lastvprop = vprops[lastl]
-            labels[v] = lastl
-            vcodes[lastl] = v
-            vprops[lastl] = lastvprop
+            lastl = vertex_labels[lastv]
+            lastvprop = vertex_data[lastl]
+            vertex_labels[v] = lastl
+            vertex_codes[lastl] = v
+            vertex_data[lastl] = lastvprop
         end
-        delete!(vprops, label)
-        delete!(labels, lastv)
+        delete!(vertex_data, label)
+        delete!(vertex_labels, lastv)
     end
     return removed
 end
@@ -150,7 +150,7 @@ function Graphs.rem_edge!(g::MetaGraph, v1::Integer, v2::Integer)
     removed = rem_edge!(g.graph, v1, v2)
     if removed
         label_1, label_2 = label_for(g, v1), label_for(g, v2)
-        delete!(g.eprops, arrange(g, label_1, label_2, v1, v2))
+        delete!(g.edge_data, arrange(g, label_1, label_2, v1, v2))
     end
     return removed
 end
@@ -163,34 +163,41 @@ function Graphs.induced_subgraph(
     inducedgraph, vmap = induced_subgraph(g.graph, v)
     newg = MetaGraph(
         inducedgraph,
-        empty(g.labels),
-        empty(g.vcodes),
-        empty(g.vprops),
-        empty(g.eprops),
-        g.gprops,
-        g.weightfunction,
-        g.defaultweight,
+        empty(g.vertex_labels),
+        empty(g.vertex_codes),
+        empty(g.vertex_data),
+        empty(g.edge_data),
+        g.graph_data,
+        g.weight_function,
+        g.default_weight,
     )
     _copy_props!(g, newg, vmap)
     return newg, vmap
 end
 
 function Graphs.reverse(g::MetaDiGraph)
     rg = reverse(g.graph)
-    rlabels = copy(g.labels)
-    rvcodes = copy(g.vcodes)
-    rvprops = copy(g.vprops)
-    reprops = empty(g.eprops)
-    rgprops = g.gprops
-    rweightfunction = g.weightfunction
-    rdefaultweight = g.defaultweight
-
-    for (u, v) in keys(g.eprops)
-        reprops[(v, u)] = g.eprops[(u, v)]
+    rvertex_labels = copy(g.vertex_labels)
+    rvertex_codes = copy(g.vertex_codes)
+    rvertex_data = copy(g.vertex_data)
+    redge_data = empty(g.edge_data)
+    rgraph_data = g.graph_data
+    rweight_function = g.weight_function
+    rdefault_weight = g.default_weight
+
+    for (u, v) in keys(g.edge_data)
+        redge_data[(v, u)] = g.edge_data[(u, v)]
     end
 
     rg = MetaGraph(
-        rg, rlabels, rvcodes, rvprops, reprops, rgprops, rweightfunction, rdefaultweight
+        rg,
+        rvertex_labels,
+        rvertex_codes,
+        rvertex_data,
+        redge_data,
+        rgraph_data,
+        rweight_function,
+        rdefault_weight,
     )
 
     return rg