MapGraph

java.lang.Object
- berack96.lib.graph.impl.MapGraph<V,W>

Type Parameters:

V - the vertices

W - the weight of the edges

All Implemented Interfaces:

Graph<V,W>, java.lang.Iterable<V>
```
public class MapGraph<V,W extends java.lang.Number>
extends java.lang.Object
implements Graph<V,W>
```
Graph that uses HashMap for vertices and edges
More specifically it utilizes a Map containing all the vertices mapped to all their edges
Technically this version of the graph combine the fast adding/removing of the edges of the Matrix implementation, with the low memory and fast adding/removing of vertices of the Linked List implementation.
This happen if the HashMap is not reallocated. So in the end each operation of adding or removing has O(n)

Author:

Berack96

Field Summary
- Fields inherited from interface berack96.lib.graph.Graph
  GSON, NOT_CONNECTED, NOT_DAG, PARAM_NULL, VERTEX_NOT_CONTAINED

Constructor Summary

Constructors
Constructor and Description

MapGraph()

Constructors
Constructor and Description
`MapGraph()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addAllEdges(java.util.Collection<Edge<V,W>> edges)` Add all the edges of the collection to the graph. If one of the two, or both vertices aren't contained in the graph, then the vertices will be added. Any null edges will be ignored. This method will overwrite any existing edge between the two vertex.
`void`	`addAllVertices(java.util.Collection<V> vertices)` Add all the vertices contained in the collection to the graph. If a vertex is contained in the collection and in the graph is ignored and it will not be replaced. Null vertices will be ignored and they will not be added to the graph.
`W`	`addEdge(Edge<V,W> edge)` Add an edge between the two vertex. The edge will be created from the vertex source of the edge and the vertex destination of it This method will overwrite any existing edge between the two vertex. If there was a previous edge then it is returned
`W`	`addEdge(V vertex1, V vertex2, W weight)` Add an edge between the two vertex. The edge will be created from the vertex V1 and the vertex V2 This method will overwrite any existing edge between the two vertex. If there was a previous edge then it is returned
`W`	`addEdgeAndVertices(Edge<V,W> edge)` This particular function add an edge to the graph. If one of the two, or both vertices of the edge aren't contained in the graph, then the vertices will be added. The edge will be created from the vertex source of the edge and the vertex destination of it This method will overwrite any existing edge between the two vertex. If there was a previous edge then it is returned
`W`	`addEdgeAndVertices(V vertex1, V vertex2, W weight)` This particular function add an edge to the graph. If one of the two, or both vertices aren't contained in the graph, then the vertices will be added. The edge will be created from the vertex V1 and the vertex V2 This method will overwrite any existing edge between the two vertex. If there was a previous edge then it is returned
`void`	`addVertex(V vertex)` Add the vertex to the graph.
`boolean`	`addVertexIfAbsent(V vertex)` Add the specified vertex to the graph only if the graph doesn't contains it. The graph contains a vertex only if the method `Graph.contains(Object)` returns true.
`boolean`	`contains(V vertex)` Check if the vertex passed is contained in the graph or not. The vertex V1 is contained in the graph G, if and only if: exist V2 in G such that V2.equals(V1)
`boolean`	`containsEdge(V vertex1, V vertex2)` Check if the edge between the two vertex passed is contained in the graph or not. An edge between V1 and V2 is contained in the graph if and only if i can travel from V1 to V2. If one of the two vertices is not contained in the graph, then even the edge isn't
`int`	`degree(V vertex)` Tells the degree of a vertex. The degree of a vertex is the quantity of edges that have. Basically, it'll count how many edge it have.
`int`	`degreeIn(V vertex)` Tells the degree of all the edges that goes to this vertex. Basically, it'll count how many edge towards himself it have.
`int`	`degreeOut(V vertex)` Tells the degree of all the edges that goes form this vertex to others. Basically, it'll count how many edge towards any other vertex it have.
`java.util.Map<V,java.util.List<Edge<V,W>>>`	`distance(V source)` Get the minimum path from the source vertex to all the possible reachable vertices.
`java.util.List<Edge<V,W>>`	`distance(V source, V destination)` Get the minimum path from the source vertex to the destination vertex. If the source vertex can't reach the destination, then an exception is thrown.
`java.util.Collection<Edge<V,W>>`	`edges()` Get all the edges in the graph. If the graph doesn't contains edges, it'll return an empty collection. Note: depending on the implementation, modifying the returned collection could affect the graph behavior and the changes could be reflected to the graph.
`java.util.Collection<Edge<V,W>>`	`edgesOf(V vertex)` Retrieve all the edges of a particular vertex. Note: the edges that are returned are the one that goes IN this vertex AND the edges that goes OUT of it. Note2: depending on the implementation, modifying the returned collection could affect the graph behavior and the changes could be reflected to the graph.
`java.util.Collection<V>`	`getAncestors(V vertex)` Get all the vertices that have the vertex passed as their child. Basically is the opposite of `Graph.getChildren(Object)` Note: depending on the implementation, modifying the returned collection could affect the graph behavior and the changes could be reflected to the graph.
`java.util.Collection<V>`	`getChildren(V vertex)` Get all the vertices that are children of the vertex passed as parameter. The vertices V(0-N) that are 'children' of a vertex V1, are all the vertices that have an edge where V1 is the source of that edge. Note: depending on the implementation, modifying the returned collection could affect the graph behavior and the changes could be reflected to the graph.
`java.util.Collection<Edge<V,W>>`	`getEdgesIn(V vertex)` Retrieve all the edges of a particular vertex. Note: the edges that are returned are the one that have this vertex as destination and another as source. Note2: depending on the implementation, modifying the returned collection could affect the graph behavior and the changes could be reflected to the graph.
`java.util.Collection<Edge<V,W>>`	`getEdgesOut(V vertex)` Retrieve all the edges that goes OUT of a particular vertex. Note: the edges that are returned are the one that have this vertex as source and another one as destination. Note2: depending on the implementation, modifying the returned collection could affect the graph behavior and the changes could be reflected to the graph.
`java.util.Collection<V>`	`getMarkedWith(java.lang.Object mark)` Get all the vertices that are marked with the specific mark passed. If there aren't vertices with that mark then it is returned an empty set. Note: depending on the implementation, modifying the returned collection could affect the graph behavior and the changes could be reflected to the graph.
`java.util.Collection<java.lang.Object>`	`getMarks(V vertex)` Get all the marker of this vertex. If the vertex doesn't have any mark, then it will return an empty set. Note: depending on the implementation, modifying the returned collection could affect the graph behavior and the changes could be reflected to the graph.
`Vertex<V>`	`getVertex(V vertex)` Get an instance of the vertex linked with this graph. For more info see `Vertex`
`W`	`getWeight(V vertex1, V vertex2)` Get the weight of the selected edge. If the edge doesn't exist, then null is returned
`boolean`	`isCyclic()` Tells if the graph has some cycle. A cycle is detected if visiting the graph G starting from V1 (that is any of the vertex of G), the visit can return to V1 in any point.
`boolean`	`isDAG()` Tells if the graph has the property of DAG (Directed Acyclic Graph). A graph is a DAG only if absent of any cycle.
`java.util.Iterator<V>`	`iterator()`
`void`	`mark(V vertex, java.lang.Object mark)` Add to the specified vertex the mark passed. A vertex can have multiple marker.
`java.util.Collection<java.lang.Object>`	`marks()` Get all the marks of this graph. Specifically it will return a collection of marks where every mark as associated at least one vertex of the graph. If the graph doesn't have vertex marked then it is returned an empty collection.
`int`	`numberOfEdges()` Tells how many edges are in the graph.
`int`	`numberOfVertices()` Tells how many vertices are in the graph.
`void`	`removeAllEdge()` Remove all the edges of the graph. After this method's call the graph will have only vertices, and no edge.
`void`	`removeAllEdge(V vertex)` Remove all edges form a particular vertex of the graph. After this method's call the selected vertex will have 0 edges. It will be no longer possible to reach this vertex from any other vertex, and vice versa.
`void`	`removeAllInEdge(V vertex)` Remove all the edges that goes in the vertex. After this method's call it will be no longer possible travel to this vertex.
`void`	`removeAllOutEdge(V vertex)` Remove all the edges that start from this vertex. After this method's call it will be no longer possible travel to any vertex from this one.
`void`	`removeAllVertex()` Remove all the vertex contained in the graph. After this method's call the graph will be empty; no vertices nor edges.
`void`	`removeEdge(V vertex1, V vertex2)` Remove the edge between the two vertex. If the edge doesn't exist, then this call does nothing. After this method's call it will be no longer possible to travel from V1 to V2, nether from V2 to V1.
`void`	`removeVertex(V vertex)` Remove the selected vertex from the graph. After this method's call the vertex will be no longer present in the graph, and nether all his edges.
`java.util.Collection<java.util.Collection<V>>`	`stronglyConnectedComponents()` The strongly connected components or disconnected components of an arbitrary directed graph form a partition into subgraphs that are themselves strongly connected.
`Graph<V,W>`	`subGraph(java.lang.Object... marker)` Get a sub-graph of the current one with only the vertex marked with the selected markers. Each vertex will have all his edges, but only the ones with the destination marked with the same marker. If the marker is not specified or is null then the returning graph will have all the vertices that are not marked by any marker. If the graph doesn't contain any vertex with that marker then an empty graph is returned.
`Graph<V,W>`	`subGraph(V source, int depth)` Get a sub-graph of the current one based on the maximum depth that is given. If the depth is 1 then only the source and it's children will be in the sub-graph. If the depth is 2 then only the source, it's children and it's children of it's children will be in the sub-graph. And so on. Of course the sub-graph will contain the edges that link the vertices, but only the one selected.
`java.util.List<V>`	`topologicalSort()` If the current graph is a DAG, it returns a topological sort of this graph. A topological ordering of a graph is a linear ordering of its vertices such that for every directed edge (V1, V2) from vertex V1 to vertex V2, V2 comes before V1 in the ordering.
`Graph<V,W>`	`transpose()` This method will create a new Graph that is the transposed version of the original. At the end of this method the new graph will have all the edges inverted in orientation. Example: if the graph G contains (V1, V2, V3) as vertex, and (V1->V2, V3->V2) as edges, the transpose graph G' will contain (V1, V2, V3) as vertex, and (V2->V1, V2->V3) as edges.
`void`	`unMark(V vertex)` Unmark the vertex selected. After this call the vertex will not have any marked object to himself.
`void`	`unMark(V vertex, java.lang.Object mark)` Remove the selected mark from the vertex.
`void`	`unMarkAll()` Remove all the marker to all the vertex. After this call the `Graph.getMarks(Object)` applied to any vertex will return an empty set
`void`	`unMarkAll(java.lang.Object mark)` Remove the selected mark from all the vertices
`java.util.Collection<V>`	`vertices()` Get all the vertices in the graph. If the graph doesn't contains vertices, it'll return an empty collection. Note: depending on the implementation, modifying the returned collection could affect the graph behavior and the changes could be reflected to the graph.
`VisitInfo<V>`	`visit(V source, VisitStrategy<V,W> strategy, java.util.function.Consumer<V> visit)` Visit the graph accordingly to the strategy that is passed. This method visit the graph from the source to all the vertex that are reachable form the source. Some strategy can accept a source vertex null, because they visit all the graph anyway.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface berack96.lib.graph.Graph
load, save, save

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Constructor Detail
  - MapGraph
