org.squashtest.tm.domain.library.structures

Class LibraryGraph<IDENT,T extends GraphNode<IDENT,T>>

java.lang.Object

org.squashtest.tm.domain.library.structures.LibraryGraph<IDENT,T>

Type Parameters:

T -

public class LibraryGraph<IDENT,T extends GraphNode<IDENT,T>>
extends Object

Author:

bsiri

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	LibraryGraph.NodeTransformer<FORMER,NEW>
static class	LibraryGraph.SimpleNode<T>

Constructor Summary

Constructors

Constructor and Description
LibraryGraph()

Method Summary

Methods

Modifier and Type	Method and Description
void	addEdge(T parentNode, T childNode) will create either the parent or the child if they didn't exist already
void	addNode(T node)
int	cardEdge(IDENT src, IDENT dest)
<X> List<X>	collect(org.apache.commons.collections.Transformer transformer)
protected T	createIfNotExists(T node)
void	disconnect(IDENT src, IDENT dest) totally remove any inbound/outbound edges between the two nodes
List<T>	filter(org.apache.commons.collections.Predicate predicate)
<X> List<X>	filterAndcollect(org.apache.commons.collections.Predicate predicate, org.apache.commons.collections.Transformer transformer) first we'll filter, then we'll collect.
List<T>	getChildless()
T	getNode(IDENT key)
Collection<T>	getNodes()
List<T>	getOrphans()
boolean	hasEdge(IDENT src, IDENT dest)
<OIDENT,ON extends GraphNode<OIDENT,ON>,OG extends LibraryGraph<OIDENT,ON>> void	mergeGraph(OG othergraph, LibraryGraph.NodeTransformer<ON,T> transformer) Will merge the structure of a graph into this graph.
void	removeAllEdges(IDENT src, IDENT dest) remove all edges from src to dest, reducing effectively the cardinality to 0 (one cannot navigate from src to dest anymore)
void	removeEdge(IDENT src, IDENT dest) remove one edge from src to dest, not all of them (in case of cardinality > 1)
void	removeNode(IDENT target)
<OIDENT,ON extends GraphNode<OIDENT,ON>,OG extends LibraryGraph<OIDENT,ON>> void	substractGraph(OG othergraph, LibraryGraph.NodeTransformer<ON,T> transformer, boolean removeAll) Will remove from this graph any edge that exists in othergraph.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

LibraryGraph

public LibraryGraph()

Method Detail

getNodes

public Collection<T> getNodes()

addNode

public void addNode(T node)

addEdge

public void addEdge(T parentNode,
           T childNode)

will create either the parent or the child if they didn't exist already

Parameters:

parentData -

childData -

getNode

public T getNode(IDENT key)

createIfNotExists

protected T createIfNotExists(T node)

hasEdge

public boolean hasEdge(IDENT src,
              IDENT dest)

cardEdge

public int cardEdge(IDENT src,
           IDENT dest)

removeNode

public void removeNode(IDENT target)

removeEdge

public void removeEdge(IDENT src,
              IDENT dest)

remove one edge from src to dest, not all of them (in case of cardinality > 1)

removeAllEdges

public void removeAllEdges(IDENT src,
                  IDENT dest)

remove all edges from src to dest, reducing effectively the cardinality to 0 (one cannot navigate from src to dest anymore)

disconnect

public void disconnect(IDENT src,
              IDENT dest)

totally remove any inbound/outbound edges between the two nodes

Parameters:

src -

dest -

getOrphans

public List<T> getOrphans()

getChildless

public List<T> getChildless()

collect

public <X> List<X> collect(org.apache.commons.collections.Transformer transformer)

filter

public List<T> filter(org.apache.commons.collections.Predicate predicate)

filterAndcollect

public <X> List<X> filterAndcollect(org.apache.commons.collections.Predicate predicate,
                           org.apache.commons.collections.Transformer transformer)

first we'll filter, then we'll collect. So write your predicate and transformer carefully.

mergeGraph

public <OIDENT,ON extends GraphNode<OIDENT,ON>,OG extends LibraryGraph<OIDENT,ON>> void mergeGraph(OG othergraph,
                                                                                          LibraryGraph.NodeTransformer<ON,T> transformer)

Will merge the structure of a graph into this graph. This means that nodes will be created if no equivalent exist already, same goes for inbound/outbound edges . You must provide an implementation of LibraryGraph.NodeTransformer in order to allow the conversion of a node from the other graph into a node acceptable for this graph.

The merge Nodes and edges inserted that way will not erase existing data provided if nodes having same keys are already present.

The generics are the following :

• OIDENT : the class of the key of the other graph
• ON : the type definition of a node from the other graph
• OG : the type of the other graph

Parameters:

othergraph -

substractGraph

public <OIDENT,ON extends GraphNode<OIDENT,ON>,OG extends LibraryGraph<OIDENT,ON>> void substractGraph(OG othergraph,
                                                                                              LibraryGraph.NodeTransformer<ON,T> transformer,
                                                                                              boolean removeAll)

Will remove from this graph any edge that exists in othergraph. If removeAll is set to true every connection between the source and destination node of such edges will be removed, is false only their cardinalities will be substracted.

Parameters:

othergraph -

transformer -

removeAll -