Graph (salt-api 3.0.1 API)

Type Parameters:
N - type of contained Nodes
E - type of contained Relations

All Superinterfaces:

IdentifiableElement, LabelableElement

All Known Subinterfaces:

SCorpusGraph, SDocumentGraph, SGraph

All Known Implementing Classes:

GraphImpl, SCorpusGraphImpl, SDocumentGraphImpl, SGraphImpl
```
public interface Graph<N extends Node,R extends Relation<N,N>,L extends Layer<N,R>>
extends IdentifiableElement
```
The here defined graph is given by G=(V, E, L, {label a , ...label b }) with:
- V being a set of Nodes with v= ({label c , ... label d }) ∊ V
- E being a set of directed Relations with e= (v 1 ∊ V, v 2 ∊ V, {label e , ... label f }) ∊ E
- L being a set of Layers with l= (V 1 ⊆ V, E 1 ⊆ E, L 1 ⊆ L, {label g ,.. label h }) ∊ L
- and a set of Labels {label a , ... label b } the graph is labeled with.
Author:

florian

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 Node,? extends Node> relation)` Adds the passed relation to this graph and updates indexes.
`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 sourceNodeId, String targetNodeId)` Returns all relations,which connects the two passed nodes.
`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(R relation)` Removes the passed relation from this graph.
`void`	`removeRelations()` Removes all relations from this graph and cleans all indexes.

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

- Method Detail
  - getIndexMgr
```
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:
    Even further indexes can be added to the index manager.
    Returns:
    the index manager
  - getRelations
```
List<R> getRelations()
```
    Returns a list of all relations contained in this graph.
    
    Returns:
    a list of all contained relations.
  - getRelation
```
R getRelation(String relationId)
```
    Returns an relation corresponding to the passed id, if such an relation is contained in the graph.
    
    Parameters:
    relationId - id of the relation to be searched for
  - getRelations
```
List<R> getRelations(String sourceNodeId,
                   String targetNodeId)
```
    Returns all relations,which connects the two passed nodes.
    
    Parameters:
    sourceNodeId - the id of the source node
    targetNodeId - the id of the target node
    
    Returns:
    returns all nodes between source node and target node
  - getInRelations
```
List<R> getInRelations(String nodeId)
```
    Returns all relations, which have the node corresponding to the passed id as their target node.
    
    Parameters:
    nodeId - id corresponding to the node, for which all incoming relations should be searched
    
    Returns:
    a list of all incoming relations
  - getOutRelations
```
List<R> getOutRelations(String nodeId)
```
    Returns all relations, which have the node corresponding to the passed id as their source node.
    
    Parameters:
    nodeId - id corresponding to the node, for which all outgoing relations should be searched
    
    Returns:
    a list of all outgoing relations
  - addRelation
```
void addRelation(Relation<? extends Node,? extends Node> 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.
    
    Parameters:
    relation - relation to be inserted
  - removeRelation
```
void removeRelation(R relation)
```
    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.
    
    Parameters:
    relation - relation to be removed
  - removeRelations
```
void removeRelations()
```
    Removes all relations from this graph and cleans all indexes.
  - containsRelation
```
boolean containsRelation(String relationId)
```
    Returns whether this graph contains an Relation corresponding to the passed id.
    
    Parameters:
    relationId - id of the node to be checked
    
    Returns:
    true if the relation is contained, false otherwise
  - getNodes
```
List<N> getNodes()
```
    Returns a list of all relations contained in this graph.
    
    Returns:
    a list of all contained relations.
  - getNode
```
N getNode(String nodeId)
```
    Returns a node corresponding to the passed id, if such a node is contained in the graph.
    
    Parameters:
    nodeId - id of the node to be searched for
  - addNode
```
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.
    
    Parameters:
    node - node to be inserted
  - removeNode
```
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.
    
    Parameters:
    node - the node to be removed
  - containsNode
```
boolean containsNode(String nodeId)
```
    Returns whether this graph contains a Node corresponding to the passed id.
    
    Parameters:
    nodeId - id of the node to be checked
    
    Returns:
    true if the node is contained, false otherwise
  - getLayer
```
L getLayer(String layerId)
```
    Returns a layer corresponding to the passed id, if such a layer is contained in the graph.
    
    Parameters:
    layerId - id of the layer to be searched for
  - getLayers
```
Set<L> getLayers()
```
    Returns a set of layers contained by this graph.
    
    Returns:
    all contained layers
  - addLayer
```
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.
    
    Parameters:
    layer - layer to be inserted
  - containsLayer
```
boolean containsLayer(String layerId)
```
    Returns whether this graph contains a Layer corresponding to the passed id.
    
    Parameters:
    layerId - id of the node to be checked
    
    Returns:
    true if the node is contained, false otherwise
  - removeLayer
```
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.
    
    Parameters:
    layer - the layer to be removed

Interface Graph<N extends Node,R extends Relation<N,N>,L extends Layer<N,R>>

Method Summary

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

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

Method Detail

getIndexMgr

getRelations

getRelation

getRelations

getInRelations

getOutRelations

addRelation

removeRelation

removeRelations

containsRelation

getNodes

getNode

addNode

removeNode

containsNode

getLayer

getLayers

addLayer

containsLayer

removeLayer