```
public MapGraph()
```
- Method Detail
  - isCyclic
```
public boolean isCyclic()
```
    Description copied from interface: Graph
    
    Tells if the graph has some cycle.
    A cycle is detected if visiting the graph G starting from V1 (that is any of the vertex of G), the visit can return to V1 in any point.
    
    Specified by:
    
    isCyclic in interface Graph<V,W extends java.lang.Number>
    
    Returns:
    
    true if has cycle, false otherwise
  - isDAG
```
public boolean isDAG()
```
    Description copied from interface: Graph
    
    Tells if the graph has the property of DAG (Directed Acyclic Graph).
    A graph is a DAG only if absent of any cycle. ( see Graph.isCyclic() )
    
    Specified by:
    
    isDAG in interface Graph<V,W extends java.lang.Number>
    
    Returns:
    
    true if is a DAG, false otherwise
  - getVertex
```
public Vertex<V> getVertex(V vertex)
                    throws java.lang.NullPointerException,
                           java.lang.IllegalArgumentException
```
    Description copied from interface: Graph
    
    Get an instance of the vertex linked with this graph.
    For more info see Vertex
    
    Specified by:
    
    getVertex in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    vertex - the vertex
    
    Returns:
    
    a vertex
    
    Throws:
    
    java.lang.NullPointerException - if the vertex is null
    
    java.lang.IllegalArgumentException - if the vertex is not contained in the graph
  - addVertex
