IGraph

All Superinterfaces:

ICollection<IGraph<V,E>,V>, Iterable<V>

All Known Implementing Classes:

DirectedAcyclicGraph, DirectedGraph, Graph
```
public interface IGraph<V,E>
extends ICollection<IGraph<V,E>,V>
```

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default IGraph<V,E>`	`add(IEdge<V,E> edge)`
`IGraph<V,E>`	`add(V vertex)`
`E`	`edge(V from, V to)`
`Iterable<IEdge<V,E>>`	`edges()`
`ISet<V>`	`in(V vertex)` In an undirected graph, this is equivalent to `out(Object)`.
`default OptionalLong`	`indexOf(V vertex)`
`boolean`	`isDirected()`
`default Iterator<V>`	`iterator(long startIndex)`
`default IGraph<V,E>`	`link(V from, V to)`
`default IGraph<V,E>`	`link(V from, V to, E edge)`
`IGraph<V,E>`	`link(V from, V to, E edge, BinaryOperator<E> merge)`
`<U> IGraph<V,U>`	`mapEdges(Function<IEdge<V,E>,U> f)`
`default IGraph<V,E>`	`merge(IGraph<V,E> graph)`
`default IGraph<V,E>`	`merge(IGraph<V,E> graph, BinaryOperator<E> merge)`
`default V`	`nth(long idx)`
`ISet<V>`	`out(V vertex)` In an undirected graph, this is equivalent to `in(Object)`.
`default IGraph<V,E>`	`remove(IEdge<V,E> edge)`
`IGraph<V,E>`	`remove(V vertex)`
`default IGraph<V,E>`	`replace(V a, V b)`
`default IGraph<V,E>`	`replace(V a, V b, BinaryOperator<E> merge)`
`IGraph<V,E>`	`select(ISet<V> vertices)`
`default long`	`size()`
`default IList<? extends IGraph<V,E>>`	`split(int parts)` Splits the collection into roughly even pieces, for parallel processing.
`IGraph<V,E>`	`transpose()`
`IGraph<V,E>`	`unlink(V from, V to)`
`BiPredicate<V,V>`	`vertexEquality()`
`ToLongFunction<V>`	`vertexHash()`
`ISet<V>`	`vertices()`

Methods inherited from interface io.lacuna.bifurcan.ICollection
clone, forked, isLinear, iterator, linear, nth, save

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

- Method Detail
  - vertices
```
ISet<V> vertices()
```
    Returns:
    
    the set of all vertices in the graph
  - edges
```
Iterable<IEdge<V,E>> edges()
```
    Returns:
    
    an iterator over every edge in the graph
  - edge
```
E edge(V from,
       V to)
```
    Returns:
    
    the value of the edge between from and to
    
    Throws:
    
    IllegalArgumentException - if no such edge exists
  - in
```
ISet<V> in(V vertex)
```
    In an undirected graph, this is equivalent to out(Object).
    
    Returns:
    
    the set of all incoming edges to vertex
    
    Throws:
    
    IllegalArgumentException - if no such vertex exists
  - out
```
ISet<V> out(V vertex)
```
    In an undirected graph, this is equivalent to in(Object).
    
    Returns:
    
    the set of all outgoing edges from vertex
    
    Throws:
    
    IllegalArgumentException - if no such vertex exists
  - link
```
IGraph<V,E> link(V from,
                 V to,
                 E edge,
                 BinaryOperator<E> merge)
```
    Parameters:
    
    from - the source of the edge
    
    to - the destination of the edge
    
    edge - the value of the edge
    
    merge - the merge function for the edge values, if an edge already exists
    
    Returns:
    
    a graph containing the new edge
  - unlink
```
IGraph<V,E> unlink(V from,
                   V to)
```
    Returns:
    
    a graph without any edge between from and to
  - add
```
IGraph<V,E> add(V vertex)
```
    Returns:
    
    a graph with vertex added
  - remove
```
IGraph<V,E> remove(V vertex)
```
    Returns:
    
    a graph with vertex removed, as well as all incoming and outgoing edges
  - mapEdges
```
<U> IGraph<V,U> mapEdges(Function<IEdge<V,E>,U> f)
```
  - indexOf
```
default OptionalLong indexOf(V vertex)
```
    Returns:
    
    the index of vertex, if it's present
  - nth
```
default V nth(long idx)
```
    Specified by:
    
    nth in interface ICollection<IGraph<V,E>,V>
    
    Returns:
    
    the element at idx
  - iterator
```
default Iterator<V> iterator(long startIndex)
```
    Specified by:
    
    iterator in interface ICollection<IGraph<V,E>,V>
  - size
```
default long size()
```
    Specified by:
    
    size in interface ICollection<IGraph<V,E>,V>
    
    Returns:
    
    the number of elements in the collection
  - select
```
IGraph<V,E> select(ISet<V> vertices)
```
    Returns:
    
    a graph containing only the specified vertices and the edges between them
  - replace
```
default IGraph<V,E> replace(V a,
                            V b)
```
    Returns:
  - replace
```
default IGraph<V,E> replace(V a,
                            V b,
                            BinaryOperator<E> merge)
```
    Parameters:
    
    a -
    
    b -
    
    merge -
    
    Returns:
  - isDirected
```
boolean isDirected()
```
    Returns:
    
    whether the graph is directed
  - vertexHash
```
ToLongFunction<V> vertexHash()
```
    Returns:
    
    the hash function for vertices
  - vertexEquality
```
BiPredicate<V,V> vertexEquality()
```
    Returns:
    
    the equality check for vertices
  - transpose
```
IGraph<V,E> transpose()
```
    Returns:
    
    a transposed version of the graph
  - split
```
default IList<? extends IGraph<V,E>> split(int parts)
```
    Description copied from interface: ICollection
    
    Splits the collection into roughly even pieces, for parallel processing. Depending on the size and contents of the collection, this function may not return exactly parts subsets.
    
    Specified by:
    
    split in interface ICollection<IGraph<V,E>,V>
    
    Parameters:
    
    parts - the target number of pieces
    
    Returns:
    
    a singleton list of the graph, unsplit. The graph can be split into separate pieces in linear time using Graphs.connectedComponents(IGraph).
  - add
```
default IGraph<V,E> add(IEdge<V,E> edge)
```
  - remove
```
default IGraph<V,E> remove(IEdge<V,E> edge)
```
  - link
```
default IGraph<V,E> link(V from,
                         V to,
                         E edge)
```
  - link
```
default IGraph<V,E> link(V from,
                         V to)
```
  - merge
```
default IGraph<V,E> merge(IGraph<V,E> graph,
                          BinaryOperator<E> merge)
```
  - merge
```
default IGraph<V,E> merge(IGraph<V,E> graph)
```

Interface IGraph<V,E>

Method Summary

Methods inherited from interface io.lacuna.bifurcan.ICollection

Methods inherited from interface java.lang.Iterable

Method Detail

vertices

edges

edge

in

out

link

unlink

add

remove

mapEdges

indexOf

nth

iterator

size

select

replace

replace

isDirected

vertexHash

vertexEquality

transpose

split

add

remove

link

link

merge

merge