org.corpus_tools.salt.graph.impl

Class GraphImpl<N extends Node,R extends Relation<N,N>,L extends Layer<N,R>>

java.lang.Object

org.corpus_tools.salt.graph.impl.LabelableElementImpl

org.corpus_tools.salt.graph.impl.IdentifiableElementImpl

org.corpus_tools.salt.graph.impl.GraphImpl<N,R,L>

All Implemented Interfaces:

Serializable, Graph<N,R,L>, IdentifiableElement, LabelableElement

Direct Known Subclasses:

SGraphImpl

public class GraphImpl<N extends Node,R extends Relation<N,N>,L extends Layer<N,R>>
extends IdentifiableElementImpl
implements Graph<N,R,L>

See Also:

Serialized Form

Field Summary

Fields

Modifier and Type	Field and Description
protected int	approximatedNodeDegree Approximated node degree, which is expectedRelations / expectedNodes
protected int	expectedNodes Number of expected nodes to initialize indexes
protected int	expectedRelations Number of expected relations to initialize indexes
protected IndexMgr	indexMgr Index manager

Fields inherited from class org.corpus_tools.salt.graph.impl.LabelableElementImpl

EXPECTED_NUMBER_OF_LABELS

Constructor Summary

Constructors

Constructor and Description
GraphImpl()
GraphImpl(int expectedNodes, int expectedRelations) Instantiates a new graph object and sets the initial capacity for all indexes to the passed ones

Method Summary

Methods

Modifier and Type	Method and Description
void	addLayer(L layer) Adds the passed layer to this graph.
void	addNode(N node) Adds the passed node to this graph and updates indexes.
void	addRelation(Relation<? extends N,? extends N> relation) Adds the passed relation to this graph and updates indexes.
protected void	basicAddLayer(L layer) This is an internally used method.
protected void	basicAddNode(N node) This is an internally used method.
protected void	basicAddRelation(Relation<? extends Node,? extends Node> relation) This is an internally used method.
protected void	basicRemoveLayer(L layer) This is an internally used method.
protected void	basicRemoveNode(N node) This is an internally used method.
protected void	basicRemoveRelation(Relation<? extends N,? extends N> rel) This is an internally used method.
boolean	containsLayer(String layerId) Returns whether this graph contains a Layer corresponding to the passed id.
boolean	containsNode(String nodeId) Returns whether this graph contains a Node corresponding to the passed id.
boolean	containsRelation(String relationId) Returns whether this graph contains an Relation corresponding to the passed id.
IndexMgr	getIndexMgr() Returns the index manager.
List<R>	getInRelations(String nodeId) Returns all relations, which have the node corresponding to the passed id as their target node.
L	getLayer(String layerId) Returns a layer corresponding to the passed id, if such a layer is contained in the graph.
Set<L>	getLayers() Returns a set of layers contained by this graph.
N	getNode(String nodeId) Returns a node corresponding to the passed id, if such a node is contained in the graph.
List<N>	getNodes() Returns a list of all relations contained in this graph.
List<R>	getOutRelations(String nodeId) Returns all relations, which have the node corresponding to the passed id as their source node.
R	getRelation(String relationId) Returns an relation corresponding to the passed id, if such an relation is contained in the graph.
List<R>	getRelations() Returns a list of all relations contained in this graph.
List<R>	getRelations(String nodeId1, String nodeId2) Returns all relations,which connects the two passed nodes.
protected void	init() Initializes an object of type GraphImpl.
void	removeLayer(L layer) Removes the passed layer from this graph and cleans all indexes.
void	removeNode(N node) Removes the passed node from this graph and cleans all indexes.
void	removeRelation(Relation<? extends N,? extends N> rel) Removes the passed relation from this graph.
void	removeRelations() Removes all relations from this graph and cleans all indexes.
protected void	update(Object oldValue, Object container, org.corpus_tools.salt.graph.impl.GraphImpl.UPDATE_TYPE updateType) Updates all graph internal indexes, concerning the kind of the update which has been made.

Methods inherited from class org.corpus_tools.salt.graph.impl.IdentifiableElementImpl

getId, getIdentifier, removeLabel, setId, setIdentifier, toString

Methods inherited from class org.corpus_tools.salt.graph.impl.LabelableElementImpl