```
public void addVertex(V vertex)
               throws java.lang.NullPointerException
```
    Description copied from interface: Graph
    
    Add the vertex to the graph. If it's already in the graph it will be replaced.
    Of course the vertex added will have no edge to any other vertex nor form any other vertex.
    
    Specified by:
    
    addVertex in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    vertex - the vertex to add
    
    Throws:
    
    java.lang.NullPointerException - if the vertex is null
  - addVertexIfAbsent
```
public boolean addVertexIfAbsent(V vertex)
                          throws java.lang.NullPointerException
```
    Description copied from interface: Graph
    
    Add the specified vertex to the graph only if the graph doesn't contains it.
    The graph contains a vertex only if the method Graph.contains(Object) returns true.
    
    Specified by:
    
    addVertexIfAbsent in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    vertex - the vertex to add
    
    Returns:
    
    true if the vertex is added, false if the graph contains the vertex and therefore the new one is not added
    
    Throws:
    
    java.lang.NullPointerException - if the vertex is null
  - addAllVertices
```
public void addAllVertices(java.util.Collection<V> vertices)
                    throws java.lang.NullPointerException
```
    Description copied from interface: Graph
    
    Add all the vertices contained in the collection to the graph.
    If a vertex is contained in the collection and in the graph is ignored and it will not be replaced.
    Null vertices will be ignored and they will not be added to the graph.
    
    Specified by:
    
    addAllVertices in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    vertices - a collection of the vertices to add
    
    Throws:
    
    java.lang.NullPointerException - if the set is null
  - removeVertex
```
public void removeVertex(V vertex)
                  throws java.lang.NullPointerException
```
    Description copied from interface: Graph
    
    Remove the selected vertex from the graph.
    After this method's call the vertex will be no longer present in the graph, and nether all his edges.
    
    Specified by:
    
    removeVertex in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    vertex - the vertex to remove
    
    Throws:
    
    java.lang.NullPointerException - if the vertex is null
  - removeAllVertex
```
public void removeAllVertex()
```
    Description copied from interface: Graph
    
    Remove all the vertex contained in the graph.
    After this method's call the graph will be empty; no vertices nor edges.
    
    Specified by:
    
    removeAllVertex in interface Graph<V,W extends java.lang.Number>
  - contains
