PartitionGraph (MultiGraph API)

java.lang.Object
- org.nongnu.multigraph.PartitionGraph<N,E>

All Implemented Interfaces:

java.lang.Iterable<N>, java.util.Collection<N>, java.util.Observer, java.util.Set<N>, Graph<N,E>
```
public class PartitionGraph<N,E>
extends java.lang.Object
implements Graph<N,E>, java.util.Observer
```
Partition the nodes of the supplied graph. Assignment of nodes to partitions is controlled by a user supplied callback class, with the PartitionCallbacks interface. Updates to the underlying graph automatically keep the partition updated.

Author:

Paul Jakma

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static interface PartitionGraph.PartitionCallbacks<N,E>

Nested Classes
Modifier and Type	Class and Description
`static interface`	`PartitionGraph.PartitionCallbacks<N,E>`

Constructor Summary

Constructors
Constructor and Description

PartitionGraph(PartitionGraph.PartitionCallbacks<N,E> cb)

Constructors
Constructor and Description
`PartitionGraph(PartitionGraph.PartitionCallbacks<N,E> cb)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`add(N node)` Add the given node to the graph, sans edges
`boolean`	`addAll(java.util.Collection<? extends N> clctn)`
`void`	`addObserver(java.util.Observer o)`
`float`	`avg_nodal_degree()`
`void`	`clear_all_edges()` Clear all edges from the graph.
`void`	`clear()`
`boolean`	`contains(java.lang.Object o)`
`boolean`	`containsAll(java.util.Collection<?> clctn)`
`int`	`countObservers()`
`void`	`deleteObserver(java.util.Observer o)`
`void`	`deleteObservers()`
`int`	`edge_outdegree(N node)` The out-degree for a give node.
`Edge<N,E>`	`edge(N from, N to)` Find the first edge from a node to another node.
`Edge<N,E>`	`edge(N from, N to, E label)` Find the edge with the given label, from the one node to another node, if it exists.
`java.util.Set<Edge<N,E>>`	`edges(N from)`
`java.util.Collection<Edge<N,E>>`	`edges(N from, N to)` Find the edges going from one node to another node.
`boolean`	`hasChanged()`
`boolean`	`is_directed()`
`boolean`	`is_linked(N from, N to)` Determine if there is a link from one node to another.
`boolean`	`is_simple()`
`boolean`	`isEmpty()`
`java.util.Iterator<N>`	`iterator()`
`long`	`link_count()`
`int`	`max_nodal_degree()`
`int`	`nodal_outdegree(N node)`
`void`	`notifyObservers()`
`void`	`notifyObservers(java.lang.Object arg)`
`java.util.Set<N>`	`partition(int id)` Retrieve a particular partition of the nodes.
`int`	`partitions()`
`void`	`plugObservable()` "Plug" delivery of Observable events to observers, so that any such events are instead queued up internally, and potentially coalesced, rather than delivered to Observers.
`java.lang.Iterable<Edge<N,E>>`	`random_edge_iterable(N n)` Provide a random-access Iterable over the <Edge<N,E>>-edges from the given node.
`java.lang.Iterable<N>`	`random_node_iterable()` Provide a random-access Iterable over the <N>-nodes in the graph.
`boolean`	`remove(N from, N to)` Remove all edges that go from one node to another
`boolean`	`remove(N from, N to, E label)` Remove 1 specific edge, given by the label, from between two nodes.
`boolean`	`remove(java.lang.Object o)`
`boolean`	`removeAll(java.util.Collection<?> clctn)`
`boolean`	`retainAll(java.util.Collection<?> clctn)`
`void`	`set(N from, N to, E label)` Set an edge from one node to another with the given label.
`void`	`set(N from, N to, E label, int weight)` Set an edge from one node to another with the given label and weight.
`int`	`size()`
`java.util.Set<N>`	`successors(N from)`
`java.lang.Object[]`	`toArray()`
`<T> T[]`	`toArray(T[] ts)`
`void`	`unplugObservable()` Unplug the delivery of Observable events.
`void`	`update(java.util.Observable o, java.lang.Object o1)`

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

Methods inherited from interface java.util.Set
equals, hashCode, spliterator

Methods inherited from interface java.util.Collection
parallelStream, removeIf, stream

Methods inherited from interface java.lang.Iterable
forEach

- Constructor Detail
  - PartitionGraph
```
public PartitionGraph(PartitionGraph.PartitionCallbacks<N,E> cb)
```
- Method Detail
  - partition
```
public java.util.Set<N> partition(int id)
```
    Retrieve a particular partition of the nodes.
    
    Parameters:
    
    id - The partition id to retrieve
    
    Returns:
    
    A Set of the nodes in this partition,
  - partitions
```
public int partitions()
```
  - is_directed
```
public boolean is_directed()
```
    Specified by:
    
    is_directed in interface Graph<N,E>
    
    Returns:
    
    Whether the graph is directed or not, i.e. whether edges have a direction.
  - is_simple
```
public boolean is_simple()
```
    Specified by:
    
    is_simple in interface Graph<N,E>
    
    Returns:
    
    Whether the graph is simple or not. A simple graph allows only single edges between nodes.
  - set
```
public void set(N from,
                N to,
                E label)