addLabel, basicAddLabel, basicRemoveLabel, containsLabel, getLabel, getLabel, getLabels, getLabelsByNamespace, removeAll, removeLabel, sizeLabels

Methods inherited from class java.lang.Object

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

Methods inherited from interface org.corpus_tools.salt.graph.IdentifiableElement

getId, getIdentifier, setId, setIdentifier

Methods inherited from interface org.corpus_tools.salt.graph.LabelableElement

addLabel, containsLabel, getLabel, getLabel, getLabels, getLabelsByNamespace, removeAll, removeLabel, removeLabel, sizeLabels

Field Detail

indexMgr

protected IndexMgr indexMgr

Index manager

expectedNodes

protected int expectedNodes

Number of expected nodes to initialize indexes

expectedRelations

protected int expectedRelations

Number of expected relations to initialize indexes

approximatedNodeDegree

protected int approximatedNodeDegree

Approximated node degree, which is expectedRelations / expectedNodes

Constructor Detail

GraphImpl

public GraphImpl()

GraphImpl

public GraphImpl(int expectedNodes,
         int expectedRelations)

Instantiates a new graph object and sets the initial capacity for all indexes to the passed ones

Parameters:

expectedNodes - expected upper bound of nodes in the graph, used for optimization

expectedRelations - expected upper bound of relations in the graph, used for optimization

Method Detail

getIndexMgr

public IndexMgr getIndexMgr()

Returns the index manager. The index manager is used to register indexes for sets of nodes, relations, layers etc. or single values. The manager contains all indexes used by the Graph class. These indexes are:

• SaltUtil.IDX_ID_NODES
• SaltUtil.IDX_ID_RELATIONS

Even further indexes can be added to the index manager.

Specified by:

getIndexMgr in interface Graph<N extends Node,R extends Relation<N,N>,L extends Layer<N,R>>

Returns:

the index manager

init

protected void init()

Initializes an object of type GraphImpl.

• SaltUtil.IDX_ID_NODES
• SaltUtil.IDX_ID_RELATIONS
• SaltUtil.IDX_ID_LAYER
• SaltUtil.IDX_OUT_RELATIONS
• SaltUtil.IDX_IN_RELATIONS

getNodes

public List<N> getNodes()

Returns a list of all relations contained in this graph.

Specified by:

getNodes in interface Graph<N extends Node,R extends Relation<N,N>,L extends Layer<N,R>>

Returns:

a list of all contained relations.

getNode

public N getNode(String nodeId)

Returns a node corresponding to the passed id, if such a node is contained in the graph.

Specified by:

getNode in interface Graph<N extends Node,R extends Relation<N,N>,L extends Layer<N,R>>

Parameters:

nodeId - id of the node to be searched for

addNode

public void addNode(N node)

Adds the passed node to this graph and updates indexes. If node is null or node is already contained nothing is inserted. The passed node and this graph will be double chained, which means the method Node.getGraph() will return this graph.

Specified by:

addNode in interface Graph<N extends Node,R extends Relation<N,N>,L extends Layer<N,R>>

Parameters:

node - node to be inserted

basicAddNode

protected void basicAddNode(N node)

This is an internally used method. To implement a double chaining of Graph and Node object when an node is inserted into this graph and to avoid an endless invocation the insertion of an relation is split into the two methods #addNode(node) and basicAddNode(Node). The invocation of methods is implement as follows:

 #addNode(node)                      Node.setGraph(Graph)
         ||             \ /                   ||
         ||              X                    ||
         \/             / \                   \/
 basicAddNode(Node)            Node#basicSetGraph(Graph)
 

That means method addNode(Node) calls basicAddNode(Node) and Node#basicSetGraph(Graph). And method Node.setGraph(Graph) calls basicAddNode(Node) and Node#basicSetGraph(Graph).

Parameters:

node - node to be inserted

removeNode

public void removeNode(N node)

Removes the passed node from this graph and cleans all indexes. It also ensures, that the graph is removed from the node, thus invoking Node.getGraph() will return null. The double chaining between this graph and the passed node will be cut off. If the passed node is null nothing is done.

Specified by:

removeNode in interface Graph<N extends Node,R extends Relation<N,N>,L extends Layer<N,R>>

Parameters:

node - the node to be removed

basicRemoveNode

protected void basicRemoveNode(N node)