```
public boolean contains(V vertex)
                 throws java.lang.NullPointerException
```
    Description copied from interface: Graph
    
    Check if the vertex passed is contained in the graph or not.
    The vertex V1 is contained in the graph G, if and only if:
    exist V2 in G such that V2.equals(V1)
    
    Specified by:
    
    contains in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    vertex - the vertex to check
    
    Returns:
    
    true if the vertex is contained, false otherwise
    
    Throws:
    
    java.lang.NullPointerException - if the vertex is null
  - marks
```
public java.util.Collection<java.lang.Object> marks()
```
    Description copied from interface: Graph
    
    Get all the marks of this graph.
    Specifically it will return a collection of marks where every mark
    as associated at least one vertex of the graph.
    If the graph doesn't have vertex marked then it is returned an empty collection.
    
    Specified by:
    
    marks in interface Graph<V,W extends java.lang.Number>
    
    Returns:
    
    a collection of marks
  - mark
```
public void mark(V vertex,
                 java.lang.Object mark)
          throws java.lang.NullPointerException,
                 java.lang.IllegalArgumentException
```
    Description copied from interface: Graph
    
    Add to the specified vertex the mark passed.
    A vertex can have multiple marker.
    
    Specified by:
    
    mark in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    vertex - the vertex to mark
    
    mark - the mark to add
    
    Throws:
    
    java.lang.NullPointerException - if one of the param is null
    
    java.lang.IllegalArgumentException - if the vertex is not contained in the graph
  - unMark
```
public void unMark(V vertex,
                   java.lang.Object mark)
            throws java.lang.NullPointerException,
                   java.lang.IllegalArgumentException
```
    Description copied from interface: Graph
    
    Remove the selected mark from the vertex.
    
    Specified by:
    
    unMark in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    vertex - the vertex where remove the mark
    
    mark - the mark to remove
    
    Throws:
    
    java.lang.NullPointerException - if a param is null
    
    java.lang.IllegalArgumentException - if the vertex is not contained in the graph
  - unMark
```
public void unMark(V vertex)
            throws java.lang.NullPointerException,
                   java.lang.IllegalArgumentException
```
    Description copied from interface: Graph
    
    Unmark the vertex selected.
    After this call the vertex will not have any marked object to himself.
    
    Specified by:
    
    unMark in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    vertex - the vertex
    
    Throws:
    
    java.lang.NullPointerException - if the vertex is null
    
    java.lang.IllegalArgumentException - if the vertex is not contained in the graph
  - getMarkedWith
```
public java.util.Collection<V> getMarkedWith(java.lang.Object mark)
                                      throws java.lang.NullPointerException
```
    Description copied from interface: Graph
    
    Get all the vertices that are marked with the specific mark passed.
    If there aren't vertices with that mark then it is returned an empty set.
    Note: depending on the implementation, modifying the returned collection
    could affect the graph behavior and the changes could be reflected to the graph.
    
    Specified by:
    
    getMarkedWith in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    mark - the mark
    
    Returns:
    
    all the vertices that are marked with that specific mark
    
    Throws:
    
    java.lang.NullPointerException - if the mark is null
  - getMarks
```
public java.util.Collection<java.lang.Object> getMarks(V vertex)
                                                throws java.lang.NullPointerException,
                                                       java.lang.IllegalArgumentException
```
    Description copied from interface: Graph
    
    Get all the marker of this vertex.
    If the vertex doesn't have any mark, then it will return an empty set.
    Note: depending on the implementation, modifying the returned collection
    could affect the graph behavior and the changes could be reflected to the graph.
    
    Specified by:
    
    getMarks in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    vertex - the vertex
    
    Returns:
    
    all the mark to the vertex or an empty collection if none
    
    Throws:
    
    java.lang.NullPointerException - if the vertex is null
    
    java.lang.IllegalArgumentException - if the vertex is not contained in the graph
  - unMarkAll
```
public void unMarkAll(java.lang.Object mark)
```
    Description copied from interface: Graph
    
    Remove the selected mark from all the vertices
    
    Specified by:
    
    unMarkAll in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    mark - the mark to remove
  - unMarkAll
```
public void unMarkAll()
```
    Description copied from interface: Graph
    
    Remove all the marker to all the vertex.
    After this call the Graph.getMarks(Object) applied to any vertex will return an empty set
    
    Specified by:
    
    unMarkAll in interface Graph<V,W extends java.lang.Number>
  - addEdge
```
public W addEdge(V vertex1,
                 V vertex2,
                 W weight)
          throws java.lang.NullPointerException,
                 java.lang.IllegalArgumentException
```
    Description copied from interface: Graph
    
    Add an edge between the two vertex.
    The edge will be created from the vertex V1 and the vertex V2
    This method will overwrite any existing edge between the two vertex.
    If there was a previous edge then it is returned
    
    Specified by:
    
    addEdge in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    vertex1 - a vertex of the graph
    
    vertex2 - a vertex of the graph
    
    weight - the weight of the edge
    
    Returns:
    
    null or the previous weight of the edge if there was already one
    
    Throws:
    
    java.lang.NullPointerException - if one of the parameter is null
    
    java.lang.IllegalArgumentException - if one of the vertex is not contained in the graph
  - addEdge
