update

Co-Authored-By: Pietro Monticone <[email protected]>
Co-Authored-By: Claudio Moroni <[email protected]>

Author: 3 people

docs/src/API_organized.md

@@ -225,13 +225,13 @@ MultilayerDiGraph(
      perform_checks::Bool = false
 ) where {T,U}
 
-SynchronizedEdgeColoredGraph{T,U}
+NodeAlignedEdgeColoredGraph{T,U}
 
-SynchronizedEdgeColoredGraph(
+NodeAlignedEdgeColoredGraph(
     layers::Vector{<:Layer{T,U}},
 ) where {T,U}
 
-SynchronizedEdgeColoredDiGraph{T,U}
+NodeAlignedEdgeColoredDiGraph{T,U}
 
 
 
@@ -253,7 +253,7 @@ has_edge( subgraph::AbstractMultilayerGraph, s::MultilayerVertex, d::MultilayerV
 ne(mg::AbstractMultilayerGraph)
 <!-- edges(mg::AbstractMultilayerUGraph) -->
 <!-- edges(mg::M) where {T,U,M<:AbstractMultilayerUGraph{T,U}} -->
-edges(mg::M) where {T,U,M<:AbstractMultilayerGraph{T,U}; IsDirected{M}}
+edges(mg::M) where {T,U,M<:AbstractMultilayerGraph{T,U}}
 edges
 add_edge!(mg::M, src::V, dst::V; weight::Union{Nothing, U} = one(U), metadata::Union{Tuple,NamedTuple} = NamedTuple() ) where {T,U, M <: AbstractMultilayerGraph{T,U}, V <: MultilayerVertex}
 add_edge!(mg::M, me::E) where {T,U, M <: AbstractMultilayerGraph{T,U}, E <: MultilayerEdge{ <: Union{U,Nothing}}}

src/MultilayerGraphs.jl

@@ -159,7 +159,7 @@ export
     # multilayerdigraph.jl
     MultilayerDiGraph,
     # abstract_synchronized_edge_colored_graph.jl
-    AbstractSynchronizedEdgeColoredGraph,
+    AbstractNodeAlignedEdgeColoredGraph,
     # synchronized_edge_colored_graph.jl
     NodeAlignedEdgeColoredGraph,
     # synchronized_edge_colored_di_graph.jl

src/directed.jl

@@ -148,7 +148,7 @@ Return an list of all the edges of `mg`.
 """
 @traitfn function Graphs.edges(
     mg::M
-) where {T,U,M<:AbstractMultilayerGraph{T,U};IsDirected{M}}
+) where {T,U,M<:AbstractMultilayerGraph{T,U}; IsDirected{M}}
     edge_list = MultilayerEdge{U}[]
 
     for (_src_v, halfedges) in enumerate(mg.fadjlist)

src/special_multilayergraphs/node_aligned_edge_colored/abstract_node_aligned_edge_colored_graph.jl

@@ -1,5 +1,5 @@
 """
-    AbstractSynchronizedEdgeColoredGraph{T,U}  <: AbstractMultilayerGraph{T,U} 
+    AbstractNodeAlignedEdgeColoredGraph{T,U}  <: AbstractMultilayerGraph{T,U} 
 
 An abstract type representing an edge-colored and synchronized (i.e. every node is represented in each layer) graph. As such:
 
@@ -8,50 +8,50 @@ An abstract type representing an edge-colored and synchronized (i.e. every node
 -  All Interlayers automatically added by `add_layer!` are empty simple graphs.
 - `specify_interlayer!` is not available.
 """
-abstract type AbstractSynchronizedEdgeColoredGraph{T,U} <: AbstractMultilayerGraph{T,U} end
+abstract type AbstractNodeAlignedEdgeColoredGraph{T,U} <: AbstractMultilayerGraph{T,U} end
 
 # Nodes
 """
-    add_node!(mg::AbstractSynchronizedEdgeColoredGraph, n::Node; add_vertex_to_layers::Union{Vector{Symbol}, Symbol} = Symbol[])
+    add_node!(mg::AbstractNodeAlignedEdgeColoredGraph, n::Node; add_vertex_to_layers::Union{Vector{Symbol}, Symbol} = Symbol[])
 
 Add node `n` to `mg`. Return true if succeeds. Additionally, add a corresponding vertex to all layers.
 """
-function add_node!(mg::AbstractSynchronizedEdgeColoredGraph, n::Node)
+function add_node!(mg::AbstractNodeAlignedEdgeColoredGraph, n::Node)
     return _add_node!(mg, n; add_vertex_to_layers=:all)
 end
 
 """
-    rem_node!(mg::AbstractSynchronizedEdgeColoredGraph, n::Node)
+    rem_node!(mg::AbstractNodeAlignedEdgeColoredGraph, n::Node)
 
 Remove node `n` to `mg`. Return true if succeeds.
 """
-rem_node!(mg::AbstractSynchronizedEdgeColoredGraph, n::Node) = _rem_node!(mg, n)
+rem_node!(mg::AbstractNodeAlignedEdgeColoredGraph, n::Node) = _rem_node!(mg, n)
 
 # Vertices
 ## add_vertex! and rem_vertex! are not implemented, since oly nodes can be added/removed to/from synchronized graphs
 
 # Edges
 """
-    add_edge!(mg::M, me::E) where {T,U, M <: AbstractSynchronizedEdgeColoredGraph{T,U}, E <: MultilayerEdge{ <: Union{U,Nothing}}}
+    add_edge!(mg::M, me::E) where {T,U, M <: AbstractNodeAlignedEdgeColoredGraph{T,U}, E <: MultilayerEdge{ <: Union{U,Nothing}}}
 
 Add a MultilayerEdge between `src` and `dst` with weight `weight` and metadata `metadata`. Return true if succeeds, false otherwise.
 """
 function Graphs.add_edge!(
     mg::M, me::E
 ) where {
-    T,U,M<:AbstractSynchronizedEdgeColoredGraph{T,U},E<:MultilayerEdge{<:Union{U,Nothing}}
+    T,U,M<:AbstractNodeAlignedEdgeColoredGraph{T,U},E<:MultilayerEdge{<:Union{U,Nothing}}
 }
     layer(src(me)) == layer(dst(me)) ||
         throw(ArgumentError("Cannot add an interlayer edge to an edge colored graph"))
     return _add_edge!(mg, me)
 end
 """
-    rem_edge!(mg::AbstractSynchronizedEdgeColoredGraph, me::MultilayerEdge)
+    rem_edge!(mg::AbstractNodeAlignedEdgeColoredGraph, me::MultilayerEdge)
 
 Remove edge from `src(me)` to `dst(me)` from `mg`. Return true if succeeds, false otherwise.
 """
 function Graphs.rem_edge!(
-    mg::AbstractSynchronizedEdgeColoredGraph, src::MultilayerVertex, dst::MultilayerVertex
+    mg::AbstractNodeAlignedEdgeColoredGraph, src::MultilayerVertex, dst::MultilayerVertex
 )
     return _rem_edge!(mg, src, dst)
 end
@@ -60,19 +60,19 @@ end
 """
     add_layer!( mg::M,
         new_layer::L;
-    ) where {T,U,G<:AbstractGraph{T},L<:Layer{T,U,G}, H <: AbstractGraph{T}, M<:AbstractSynchronizedEdgeColoredGraph{T,U}; !IsDirected{M}}
+    ) where {T,U,G<:AbstractGraph{T},L<:Layer{T,U,G}, H <: AbstractGraph{T}, M<:AbstractNodeAlignedEdgeColoredGraph{T,U}; !IsDirected{M}}
 
 Add layer `layer` to the synchronized edge-colored graph `mg`.
 
 # ARGUMENTS
 
-- `mg::M`: the `AbstractSynchronizedEdgeColoredGraph` which the new layer will be added to;
+- `mg::M`: the `AbstractNodeAlignedEdgeColoredGraph` which the new layer will be added to;
 - `new_layer::L`: the new `Layer` to add to `mg`;
 """
 function add_layer!(
     mg::M, new_layer::L
 ) where {
-    T,U,G<:AbstractGraph{T},L<:Layer{T,U,G},M<:AbstractSynchronizedEdgeColoredGraph{T,U}
+    T,U,G<:AbstractGraph{T},L<:Layer{T,U,G},M<:AbstractNodeAlignedEdgeColoredGraph{T,U}
 }
     return add_layer_directedness!(mg, new_layer; default_interlayers_structure="empty")
 end

src/special_multilayergraphs/node_aligned_edge_colored/node_aligned_edge_colored_di_graph.jl

@@ -10,7 +10,7 @@ A concrete type that can represent a general directed edge colored graph, that i
 Its internal fields aren't meant to be modified by the user. Please prefer the provided API.
 """
 mutable struct NodeAlignedEdgeColoredDiGraph{T,U} <:
-               AbstractSynchronizedEdgeColoredGraph{T,U}
+        AbstractNodeAlignedEdgeColoredGraph{T,U}
     layers::Vector{LayerDescriptor{T,U}} # vector containing all the layers of the multilayer graph. Their underlying graphs must be all undirected.
     interlayers::OrderedDict{Set{Symbol},InterlayerDescriptor{T,U}} #  the ordered dictionary containing all the interlayers of the multilayer graph. Their underlying graphs must be all undirected.
     v_V_associations::Bijection{T,<:MultilayerVertex} # A Bijection from Bijections.jl that associates numeric vertices to `MultilayerVertex`s.

src/special_multilayergraphs/node_aligned_edge_colored/node_aligned_edge_colored_graph.jl

@@ -9,7 +9,7 @@ A concrete type that can represent a general edge colored graph, that is synchro
 
 Its internal fields aren't meant to be modified by the user. Please prefer the provided API.
 """
-mutable struct NodeAlignedEdgeColoredGraph{T,U} <: AbstractSynchronizedEdgeColoredGraph{T,U}
+mutable struct NodeAlignedEdgeColoredGraph{T,U} <: AbstractNodeAlignedEdgeColoredGraph{T,U}
     layers::Vector{LayerDescriptor{T,U}} # vector containing all the layers of the multilayer graph. Their underlying graphs must be all undirected.
     interlayers::OrderedDict{Set{Symbol},InterlayerDescriptor{T,U}} # the ordered dictionary containing all the interlayers of the multilayer graph. Their underlying graphs must be all undirected.
     v_V_associations::Bijection{T,<:MultilayerVertex} # A Bijection from Bijections.jl that associates numeric vertices to `MultilayerVertex`s.

src/vertices/multilayervertex.jl

@@ -33,42 +33,42 @@ struct MultilayerVertex{S} <: AbstractMultilayerVertex{S}
     end
 end
 
-#= """
+"""
     MultilayerVertex(node::Node, layer::Symbol)
 
 Return `MultilayerVertex(node, layer, NamedTuple())`
-""" =#
+"""
 MultilayerVertex(node::Node, layer::Symbol) = MultilayerVertex(node, layer, NamedTuple())
 
-#= """
+"""
     MultilayerVertex(node::Node, not::Nothing)
 
 Return `MultilayerVertex(node, nothing, NamedTuple())`.
-""" =#
+"""
 MultilayerVertex(node::Node, not::Nothing) = MultilayerVertex(node, nothing, NamedTuple())
 
-#= """
+"""
     MultilayerVertex(node::Node, metadata::Union{Tuple,NamedTuple})
 
 Return `MultilayerVertex(node, nothing, metadata)`.
-""" =#
+"""
 function MultilayerVertex(node::Node, metadata::Union{Tuple,NamedTuple})
     return MultilayerVertex(node, nothing, metadata)
 end
 
-#= """
+"""
     MultilayerVertex(node::Node)
 
 Return `MultilayerVertex(node, nothing, NamedTuple())`.
-""" =#
+"""
 MultilayerVertex(node::Node) = MultilayerVertex(node, nothing, NamedTuple())
 
 # Shorter alias for MultilayerVertex
-#= """
+"""
     MV
 
 Alias for `MultilayerVertex`
-""" =#
+"""
 const MV = MultilayerVertex
 
 # Base overrides