This is an internally used method. To realize the cut of the double chaining, the removal is split in two methods removeNode(Node) and basicRemoveNode(Node). which are connected as follows:

 #removeNode(node)                      Node#setGraph(null)
         ||             \ /                   ||
         ||              X                    ||
         \/             / \                   \/
 basicRemoveNode(Node)            Node#basicSetGraph(null)
 

Parameters:

node - the node to be removed

containsNode

public boolean containsNode(String nodeId)

Returns whether this graph contains a Node corresponding to the passed id.

Specified by:

containsNode in interface Graph<N extends Node,R extends Relation<N,N>,L extends Layer<N,R>>

Parameters:

nodeId - id of the node to be checked

Returns:

true if the node is contained, false otherwise

getRelations

public List<R> getRelations()

Returns a list of all relations contained in this graph.

Specified by:

getRelations in interface Graph<N extends Node,R extends Relation<N,N>,L extends Layer<N,R>>

Returns:

a list of all contained relations.

getRelation

public R getRelation(String relationId)

Returns an relation corresponding to the passed id, if such an relation is contained in the graph.

Specified by:

getRelation in interface Graph<N extends Node,R extends Relation<N,N>,L extends Layer<N,R>>

Parameters:

relationId - id of the relation to be searched for

getRelations

public List<R> getRelations(String nodeId1,
                   String nodeId2)

Returns all relations,which connects the two passed nodes.

Specified by:

getRelations in interface Graph<N extends Node,R extends Relation<N,N>,L extends Layer<N,R>>

Parameters:

nodeId1 - the id of the source node

nodeId2 - the id of the target node

Returns:

returns all nodes between source node and target node

getInRelations

public List<R> getInRelations(String nodeId)

Returns all relations, which have the node corresponding to the passed id as their target node.

Specified by:

getInRelations in interface Graph<N extends Node,R extends Relation<N,N>,L extends Layer<N,R>>

Parameters:

nodeId - id corresponding to the node, for which all incoming relations should be searched

Returns:

a list of all incoming relations

getOutRelations

public List<R> getOutRelations(String nodeId)

Returns all relations, which have the node corresponding to the passed id as their source node.

Specified by:

getOutRelations in interface Graph<N extends Node,R extends Relation<N,N>,L extends Layer<N,R>>

Parameters:

nodeId - id corresponding to the node, for which all outgoing relations should be searched

Returns:

a list of all outgoing relations

addRelation

public void addRelation(Relation<? extends N,? extends N> relation)

Adds the passed relation to this graph and updates indexes. If relation is null or relation is already contained nothing is inserted. The passed relation and this graph will be double chained, which means the method Relation.getGraph() will return this graph.

Specified by:

addRelation in interface Graph<N extends Node,R extends Relation<N,N>,L extends Layer<N,R>>

Parameters:

relation - relation to be inserted

basicAddRelation

protected void basicAddRelation(Relation<? extends Node,? extends Node> relation)

This is an internally used method. To implement a double chaining of Graph and Relation object when an relation is inserted into this graph and to avoid an endless invocation the insertion of an relation is split into the two methods addRelation(Relation) and basicAddRelation(Relation). The invocation of methods is implement as follows:

 addRelation(Relation)                      Relation.setGraph(Graph)
         ||             \ /                   ||
         ||              X                    ||
         \/             / \                   \/
 basicAddRelation(Relation)            Relation#basicSetGraph(Graph)
 

That means method addRelation(Relation) calls basicAddRelation(Relation) and Relation#basicSetGraph(Graph). And method Relation.setGraph(Graph) calls basicAddRelation(Relation) and Relation#basicSetGraph(Graph).

Parameters:

relation - relation to be inserted

update

protected void update(Object oldValue,
          Object container,
          org.corpus_tools.salt.graph.impl.GraphImpl.UPDATE_TYPE updateType)
               throws SaltException

Updates all graph internal indexes, concerning the kind of the update which has been made. If the update could not be performed, false is returned. True otherwise.

Parameters:

oldValue - old value

container - the object which has been updated

updateType - type of update to be performed

Throws:

SaltException - in case the update could not be performed

removeRelation

public void removeRelation(Relation<? extends N,? extends N> rel)

Removes the passed relation from this graph. If a relation is removed, it will be deleted from all indexes. If the passed relation is null, nothing is removed.