```
public W addEdge(Edge<V,W> edge)
          throws java.lang.NullPointerException,
                 java.lang.IllegalArgumentException
```
    Description copied from interface: Graph
    
    Add an edge between the two vertex.
    The edge will be created from the vertex source of the edge and the vertex destination of it
    This method will overwrite any existing edge between the two vertex.
    If there was a previous edge then it is returned
    
    Specified by:
    
    addEdge in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    edge - the edge to add
    
    Returns:
    
    null or the previous weight of the edge if there was already one
    
    Throws:
    
    java.lang.NullPointerException - if one of the parameter is null
    
    java.lang.IllegalArgumentException - if one of the vertex is not contained in the graph
  - addEdgeAndVertices
```
public W addEdgeAndVertices(V vertex1,
                            V vertex2,
                            W weight)
                     throws java.lang.NullPointerException
```
    Description copied from interface: Graph
    
    This particular function add an edge to the graph.
    If one of the two, or both vertices aren't contained in the graph, then the vertices will be added.
    The edge will be created from the vertex V1 and the vertex V2
    This method will overwrite any existing edge between the two vertex.
    If there was a previous edge then it is returned
    
    Specified by:
    
    addEdgeAndVertices in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    vertex1 - a vertex of the graph
    
    vertex2 - a vertex of the graph
    
    weight - the weight of the edge
    
    Returns:
    
    null or the previous weight of the edge if there was already one
    
    Throws:
    
    java.lang.NullPointerException - if one of the parameter is null
  - addEdgeAndVertices
```
public W addEdgeAndVertices(Edge<V,W> edge)
                     throws java.lang.NullPointerException,
                            java.lang.IllegalArgumentException
```
    Description copied from interface: Graph
    
    This particular function add an edge to the graph.
    If one of the two, or both vertices of the edge aren't contained in the graph, then the vertices will be added.
    The edge will be created from the vertex source of the edge and the vertex destination of it
    This method will overwrite any existing edge between the two vertex.
    If there was a previous edge then it is returned
    
    Specified by:
    
    addEdgeAndVertices in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    edge - the edge to add
    
    Returns:
    
    null or the previous weight of the edge if there was already one
    
    Throws:
    
    java.lang.NullPointerException - if one of the parameter is null
    
    java.lang.IllegalArgumentException
  - addAllEdges
```
public void addAllEdges(java.util.Collection<Edge<V,W>> edges)
                 throws java.lang.NullPointerException
```
    Description copied from interface: Graph
    
    Add all the edges of the collection to the graph.
    If one of the two, or both vertices aren't contained in the graph, then the vertices will be added.
    Any null edges will be ignored.
    This method will overwrite any existing edge between the two vertex.
    
    Specified by:
    
    addAllEdges in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    edges - the edges to add
    
    Throws:
    
    java.lang.NullPointerException - if the set is null
  - getWeight
```
public W getWeight(V vertex1,
                   V vertex2)
            throws java.lang.NullPointerException,
                   java.lang.IllegalArgumentException
```
    Description copied from interface: Graph
    
    Get the weight of the selected edge.
    If the edge doesn't exist, then null is returned
    
    Specified by:
    
    getWeight in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    vertex1 - a vertex of the graph
    
    vertex2 - a vertex of the graph
    
    Returns:
    
    the weight previously set, or null if the edge doesn't exist
    
    Throws:
    
    java.lang.NullPointerException - if one of the parameters is null
    
    java.lang.IllegalArgumentException - if one of the vertex is not contained in the graph
  - removeEdge
```
public void removeEdge(V vertex1,
                       V vertex2)
                throws java.lang.NullPointerException,
                       java.lang.IllegalArgumentException
```
    Description copied from interface: Graph
    
    Remove the edge between the two vertex.
    If the edge doesn't exist, then this call does nothing.
    After this method's call it will be no longer possible to travel from V1 to V2, nether from V2 to V1.
    
    Specified by:
    
    removeEdge in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    vertex1 - a vertex of the graph
    
    vertex2 - a vertex of the graph
    
    Throws:
    
    java.lang.NullPointerException - if one of the parameters is null
    
    java.lang.IllegalArgumentException - if one of the vertex is not contained in the graph
  - removeAllInEdge
```
public void removeAllInEdge(V vertex)
                     throws java.lang.NullPointerException,
                            java.lang.IllegalArgumentException
```
    Description copied from interface: Graph
    
    Remove all the edges that goes in the vertex.
    After this method's call it will be no longer possible travel to this vertex.
    
    Specified by:
    
    removeAllInEdge in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    vertex - a vertex of the graph
    
    Throws:
    
    java.lang.NullPointerException - if one of the parameters is null
    
    java.lang.IllegalArgumentException - if one of the vertex is not contained in the graph
  - removeAllOutEdge
```
public void removeAllOutEdge(V vertex)
                      throws java.lang.NullPointerException,
                             java.lang.IllegalArgumentException
```
    Description copied from interface: Graph
    
    Remove all the edges that start from this vertex.
    After this method's call it will be no longer possible travel to any vertex from this one.
    
    Specified by:
    
    removeAllOutEdge in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    vertex - a vertex of the graph
    
    Throws:
    
    java.lang.NullPointerException - if one of the parameters is null
    
    java.lang.IllegalArgumentException - if one of the vertex is not contained in the graph
  - removeAllEdge