```
    Description copied from interface: Graph
    
    Set an edge from one node to another with the given label. Weight defaults to 1. Nodes are automatically added to graph, as needs be. If a given edge for <from,to,label> }already exists, then the weight is updated.
    
    Specified by:
    
    set in interface Graph<N,E>
    
    Parameters:
    
    from - Node from which the edge originates.
    
    to - Node to which the edges goes.
    
    label - The user's label for this edge.
  - set
```
public void set(N from,
                N to,
                E label,
                int weight)
```
    Description copied from interface: Graph
    
    Set an edge from one node to another with the given label and weight.
    
    Specified by:
    
    set in interface Graph<N,E>
    
    weight - a user-specified metric or weight for the edge
    
    See Also:
    
    Graph.set(Object, Object, Object)
  - add
```
public boolean add(N node)
```
    Description copied from interface: Graph
    
    Add the given node to the graph, sans edges
    
    Specified by:
    
    add in interface java.util.Collection<N>
    
    Specified by:
    
    add in interface java.util.Set<N>
    
    Specified by:
    
    add in interface Graph<N,E>
  - remove
```
public boolean remove(N from,
                      N to,
                      E label)
```
    Description copied from interface: Graph
    
    Remove 1 specific edge, given by the label, from between two nodes.
    
    Specified by:
    
    remove in interface Graph<N,E>
    
    Returns:
    
    Whether an edge was removed
  - remove
```
public boolean remove(N from,
                      N to)
```
    Description copied from interface: Graph
    
    Remove all edges that go from one node to another
    
    Specified by:
    
    remove in interface Graph<N,E>
    
    Returns:
    
    Whether an edge was removed
    
    See Also:
    
    Graph.set(Object, Object, Object), Graph.add(Object)
  - clear_all_edges
```
public void clear_all_edges()
```
    Description copied from interface: Graph
    
    Clear all edges from the graph. This can NOT be done by iterating over the sets of edges from each node, as that will raise a concurrent modification exception.
    
    Specified by:
    
    clear_all_edges in interface Graph<N,E>
  - edge_outdegree
```
public int edge_outdegree(N node)
```
    Description copied from interface: Graph
    
    The out-degree for a give node. I.e. the number of edges leaving the node.
    
    Specified by:
    
    edge_outdegree in interface Graph<N,E>
  - nodal_outdegree
```
public int nodal_outdegree(N node)
```
    Specified by:
    
    nodal_outdegree in interface Graph<N,E>
    
    Returns:
    
    The number of distinct nodes to which this node has edges.
  - avg_nodal_degree
```
public float avg_nodal_degree()
```
    Specified by:
    
    avg_nodal_degree in interface Graph<N,E>
    
    Returns:
    
    The average nodal out-degree.
  - link_count
```
public long link_count()
```
    Specified by:
    
    link_count in interface Graph<N,E>
    
    Returns:
    
    The number of edges in the graph
  - max_nodal_degree
```
public int max_nodal_degree()
```
    Specified by:
    
    max_nodal_degree in interface Graph<N,E>
    
    Returns:
    
    The maximum degree of any node in the graph
  - successors
```
public java.util.Set<N> successors(N from)
```
    Specified by:
    
    successors in interface Graph<N,E>
    
    Returns:
    
    The set of nodes that succeed the given node. I.e. those nodes to which the given node has an edge. The returned set is read-only and may not be modified. The returned set will be null if the node does not exist, and will be the empty set if the node exists but has no successors.
  - edges
```
public java.util.Set<Edge<N,E>> edges(N from)
```
    Specified by:
    
    edges in interface Graph<N,E>
    
    Returns:
    
    The set of edges that go out from this node. The returned set is read-only and may not be modified. The set will be null if the node does not exist, and an empty set if the node exists but has no edges.
  - edges
```
public java.util.Collection<Edge<N,E>> edges(N from,
                                             N to)