Specified by:

removeRelation in interface Graph<N extends Node,R extends Relation<N,N>,L extends Layer<N,R>>

Parameters:

rel - relation to be removed

removeRelations

public void removeRelations()

Removes all relations from this graph and cleans all indexes.

Specified by:

removeRelations in interface Graph<N extends Node,R extends Relation<N,N>,L extends Layer<N,R>>

basicRemoveRelation

protected void basicRemoveRelation(Relation<? extends N,? extends N> rel)

This is an internally used method. To realize the cut of the double chaining, the removal is split in two methods removeRelation(Relation) and basicRemoveRelation(Relation). which are connected as follows:

 #removeRelation(relation)                      Relation#setGraph(null)
         ||             \ /                   ||
         ||              X                    ||
         \/             / \                   \/
 basicRemoveRelation(Relation)            Relation#basicSetGraph(null)
 

Parameters:

relation - the relation to be removed

containsRelation

public boolean containsRelation(String relationId)

Returns whether this graph contains an Relation corresponding to the passed id.

Specified by:

containsRelation in interface Graph<N extends Node,R extends Relation<N,N>,L extends Layer<N,R>>

Parameters:

relationId - id of the node to be checked

Returns:

true if the relation is contained, false otherwise

getLayers

public Set<L> getLayers()

Returns a set of layers contained by this graph.

Specified by:

getLayers in interface Graph<N extends Node,R extends Relation<N,N>,L extends Layer<N,R>>

Returns:

all contained layers

getLayer

public L getLayer(String layerId)

Returns a layer corresponding to the passed id, if such a layer is contained in the graph.

Specified by:

getLayer in interface Graph<N extends Node,R extends Relation<N,N>,L extends Layer<N,R>>

Parameters:

layerId - id of the layer to be searched for

containsLayer

public boolean containsLayer(String layerId)

Returns whether this graph contains a Layer corresponding to the passed id.

Specified by:

containsLayer in interface Graph<N extends Node,R extends Relation<N,N>,L extends Layer<N,R>>

Parameters:

layerId - id of the node to be checked

Returns:

true if the node is contained, false otherwise

addLayer

public void addLayer(L layer)

Adds the passed layer to this graph. If layer is null or layer is already contained nothing is inserted. The passed layer and this graph will be double chained, which means the method Layer.getGraph() will return this graph. If the passed layer contains nodes or relations, which are not already contained by the graph, they will be added.

Specified by:

addLayer in interface Graph<N extends Node,R extends Relation<N,N>,L extends Layer<N,R>>

Parameters:

layer - layer to be inserted

basicAddLayer

protected void basicAddLayer(L layer)

This is an internally used method. To implement a double chaining of Graph and Node object when an node is inserted into this graph and to avoid an endless invocation the insertion of an relation is split into the two methods #addNode(node) and basicAddNode(Node). The invocation of methods is implement as follows:

 #addLayer(layer)                      Layer.setGraph(Graph)
         ||             \ /                   ||
         ||              X                    ||
         \/             / \                   \/
 basicAddLayer(Layer)            Layer#basicSetGraph(Graph)
 

That means method addLayer(Layer) calls basicAddLayer(Layer) and Node#basicSetGraph(Graph). And method Layer.setGraph(Graph) calls basicAddLayer(Layer) and Layer#basicSetGraph(Graph).

Parameters:

node - node to be inserted

removeLayer

public void removeLayer(L layer)

Removes the passed layer from this graph and cleans all indexes. It also ensures, that the graph is removed from the layer, thus invoking Layer.getGraph() will return null. The double chaining between this graph and the passed layer will be cut off. If the passed layer is null nothing happens.

Specified by:

removeLayer in interface Graph<N extends Node,R extends Relation<N,N>,L extends Layer<N,R>>

Parameters:

layer - the layer to be removed

basicRemoveLayer

protected void basicRemoveLayer(L layer)

This is an internally used method. To realize the cut of the double chaining, the removal is split in two methods removeLayer(Layer) and basicRemoveLayer(Layer). which are connected as follows:

 #removeLayer(layer)                      Layer#setGraph(null)
         ||             \ /                   ||
         ||              X                    ||
         \/             / \                   \/
 basicRemoveLayer(Layer)            Layer#basicSetGraph(null)
 

Parameters:

node - the node to be removed