```
public void removeAllEdge(V vertex)
                   throws java.lang.NullPointerException,
                          java.lang.IllegalArgumentException
```
    Description copied from interface: Graph
    
    Remove all edges form a particular vertex of the graph.
    After this method's call the selected vertex will have 0 edges.
    It will be no longer possible to reach this vertex from any other vertex, and vice versa.
    
    Specified by:
    
    removeAllEdge in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    vertex - a vertex of the graph
    
    Throws:
    
    java.lang.NullPointerException - if the vertex is null
    
    java.lang.IllegalArgumentException - if one of the vertex is not contained in the graph
  - removeAllEdge
```
public void removeAllEdge()
```
    Description copied from interface: Graph
    
    Remove all the edges of the graph.
    After this method's call the graph will have only vertices, and no edge.
    
    Specified by:
    
    removeAllEdge in interface Graph<V,W extends java.lang.Number>
  - containsEdge
```
public boolean containsEdge(V vertex1,
                            V vertex2)
                     throws java.lang.NullPointerException
```
    Description copied from interface: Graph
    
    Check if the edge between the two vertex passed is contained in the graph or not.
    An edge between V1 and V2 is contained in the graph if and only if i can travel from V1 to V2.
    If one of the two vertices is not contained in the graph, then even the edge isn't
    
    Specified by:
    
    containsEdge in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    vertex1 - a vertex of the graph
    
    vertex2 - a vertex of the graph
    
    Returns:
    
    true if the edge is contained, false otherwise
    
    Throws:
    
    java.lang.NullPointerException - if one of the parameters is null
  - vertices
```
public java.util.Collection<V> vertices()
```
    Description copied from interface: Graph
    
    Get all the vertices in the graph.
    If the graph doesn't contains vertices, it'll return an empty collection.
    Note: depending on the implementation, modifying the returned collection
    could affect the graph behavior and the changes could be reflected to the graph.
    
    Specified by:
    
    vertices in interface Graph<V,W extends java.lang.Number>
    
    Returns:
    
    an array that include all the vertices
  - edges
```
public java.util.Collection<Edge<V,W>> edges()
```
    Description copied from interface: Graph
    
    Get all the edges in the graph.
    If the graph doesn't contains edges, it'll return an empty collection.
    Note: depending on the implementation, modifying the returned collection
    could affect the graph behavior and the changes could be reflected to the graph.
    
    Specified by:
    
    edges in interface Graph<V,W extends java.lang.Number>
    
    Returns:
    
    a collection that include all the edges
  - edgesOf
```
public java.util.Collection<Edge<V,W>> edgesOf(V vertex)
                                        throws java.lang.NullPointerException,
                                               java.lang.IllegalArgumentException
```
    Description copied from interface: Graph
    
    Retrieve all the edges of a particular vertex.
    Note: the edges that are returned are the one that goes IN this vertex AND the edges that goes OUT of it.
    Note2: depending on the implementation, modifying the returned collection
    could affect the graph behavior and the changes could be reflected to the graph.
    
    Specified by:
    
    edgesOf in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    vertex - a vertex of the graph
    
    Returns:
    
    a collection of edges
    
    Throws:
    
    java.lang.NullPointerException - if the vertex is null
    
    java.lang.IllegalArgumentException - if the vertex is not contained in the graph
  - getEdgesIn
```
public java.util.Collection<Edge<V,W>> getEdgesIn(V vertex)
                                           throws java.lang.NullPointerException,
                                                  java.lang.IllegalArgumentException
```
    Description copied from interface: Graph
    
    Retrieve all the edges of a particular vertex.
    Note: the edges that are returned are the one that have this vertex as destination and another as source.
    Note2: depending on the implementation, modifying the returned collection
    could affect the graph behavior and the changes could be reflected to the graph.
    
    Specified by:
    
    getEdgesIn in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    vertex - a vertex of the graph
    
    Returns:
    
    a collection of edges
    
    Throws:
    
    java.lang.NullPointerException - if the vertex is null
    
    java.lang.IllegalArgumentException - if the vertex is not contained in the graph
  - getEdgesOut
```
public java.util.Collection<Edge<V,W>> getEdgesOut(V vertex)
                                            throws java.lang.NullPointerException,
                                                   java.lang.IllegalArgumentException
```
    Description copied from interface: Graph
    
    Retrieve all the edges that goes OUT of a particular vertex.
    Note: the edges that are returned are the one that have this vertex as source and another one as destination.
    Note2: depending on the implementation, modifying the returned collection
    could affect the graph behavior and the changes could be reflected to the graph.
    
    Specified by:
    
    getEdgesOut in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    vertex - a vertex of the graph
    
    Returns:
    
    a collection of edges
    
    Throws:
    
    java.lang.NullPointerException - if the vertex is null
    
    java.lang.IllegalArgumentException - if the vertex is not contained in the graph
  - getChildren
