io.ataraxic.nomicflux.voyageur

Interface Graph<A,N extends Node<A>,E extends Edge<A,N,E>,I extends Iterable<E>,G extends Graph<A,N,E,I,G>>

Type Parameters:

A - The type of a Node's ID

N - The concrete type of a Node

E - The concrete type of an Edge

I - The concrete type of an Iterable of edges

G - Unification type for the concrete Graph implementation

All Known Implementing Classes:

AdjListGraph

public interface Graph<A,N extends Node<A>,E extends Edge<A,N,E>,I extends Iterable<E>,G extends Graph<A,N,E,I,G>>

Main interface for working with inductive graphs

Method Summary

Modifier and Type	Method and Description
default Fn1<E,G>	addEdge()
G	addEdge(E edge)
default Fn1<N,G>	addNode()
G	addNode(N node)
default Fn1<N,Choice2<G,Tuple2<Context<A,N,E,I>,G>>>	atNode()
Choice2<G,Tuple2<Context<A,N,E,I>,G>>	atNode(N node) Decompose a graph at a given Node into the node's Context and the rest of the graph
Maybe<Tuple2<Context<A,N,E,I>,G>>	decompose() Implementation-dependent and possibly non-deterministic decomposition of a graph into a Context and the rest of the graph
default <S,Acc> Acc	guidedCutFold(Fn1<Context<A,N,E,I>,Boolean> destinationCheck, State<S,FoldContinue<N>> contextGetter, Fn2<Acc,Context<A,N,E,I>,State<S,Acc>> accumulator, S defState, Acc defAcc) Fold a graph into an accumulation, using stateful methods to guide the traversal of the graph, and a cutoff function to end the fold early
default <S,Acc> Acc	guidedFold(State<S,FoldContinue<N>> contextGetter, Fn2<Acc,Context<A,N,E,I>,State<S,Acc>> accumulator, S defState, Acc defAcc) Fold a graph into an accumulation, using stateful methods to guide the traversal of the graph.
Boolean	isEmpty()
default Fn1<E,G>	removeEdge()
G	removeEdge(E edge)
default Fn1<N,G>	removeNode()
G	removeNode(N node)
default <Acc> Acc	simpleCutFold(Fn1<Context<A,N,E,I>,Boolean> destinationCheck, Fn2<Acc,Context<A,N,E,I>,Acc> accumulator, Acc defAcc) Fold a graph into an accumulation, using the implementation's decompose() method, and a cutoff function to end the fold early
default <Acc> Acc	simpleFold(Fn2<Acc,Context<A,N,E,I>,Acc> accumulator, Acc defAcc) Fold a graph into an accumulation, using the implementation's decompose() method.

Method Detail

isEmpty

Boolean isEmpty()

Returns:

Whether the current graph is empty

addEdge

G addEdge(E edge)

Parameters:

edge - Edge to add to graph

Returns:

Graph G with edge added

addEdge

default Fn1<E,G> addEdge()

removeEdge

G removeEdge(E edge)

Parameters:

edge - Edge to remove from graph

Returns:

Graph G with edge removed

removeEdge

default Fn1<E,G> removeEdge()

addNode

G addNode(N node)

Parameters:

node - Node to add to graph

Returns:

Graph G with disconnected node added

addNode

default Fn1<N,G> addNode()

removeNode

G removeNode(N node)

Parameters:

node - Node to remove from graph

Returns:

Graph G with node and all connected edges removed

removeNode

default Fn1<N,G> removeNode()

decompose

Maybe<Tuple2<Context<A,N,E,I>,G>> decompose()

Implementation-dependent and possibly non-deterministic decomposition of a graph into a Context and the rest of the graph

Returns:

Either the Context and the graph with the context's Node and Edges removed, or nothing to indicate the graph is empty

atNode

Choice2<G,Tuple2<Context<A,N,E,I>,G>> atNode(N node)

Decompose a graph at a given Node into the node's Context and the rest of the graph

Parameters:

node - Node to find in the graph, around which to base a decomposition

Returns:

Either the whole graph G if the node cannot be found, or a decomposition into a context centered on node and the rest of the graph

atNode

default Fn1<N,Choice2<G,Tuple2<Context<A,N,E,I>,G>>> atNode()

guidedCutFold

default <S,Acc> Acc guidedCutFold(Fn1<Context<A,N,E,I>,Boolean> destinationCheck,
                                  State<S,FoldContinue<N>> contextGetter,
                                  Fn2<Acc,Context<A,N,E,I>,State<S,Acc>> accumulator,
                                  S defState,
                                  Acc defAcc)

Fold a graph into an accumulation, using stateful methods to guide the traversal of the graph, and a cutoff function to end the fold early

Type Parameters:

S - Type of the State updated in the fold

Acc - Type of the accumulator returned from the fold

Parameters:

destinationCheck - End the fold if a Context matches this predicate

contextGetter - Retrieve the next Node from a given State S. If the state can't produce a new node, a FoldContinue determines whether the fold should decompose arbitrarily or end.

accumulator - Stateful function to update the accumulator based on the new Context and the State

defState - Starting State S

defAcc - Starting accumulator Acc

Returns:

The accumulator at the end of the fold

guidedFold

default <S,Acc> Acc guidedFold(State<S,FoldContinue<N>> contextGetter,
                               Fn2<Acc,Context<A,N,E,I>,State<S,Acc>> accumulator,
                               S defState,
                               Acc defAcc)

Fold a graph into an accumulation, using stateful methods to guide the traversal of the graph. Fold traverses entire graph.

Type Parameters:

S - Type of the State updated in the fold

Acc - Type of the accumulator returned from the fold

Parameters:

contextGetter - Retrieve the next Node from a given State S. If the state can't produce a new node, a FoldContinue determines whether the fold should decompose arbitrarily or end.

accumulator - Stateful function to update the accumulator based on the new Context and the State

defState - Starting State S

defAcc - Starting accumulator Acc

Returns:

The accumulator at the end of the fold

simpleCutFold

default <Acc> Acc simpleCutFold(Fn1<Context<A,N,E,I>,Boolean> destinationCheck,
                                Fn2<Acc,Context<A,N,E,I>,Acc> accumulator,
                                Acc defAcc)

Fold a graph into an accumulation, using the implementation's decompose() method, and a cutoff function to end the fold early

Type Parameters:

Acc - Type of the accumulator returned from the fold

Parameters:

destinationCheck - End the fold if a Context matches this predicate

accumulator - Function to update the accumulator based on the new Context

defAcc - Starting accumulator Acc

Returns:

The accumulator at the end of the fold

simpleFold

default <Acc> Acc simpleFold(Fn2<Acc,Context<A,N,E,I>,Acc> accumulator,
                             Acc defAcc)

Fold a graph into an accumulation, using the implementation's decompose() method. Traverses the entire graph.

Type Parameters:

Acc - Type of the accumulator returned from the fold

Parameters:

accumulator - Function to update the accumulator based on the new Context

defAcc - Starting accumulator Acc

Returns:

The accumulator at the end of the fold