```
    Description copied from interface: Graph
    
    Find the edges going from one node to another node.
    
    Specified by:
    
    edges in interface Graph<N,E>
    
    Parameters:
    
    from - Which node we want to query edges from.
    
    to - The node to which we're looking for an edge.
    
    Returns:
    
    An immutable Collection of edges going from
    
    See Also:
    
    Graph.edges(Object)
  - edge
```
public Edge<N,E> edge(N from,
                      N to)
```
    Description copied from interface: Graph
    
    Find the first edge from a node to another node.
    
    Specified by:
    
    edge in interface Graph<N,E>
    
    Parameters:
    
    from - Which node we want to query edges from.
    
    to - The node to which we're looking for an edge.
    
    Returns:
    
    An edge going from from->to if any exist, or null otherwise.
  - is_linked
```
public boolean is_linked(N from,
                         N to)
```
    Description copied from interface: Graph
    
    Determine if there is a link from one node to another.
    
    Specified by:
    
    is_linked in interface Graph<N,E>
    
    Returns:
    
    True if an edge exists from -> to
  - edge
```
public Edge<N,E> edge(N from,
                      N to,
                      E label)
```
    Description copied from interface: Graph
    
    Find the edge with the given label, from the one node to another node, if it exists.
    
    Specified by:
    
    edge in interface Graph<N,E>
    
    Parameters:
    
    from - Which node we want to query edges from.
    
    to - The node to which we're looking for an edge.
    
    label - The label of the edge we're interested in.
    
    Returns:
    
    The edge going from from->to specified by the given label, if it exists, or null otherwise.
  - random_node_iterable
```
public java.lang.Iterable<N> random_node_iterable()
```
    Description copied from interface: Graph
    
    Provide a random-access Iterable over the <N>-nodes in the graph.
    
    Specified by:
    
    random_node_iterable in interface Graph<N,E>
  - random_edge_iterable
```
public java.lang.Iterable<Edge<N,E>> random_edge_iterable(N n)
```
    Description copied from interface: Graph
    
    Provide a random-access Iterable over the <Edge<N,E>>-edges from the given node.
    
    Specified by:
    
    random_edge_iterable in interface Graph<N,E>
  - addObserver
```
public void addObserver(java.util.Observer o)
```
    Specified by:
    
    addObserver in interface Graph<N,E>
    
    See Also:
    
    Observable
  - countObservers
```
public int countObservers()
```
    Specified by:
    
    countObservers in interface Graph<N,E>
    
    See Also:
    
    Observable
  - deleteObserver
```
public void deleteObserver(java.util.Observer o)
```
    Specified by:
    
    deleteObserver in interface Graph<N,E>
    
    See Also:
    
    Observable
  - deleteObservers
```
public void deleteObservers()
```
    Specified by:
    
    deleteObservers in interface Graph<N,E>
    
    See Also:
    
    Observable
  - hasChanged
```
public boolean hasChanged()
```
    Specified by:
    
    hasChanged in interface Graph<N,E>
    
    See Also:
    
    Observable
  - notifyObservers
```
public void notifyObservers()
```
    Specified by:
    
    notifyObservers in interface Graph<N,E>
    
    See Also:
    
    Observable
  - notifyObservers
```
public void notifyObservers(java.lang.Object arg)
```
    Specified by:
    
    notifyObservers in interface Graph<N,E>
    
    See Also:
    
    Observable
  - plugObservable
```
public void plugObservable()
```
    Description copied from interface: Graph
    
    "Plug" delivery of Observable events to observers, so that any such events are instead queued up internally, and potentially coalesced, rather than delivered to Observers. This potentially allows bulk updates to be made to the graph more efficiently.
    
    Specified by:
    
    plugObservable in interface Graph<N,E>
  - unplugObservable
```
public void unplugObservable()
```
    Description copied from interface: Graph
    
    Unplug the delivery of Observable events. Stored events will be delivered, though potentially coalesced, so that multiple events for the same object are collapsed into one. Further, a general "notifyObservers" event will coalesce with and subsume *all* events for specific objects.
    
    Specified by:
    
    unplugObservable in interface Graph<N,E>
  - size
```
public int size()
```
    Specified by:
    
    size in interface java.util.Collection<N>
    
    Specified by:
    
    size in interface java.util.Set<N>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface java.util.Collection<N>
    
    Specified by:
    
    isEmpty in interface java.util.Set<N>
  - contains
```
public boolean contains(java.lang.Object o)
```
    Specified by:
    
    contains in interface java.util.Collection<N>
    
    Specified by:
    
    contains in interface java.util.Set<N>
  - iterator
```
public java.util.Iterator<N> iterator()
```
    Specified by:
    
    iterator in interface java.lang.Iterable<N>
    
    Specified by:
    
    iterator in interface java.util.Collection<N>
    
    Specified by:
    
    iterator in interface java.util.Set<N>
  - toArray
```
public java.lang.Object[] toArray()
```
    Specified by:
    
    toArray in interface java.util.Collection<N>
    
    Specified by:
    
    toArray in interface java.util.Set<N>
  - toArray
```
public <T> T[] toArray(T[] ts)
```
    Specified by:
    
    toArray in interface java.util.Collection<N>
    
    Specified by:
    
    toArray in interface java.util.Set<N>
  - remove
```
public boolean remove(java.lang.Object o)
```
    Specified by:
    
    remove in interface java.util.Collection<N>
    
    Specified by:
    
    remove in interface java.util.Set<N>
  - containsAll
```
public boolean containsAll(java.util.Collection<?> clctn)
```
    Specified by:
    
    containsAll in interface java.util.Collection<N>
    
    Specified by:
    
    containsAll in interface java.util.Set<N>
  - addAll
```
public boolean addAll(java.util.Collection<? extends N> clctn)
```
    Specified by:
    
    addAll in interface java.util.Collection<N>
    
    Specified by:
    
    addAll in interface java.util.Set<N>
  - retainAll
```
public boolean retainAll(java.util.Collection<?> clctn)
```
    Specified by:
    
    retainAll in interface java.util.Collection<N>
    
    Specified by:
    
    retainAll in interface java.util.Set<N>
  - removeAll
```
public boolean removeAll(java.util.Collection<?> clctn)
```
    Specified by:
    
    removeAll in interface java.util.Collection<N>
    
    Specified by:
    
    removeAll in interface java.util.Set<N>
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface java.util.Collection<N>
    
    Specified by:
    
    clear in interface java.util.Set<N>
  - update
```
public void update(java.util.Observable o,
                   java.lang.Object o1)
```
    Specified by:
    
    update in interface java.util.Observer

Class PartitionGraph<N,E>

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Set

Methods inherited from interface java.util.Collection

Methods inherited from interface java.lang.Iterable

Constructor Detail

PartitionGraph

Method Detail

partition

partitions

is_directed

is_simple

set

set

add

remove

remove

clear_all_edges

edge_outdegree

nodal_outdegree

avg_nodal_degree

link_count

max_nodal_degree

successors

edges

edges

edge

is_linked

edge

random_node_iterable

random_edge_iterable

addObserver

countObservers

deleteObserver

deleteObservers

hasChanged

notifyObservers

notifyObservers

plugObservable

unplugObservable

size

isEmpty

contains

iterator

toArray

toArray

remove

containsAll

addAll

retainAll

removeAll

clear

update