```
public java.util.Collection<V> getChildren(V vertex)
                                    throws java.lang.NullPointerException,
                                           java.lang.IllegalArgumentException
```
    Description copied from interface: Graph
    
    Get all the vertices that are children of the vertex passed as parameter.
    The vertices V(0-N) that are 'children' of a vertex V1, are all the vertices that have an edge where V1 is the source of that edge.
    Note: depending on the implementation, modifying the returned collection
    could affect the graph behavior and the changes could be reflected to the graph.
    
    Specified by:
    
    getChildren in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    vertex - the source vertex
    
    Returns:
    
    an array of vertices
    
    Throws:
    
    java.lang.NullPointerException - if the vertex is null
    
    java.lang.IllegalArgumentException - if the vertex is not contained in the graph
  - getAncestors
```
public java.util.Collection<V> getAncestors(V vertex)
                                     throws java.lang.NullPointerException,
                                            java.lang.IllegalArgumentException
```
    Description copied from interface: Graph
    
    Get all the vertices that have the vertex passed as their child.
    Basically is the opposite of Graph.getChildren(Object)
    Note: depending on the implementation, modifying the returned collection
    could affect the graph behavior and the changes could be reflected to the graph.
    
    Specified by:
    
    getAncestors in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    vertex - a vertex of the graph
    
    Returns:
    
    an array of ancestors of the vertex
    
    Throws:
    
    java.lang.NullPointerException - if one of the parameters is null
    
    java.lang.IllegalArgumentException - if one of the vertex is not contained in the graph
  - degreeIn
```
public int degreeIn(V vertex)
             throws java.lang.NullPointerException,
                    java.lang.IllegalArgumentException
```
    Description copied from interface: Graph
    
    Tells the degree of all the edges that goes to this vertex.
    Basically, it'll count how many edge towards himself it have.
    
    Specified by:
    
    degreeIn in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    vertex - a vertex of the graph
    
    Returns:
    
    the in degree of the vertex
    
    Throws:
    
    java.lang.NullPointerException - if the vertex is null
    
    java.lang.IllegalArgumentException - if the vertex is not contained in the graph
  - degreeOut
```
public int degreeOut(V vertex)
              throws java.lang.NullPointerException,
                     java.lang.IllegalArgumentException
```
    Description copied from interface: Graph
    
    Tells the degree of all the edges that goes form this vertex to others.
    Basically, it'll count how many edge towards any other vertex it have.
    
    Specified by:
    
    degreeOut in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    vertex - a vertex of the graph
    
    Returns:
    
    the out degree of the vertex
    
    Throws:
    
    java.lang.NullPointerException - if the vertex is null
    
    java.lang.IllegalArgumentException - if the vertex is not contained in the graph
  - degree
```
public int degree(V vertex)
           throws java.lang.NullPointerException,
                  java.lang.IllegalArgumentException
```
    Description copied from interface: Graph
    
    Tells the degree of a vertex.
    The degree of a vertex is the quantity of edges that have.
    Basically, it'll count how many edge it have.
    
    Specified by:
    
    degree in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    vertex - a vertex of the graph
    
    Returns:
    
    the degree of the vertex
    
    Throws:
    
    java.lang.NullPointerException - if the vertex is null
    
    java.lang.IllegalArgumentException - if the vertex is not contained in the graph
  - numberOfVertices
```
public int numberOfVertices()
```
    Description copied from interface: Graph
    
    Tells how many vertices are in the graph.
    
    Specified by:
    
    numberOfVertices in interface Graph<V,W extends java.lang.Number>
    
    Returns:
    
    the number of vertices
  - numberOfEdges
```
public int numberOfEdges()
```
    Description copied from interface: Graph
    
    Tells how many edges are in the graph.
    
    Specified by:
    
    numberOfEdges in interface Graph<V,W extends java.lang.Number>
    
    Returns:
    
    the number of edges
  - visit
```
public VisitInfo<V> visit(V source,
                          VisitStrategy<V,W> strategy,
                          java.util.function.Consumer<V> visit)
                   throws java.lang.NullPointerException,
                          java.lang.IllegalArgumentException
```
    Description copied from interface: Graph
    
    Visit the graph accordingly to the strategy that is passed.
    This method visit the graph from the source to all the vertex that are reachable form the source.
    Some strategy can accept a source vertex null, because they visit all the graph anyway.
    
    Specified by:
    
    visit in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    source - the source vertex of the visit
    
    strategy - the algorithm for visiting the graph
    
    visit - the function to apply at each vertex
    
    Returns:
    
    an info of the visit
    
    Throws:
    
    java.lang.NullPointerException - if one of the parameter is null (except the consumer)
    
    java.lang.IllegalArgumentException - if the vertex is not in the graph
  - transpose
```
public Graph<V,W> transpose()
```
    Description copied from interface: Graph
    
    This method will create a new Graph that is the transposed version of the original.
    At the end of this method the new graph will have all the edges inverted in orientation.
    Example: if the graph G contains (V1, V2, V3) as vertex, and (V1->V2, V3->V2) as edges, the transpose graph G' will contain (V1, V2, V3) as vertex, and (V2->V1, V2->V3) as edges.
    
    Specified by:
    
    transpose in interface Graph<V,W extends java.lang.Number>
    
    Returns:
    
    a transposed graph of this instance
  - topologicalSort
```
public java.util.List<V> topologicalSort()
                                  throws java.lang.UnsupportedOperationException
```
    Description copied from interface: Graph
    
    If the current graph is a DAG, it returns a topological sort of this graph.
    A topological ordering of a graph is a linear ordering of its vertices such that for every directed edge (V1, V2) from vertex V1 to vertex V2, V2 comes before V1 in the ordering.
    
    Specified by:
    
    topologicalSort in interface Graph<V,W extends java.lang.Number>
    
    Returns:
    
    an array containing the topological order of the vertices
    
    Throws:
    
    java.lang.UnsupportedOperationException - if the graph is not a DAG (see Graph.isDAG())
  - stronglyConnectedComponents
```
public java.util.Collection<java.util.Collection<V>> stronglyConnectedComponents()
```
    Description copied from interface: Graph
    
    The strongly connected components or disconnected components of an arbitrary directed graph form a partition into subgraphs that are themselves strongly connected.
    
    Specified by:
    
    stronglyConnectedComponents in interface Graph<V,W extends java.lang.Number>
    
    Returns:
    
    a collection containing the strongly connected components
  - subGraph
```
public Graph<V,W> subGraph(V source,
                           int depth)
                    throws java.lang.NullPointerException,
                           java.lang.IllegalArgumentException
```
    Description copied from interface: Graph
    
    Get a sub-graph of the current one based on the maximum depth that is given.
    If the depth is 1 then only the source and it's children will be in the sub-graph.
    If the depth is 2 then only the source, it's children and it's children of it's children will be in the sub-graph.
    And so on.
    Of course the sub-graph will contain the edges that link the vertices, but only the one selected.
    
    Specified by:
    
    subGraph in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    source - the source vertex
    
    depth - the maximum depth (must be a positive number, if >=0 a graph containing only the source is returned)
    
    Returns:
    
    a sub-graph of the original
    
    Throws:
    
    java.lang.NullPointerException - if the vertex is null
    
    java.lang.IllegalArgumentException - if the vertex is not contained
  - subGraph
```
public Graph<V,W> subGraph(java.lang.Object... marker)
```
    Description copied from interface: Graph
    
    Get a sub-graph of the current one with only the vertex marked with the selected markers.
    Each vertex will have all his edges, but only the ones with the destination marked with the same marker.
    If the marker is not specified or is null then the returning graph will have all the vertices that are not marked by any marker.
    If the graph doesn't contain any vertex with that marker then an empty graph is returned.
    
    Specified by:
    
    subGraph in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    marker - one or more markers
    
    Returns:
    
    a sub-graph of the current graph
  - distance
```
public java.util.List<Edge<V,W>> distance(V source,
                                          V destination)
                                   throws java.lang.NullPointerException,
                                          java.lang.IllegalArgumentException,
                                          java.lang.UnsupportedOperationException
```
    Description copied from interface: Graph
    
    Get the minimum path from the source vertex to the destination vertex.
    If the source vertex can't reach the destination, then an exception is thrown.
    
    Specified by:
    
    distance in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    source - the vertex where to start
    
    destination - the destination chosen
    
    Returns:
    
    an ordered list of edges from source to destination that represent the minimum path between the two vertices
    
    Throws:
    
    java.lang.NullPointerException - if one of the parameter is null (except the consumer)
    
    java.lang.IllegalArgumentException - if the vertex is not in the graph
    
    java.lang.UnsupportedOperationException - if from the source it's not possible to reach the destination
  - distance
```
public java.util.Map<V,java.util.List<Edge<V,W>>> distance(V source)
                                                    throws java.lang.NullPointerException,
                                                           java.lang.IllegalArgumentException
```
    Description copied from interface: Graph
    
    Get the minimum path from the source vertex to all the possible reachable vertices.
    
    Specified by:
    
    distance in interface Graph<V,W extends java.lang.Number>
    
    Parameters:
    
    source - the vertex where to start
    
    Returns:
    
    a map containing all the possible reachable vertices from the source and the minimum path to reach them
    
    Throws:
    
    java.lang.NullPointerException - if one of the parameter is null (except the consumer)
    
    java.lang.IllegalArgumentException - if the vertex is not in the graph
  - iterator
```
public java.util.Iterator<V> iterator()
```
    Specified by:
    
    iterator in interface java.lang.Iterable<V>

Class MapGraph<V,W extends java.lang.Number>

Field Summary

Fields inherited from interface berack96.lib.graph.Graph

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface berack96.lib.graph.Graph

Methods inherited from interface java.lang.Iterable

Constructor Detail

MapGraph

Method Detail

isCyclic

isDAG

getVertex

addVertex

addVertexIfAbsent

addAllVertices

removeVertex

removeAllVertex

contains

marks

mark

unMark

unMark

getMarkedWith

getMarks

unMarkAll

unMarkAll

addEdge

addEdge

addEdgeAndVertices

addEdgeAndVertices

addAllEdges

getWeight

removeEdge

removeAllInEdge

removeAllOutEdge

removeAllEdge

removeAllEdge

containsEdge

vertices

edges

edgesOf

getEdgesIn

getEdgesOut

getChildren

getAncestors

degreeIn

degreeOut

degree

numberOfVertices

numberOfEdges

visit

transpose

topologicalSort

stronglyConnectedComponents

subGraph

subGraph

distance

distance

iterator