InternalHeapConfiguration (Attestor 0.4.1 API)

java.lang.Object
- de.rwth.i2.attestor.graph.heap.internal.InternalHeapConfiguration

All Implemented Interfaces:

HeapConfiguration, Graph
```
public class InternalHeapConfiguration
extends Object
implements HeapConfiguration, Graph
```
An implementation of HeapConfiguration based on bipartite graphs, which are implemented in LabeledDigraph. In addition to HeapConfiguration, this class also implements Graph, such that graph morphisms between InternalHeapConfigurations can be computed. See also de.rwth.i2.attestor.graph.morphism.

In an InternalHeapConfiguration, nodes, nonterminal edges and variable edges are represented by nodes in a LabeledDigraph that are distinguished by their node label. Furthermore, selector edges and tentacles between (nonterminal or variable) hyperedges are represented by edges in a LabeledDigraph. Consequently, each selector edge is labeled with a SelectorLabel and each tentacle is labeled with an int value that represents the tentacles position in the sequence of nodes attached to a hyperedge. To be more precise:
- Nodes are labeled with Type. All incoming and outgoing edges in the underlying LabeledDigraph correspond to selector edges. For each SelectorLabel there is at most one outgoing selector edge for each node. In contrast, a node may have an arbitrary number of incoming selector edges.
- Nonterminal edges are labeled with Nonterminal. In the underlying LabeledDigraph a nonterminal edge containsSubsumingState no incoming edges. Moreover, a nonterminal edge with Nonterminal.getRank() equals to k containsSubsumingState exactly k outgoing edges in the underlying LabeledDigraph that correspond to its tentacles. Thus, these outgoing edges are labeled with integers 0,1,...,k-1, respectively. The target of an outgoing edge labeled with i then corresponds to the i-th node attached to the nonterminal edge. that are labeled with integer values 0,1,...,k-1, respectively. In this setting an edge labeled with i denotes the i-th tentacle of a nonterminal edge.
- Variable edges are labeled with Variable. In the underlying LabeledDigraph a variable edge containsSubsumingState no incoming edges. Moreover, each variable edge has exactly one outgoing edge in the underlying LabeledDigraph whose target is the unique node corresponding to the value of the variable. This unique outgoing edge is always labeled with the integer value 0.
The LabeledDigraph underlying an immutable InternalHeapConfiguration is kept compact. This means that LabeledDigraph.size() equals the number of nodes, nonterminal edges and variable edges. To this end any call to InternalHeapConfigurationBuilder.build() may swap around elements to remove gaps caused by deleting elements of a HeapConfiguration. Since swapping elements changes their identifiers, InternalHeapConfiguration distinguishes between public and private identifiers:
- Private identifiers correspond to the actual identifiers used within the underlying LabeledDigraph. The private identifier of a node in a LabeledDigraph may change, for example after another element has been deleted. Private identifiers are not accessible through the methodExecution provided by HeapConfiguration. In contrast, all methodExecution provided by Graph directly use private identifiers to avoid translating between public and private identifiers when computing graph morphisms.
- Public identifiers provide an additional indirection that remains unaffected by changes to the underlying LabeledDigraph. All methodExecution provided by HeapConfiguration always take public identifiers as parameters and return public identifiers.
Hence, as long as a client uses only methodExecution provided by HeapConfiguration, all identifiers are public.

InternalHeapConfiguration provides the methodExecution getPrivateId(int) and getPublicId(int) to translate a public identifier into a private identifier and a private identifier into a public identifier, respectively.
Author:

Christoph

Field Summary
- Fields inherited from interface de.rwth.i2.attestor.graph.heap.HeapConfiguration
  INVALID_ELEMENT

Constructor Summary

Constructors
Constructor and Description

InternalHeapConfiguration()
Sets up an empty InternalHeapConfiguration.

Constructors
Constructor and Description
`InternalHeapConfiguration()` Sets up an empty InternalHeapConfiguration.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`gnu.trove.list.array.TIntArrayList`	`attachedNodesOf(int ntEdge)`
`gnu.trove.list.array.TIntArrayList`	`attachedNonterminalEdgesOf(int node)`
`gnu.trove.map.TIntIntMap`	`attachedNonterminalEdgesWithNonReductionTentacle(int node)`
`gnu.trove.list.array.TIntArrayList`	`attachedVariablesOf(int node)`
`HeapConfigurationBuilder`	`builder()` Mark a HeapConfiguration as temporarily mutable by a `HeapConfigurationBuilder`.
`HeapConfiguration`	`clone()`
`int`	`countExternalNodes()`
`int`	`countNodes()`
`int`	`countNonterminalEdges()`
`int`	`countVariableEdges()`
`boolean`	`equals(Object otherObject)`
`int`	`externalIndexOf(int node)`
`int`	`externalNodeAt(int pos)`
`gnu.trove.list.array.TIntArrayList`	`externalNodes()`
`List<Object>`	`getEdgeLabel(int privateIdFrom, int privateIdTo)` This method directly access the `LabeledDigraph` underlying an InternalHeapConfiguration through private IDs.
`AbstractMatchingChecker`	`getEmbeddingsOf(HeapConfiguration pattern, MorphismOptions morphismOptions)` Returns an AbstractMatchingChecker to search for all occurrences of the given pattern HeapConfiguration in this HeapConfiguration (the target).
`HeapConfiguration`	`getEmpty()`
`int`	`getExternalIndex(int privateNodeId)` This method directly access the `LabeledDigraph` underlying an InternalHeapConfiguration through private IDs.
`NodeLabel`	`getNodeLabel(int privateNodeId)` This method directly access the `LabeledDigraph` underlying an InternalHeapConfiguration through private IDs.
`gnu.trove.list.array.TIntArrayList`	`getPredecessorsOf(int privateNodeId)` This method directly access the `LabeledDigraph` underlying an InternalHeapConfiguration through private IDs.
`gnu.trove.list.array.TIntArrayList`	`getSuccessorsOf(int privateNodeId)` This method directly access the `LabeledDigraph` underlying an InternalHeapConfiguration through private IDs.
`boolean`	`hasEdge(int privateIdFrom, int privateIdTo)` This method directly access the `LabeledDigraph` underlying an InternalHeapConfiguration through private IDs.
`int`	`hashCode()`
`boolean`	`isEdgeBetweenMarkedNodes(int from, int to)`
`boolean`	`isExternal(int privateNodeId)` This method directly access the `LabeledDigraph` underlying an InternalHeapConfiguration through private IDs.
`boolean`	`isExternalNode(int node)`
`Nonterminal`	`labelOf(int ntEdge)`
`String`	`nameOf(int varEdge)`
`gnu.trove.list.array.TIntArrayList`	`nodes()`
`Type`	`nodeTypeOf(int node)`
`gnu.trove.list.array.TIntArrayList`	`nonterminalEdges()`
`gnu.trove.list.array.TIntArrayList`	`predecessorNodesOf(int node)`
`int`	`rankOf(int ntEdge)`
`List<SelectorLabel>`	`selectorLabelsOf(int node)`
`int`	`selectorTargetOf(int node, SelectorLabel sel)`
`int`	`size()`
`gnu.trove.list.array.TIntArrayList`	`successorNodesOf(int node)`
`int`	`targetOf(int varEdge)`
`String`	`toString()`
`gnu.trove.list.array.TIntArrayList`	`variableEdges()`
`int`	`variableTargetOf(String variableName)`
`int`	`variableWith(String name)`

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - InternalHeapConfiguration
```
public InternalHeapConfiguration()
```
    Sets up an empty InternalHeapConfiguration.
- Method Detail
  - clone
```
public HeapConfiguration clone()
```
    Specified by:
    
    clone in interface HeapConfiguration
    
    Overrides:
    
    clone in class Object
    
    Returns:
    
    A deep copy of this HeapConfiguration.
  - getEmpty
```
public HeapConfiguration getEmpty()
```
    Specified by:
    
    getEmpty in interface HeapConfiguration
    
    Returns:
    
    An empty heap configuration
  - builder
```
public HeapConfigurationBuilder builder()
```
    Description copied from interface: HeapConfiguration
    
    Mark a HeapConfiguration as temporarily mutable by a HeapConfigurationBuilder. The HeapConfiguration stays mutable until HeapConfigurationBuilder.build() is called. For each HeapConfiguration, there is either no builder (immutable) or exactly one builder (mutable).
    
    Specified by:
    
    builder in interface HeapConfiguration
    
    Returns:
    
    The HeapConfigurationBuilder that allows mutation of this HeapConfiguration.
  - countNodes
```
public int countNodes()
```
    Specified by:
    
    countNodes in interface HeapConfiguration
    
    Returns:
    
    The number of nodes contained in the HeapConfiguration.
  - nodes
```
public gnu.trove.list.array.TIntArrayList nodes()
```
    Specified by:
    
    nodes in interface HeapConfiguration
    
    Returns:
    
    A list of all nodes contained in the heap contained in the HeapConfiguration.
  - nodeTypeOf
```
public Type nodeTypeOf(int node)
```
    Specified by:
    
    nodeTypeOf in interface HeapConfiguration
    
    Parameters:
    
    node - A node contained in the HeapConfiguration.
    
    Returns:
    
    The type of the given node.
  - attachedVariablesOf
```
public gnu.trove.list.array.TIntArrayList attachedVariablesOf(int node)
```
    Specified by:
    
    attachedVariablesOf in interface HeapConfiguration
    
    Parameters:
    
    node - A node contained in the HeapConfiguration.
    
    Returns:
    
    A list of all variables attached to the given node.
  - attachedNonterminalEdgesOf
```
public gnu.trove.list.array.TIntArrayList attachedNonterminalEdgesOf(int node)
```
    Specified by:
    
    attachedNonterminalEdgesOf in interface HeapConfiguration
    
    Parameters:
    
    node - A node contained in the HeapConfiguration.
    
    Returns:
    
    A list of all nonterminal edges attached to the given node.
  - successorNodesOf
```
public gnu.trove.list.array.TIntArrayList successorNodesOf(int node)
```
    Specified by:
    
    successorNodesOf in interface HeapConfiguration
    
    Parameters:
    
    node - A node contained in the HeapConfiguration.
    
    Returns:
    
    A list of all nodes reachable by a single selector edge from the given node.
  - predecessorNodesOf
```
public gnu.trove.list.array.TIntArrayList predecessorNodesOf(int node)
```
    Specified by:
    
    predecessorNodesOf in interface HeapConfiguration
    
    Parameters:
    
    node - A node contained in the HeapConfiguration.
    
    Returns:
    
    A list of all nodes that can reach the given node by a single selector.
  - selectorLabelsOf
```
public List<SelectorLabel> selectorLabelsOf(int node)
```
    Specified by:
    
    selectorLabelsOf in interface HeapConfiguration
    
    Parameters:
    
    node - A node contained in the HeapConfiguration.
    
    Returns:
    
    A list of all selectors that occur as edge labels for the given node.
  - selectorTargetOf
```
public int selectorTargetOf(int node,
                            SelectorLabel sel)
```
    Specified by:
    
    selectorTargetOf in interface HeapConfiguration
    
    Parameters:
    
    node - A node contained in the HeapConfiguration.
    
    sel - A SelectorLabel that occurs as an edge label for the given node.
    
    Returns:
    
    The node reached by taken the given selector from the given node.
  - countExternalNodes
```
public int countExternalNodes()
```
    Specified by:
    
    countExternalNodes in interface HeapConfiguration
    
    Returns:
    
    The number of external nodes in this HeapConfiguration.
  - externalNodes
```
public gnu.trove.list.array.TIntArrayList externalNodes()
```
    Specified by:
    
    externalNodes in interface HeapConfiguration
    
    Returns:
    
    A list of all external nodes in this HeapConfiguration.
  - externalNodeAt
```
public int externalNodeAt(int pos)
```
    Specified by:
    
    externalNodeAt in interface HeapConfiguration
    
    Parameters:
    
    pos - An index of an external node satisfying 0 <= pos && pos <= countExternalNodes().
    
    Returns:
    
    The requested external node.
  - isExternalNode
```
public boolean isExternalNode(int node)
```
    Specified by:
    
    isExternalNode in interface HeapConfiguration
    
    Parameters:
    
    node - A node in the HeapConfiguration.
    
    Returns:
    
    true if and only if the given node is external.
  - externalIndexOf
```
public int externalIndexOf(int node)
```
    Specified by:
    
    externalIndexOf in interface HeapConfiguration
    
    Parameters:
    
    node - A node in the HeapConfiguration.
    
    Returns:
    
    The position of the given node in the sequence of external nodes.
  - countNonterminalEdges
```
public int countNonterminalEdges()
```
    Specified by:
    
    countNonterminalEdges in interface HeapConfiguration
    
    Returns:
    
    The number of nonterminal edges in this HeapConfiguration.
  - nonterminalEdges
```
public gnu.trove.list.array.TIntArrayList nonterminalEdges()
```
    Specified by:
    
    nonterminalEdges in interface HeapConfiguration
    
    Returns:
    
    A list of all nonterminal edges in this HeapConfiguration.
  - rankOf
```
public int rankOf(int ntEdge)
```
    Specified by:
    
    rankOf in interface HeapConfiguration
    
    Parameters:
    
    ntEdge - A nonterminal edge in this HeapConfiguration.
    
    Returns:
    
    The number of nodes attached to the given nonterminal edge.
  - labelOf
```
public Nonterminal labelOf(int ntEdge)
```
    Specified by:
    
    labelOf in interface HeapConfiguration
    
    Parameters:
    
    ntEdge - A nonterminal edge in this HeapConfiguration.
    
    Returns:
    
    The label of the given nonterminal edge.
  - attachedNodesOf
```
public gnu.trove.list.array.TIntArrayList attachedNodesOf(int ntEdge)
```
    Specified by:
    
    attachedNodesOf in interface HeapConfiguration
    
    Parameters:
    
    ntEdge - A nonterminal edge in this HeapConfiguration.
    
    Returns:
    
    The list of nodes attached to the given nonterminal edge.
  - countVariableEdges
```
public int countVariableEdges()
```
    Specified by:
    
    countVariableEdges in interface HeapConfiguration
    
    Returns:
    
    The number of variable edges in this HeapConfiguration.
  - variableEdges
```
public gnu.trove.list.array.TIntArrayList variableEdges()
```
    Specified by:
    
    variableEdges in interface HeapConfiguration
    
    Returns:
    
    A list of all variable edges contained in this HeapConfiguration.
  - variableWith
```
public int variableWith(String name)
```
    Specified by:
    
    variableWith in interface HeapConfiguration
    
    Parameters:
    
    name - The name of the requested variable
    
    Returns:
    
    The variable with the requested name or HeapConfiguration.INVALID_ELEMENT.
  - nameOf
```
public String nameOf(int varEdge)
```
    Specified by:
    
    nameOf in interface HeapConfiguration
    
    Parameters:
    
    varEdge - A variable edge in this HeapConfiguration.
    
    Returns:
    
    The name of the given variable edge.
  - targetOf
```
public int targetOf(int varEdge)
```
    Specified by:
    
    targetOf in interface HeapConfiguration
    
    Parameters:
    
    varEdge - A variable edge in this HeapConfiguration.
    
    Returns:
    
    The node attached to the given variable edge.
  - getEmbeddingsOf
```
public AbstractMatchingChecker getEmbeddingsOf(HeapConfiguration pattern,
                                               MorphismOptions morphismOptions)
```
    Description copied from interface: HeapConfiguration
    
    Returns an AbstractMatchingChecker to search for all occurrences of the given pattern HeapConfiguration in this HeapConfiguration (the target).
    
    Specified by:
    
    getEmbeddingsOf in interface HeapConfiguration
    
    Parameters:
    
    pattern - The HeapConfiguration to search for.
    
    morphismOptions - Options guiding how embeddings are computed.
    
    Returns:
    
    An AbstractMatchingChecker to iterate through all found embeddings.
  - variableTargetOf
```
public int variableTargetOf(String variableName)
```
    Specified by:
    
    variableTargetOf in interface HeapConfiguration
    
    Parameters:
    
    variableName - The name of the requested variable.
    
    Returns:
    
    The unique node attached to a variable edge with the given name or INVALID_ELEMENT if no such variable edge exists.
  - attachedNonterminalEdgesWithNonReductionTentacle
```
public gnu.trove.map.TIntIntMap attachedNonterminalEdgesWithNonReductionTentacle(int node)
```
    Specified by:
    
    attachedNonterminalEdgesWithNonReductionTentacle in interface HeapConfiguration
    
    Parameters:
    
    node - A node in the graph.
    
    Returns:
    
    Mapping from attached nonterminal edges to node to the index of the first non reduction tentacle attached to node.
  - equals
```
public boolean equals(Object otherObject)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - size
```
public int size()
```
    Specified by:
    
    size in interface Graph
    
    Returns:
    
    The total number of nodes if this Graph.
  - hasEdge
```
public boolean hasEdge(int privateIdFrom,
                       int privateIdTo)
```
    This method directly access the LabeledDigraph underlying an InternalHeapConfiguration through private IDs. It should thus only be used if it can be guaranteed that a HeapConfiguration is immutable. That is, HeapConfiguration.builder() is null.
    
    Specified by:
    
    hasEdge in interface Graph
    
    Parameters:
    
    privateIdFrom - The source node of the desired edges.
    
    privateIdTo - The target node of the desired edges.
    
    Returns:
    
    True if and only if there exists at least one edge with source from and target to.
  - getSuccessorsOf
```
public gnu.trove.list.array.TIntArrayList getSuccessorsOf(int privateNodeId)
```
    This method directly access the LabeledDigraph underlying an InternalHeapConfiguration through private IDs. It should thus only be used if it can be guaranteed that a HeapConfiguration is immutable. That is, HeapConfiguration.builder() is null.
    
    Specified by:
    
    getSuccessorsOf in interface Graph
    
    Parameters:
    
    privateNodeId - The source node whose successor nodes are requested.
    
    Returns:
    
    A list of all successor nodes of the given source node.
  - getPredecessorsOf
```
public gnu.trove.list.array.TIntArrayList getPredecessorsOf(int privateNodeId)
```
    This method directly access the LabeledDigraph underlying an InternalHeapConfiguration through private IDs. It should thus only be used if it can be guaranteed that a HeapConfiguration is immutable. That is, HeapConfiguration.builder() is null.
    
    Specified by:
    
    getPredecessorsOf in interface Graph
    
    Parameters:
    
    privateNodeId - The target node whose predecessor nodes are requested.
    
    Returns:
    
    A list of all predecessor nodes of the given target node.
  - getNodeLabel
```
public NodeLabel getNodeLabel(int privateNodeId)
```
    This method directly access the LabeledDigraph underlying an InternalHeapConfiguration through private IDs. It should thus only be used if it can be guaranteed that a HeapConfiguration is immutable. That is, HeapConfiguration.builder() is null.
    
    Specified by:
    
    getNodeLabel in interface Graph
    
    Parameters:
    
    privateNodeId - The node whose label is requested.
    
    Returns:
    
    The label of the node or null if the node does not exist.
  - getEdgeLabel
```
public List<Object> getEdgeLabel(int privateIdFrom,
                                 int privateIdTo)
```
    This method directly access the LabeledDigraph underlying an InternalHeapConfiguration through private IDs. It should thus only be used if it can be guaranteed that a HeapConfiguration is immutable. That is, HeapConfiguration.builder() is null.
    
    Specified by:
    
    getEdgeLabel in interface Graph
    
    Parameters:
    
    privateIdFrom - The source node.
    
    privateIdTo - The target node.
    
    Returns:
    
    A repetition-free list of all edge labels of edges whose source node is from and whose target node is to.
  - getExternalIndex
```
public int getExternalIndex(int privateNodeId)
```
    This method directly access the LabeledDigraph underlying an InternalHeapConfiguration through private IDs. It should thus only be used if it can be guaranteed that a HeapConfiguration is immutable. That is, HeapConfiguration.builder() is null.
    
    Specified by:
    
    getExternalIndex in interface Graph
    
    Parameters:
    
    privateNodeId - An external node.
    
    Returns:
    
    The unique position of the node in the sequence of external nodes or -1 if the given node does not exist or is not external.
  - isEdgeBetweenMarkedNodes
```
public boolean isEdgeBetweenMarkedNodes(int from,
                                        int to)
```
    Specified by:
    
    isEdgeBetweenMarkedNodes in interface Graph
  - isExternal
```
public boolean isExternal(int privateNodeId)
```
    This method directly access the LabeledDigraph underlying an InternalHeapConfiguration through private IDs. It should thus only be used if it can be guaranteed that a HeapConfiguration is immutable. That is, HeapConfiguration.builder() is null.
    
    Specified by:
    
    isExternal in interface Graph
    
    Parameters:
    
    privateNodeId - The node that should be checked.
    
    Returns:
    
    True if and only if the given node is external.

Class InternalHeapConfiguration

Field Summary

Fields inherited from interface de.rwth.i2.attestor.graph.heap.HeapConfiguration

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

InternalHeapConfiguration

Method Detail

clone

getEmpty

builder

countNodes

nodes

nodeTypeOf

attachedVariablesOf

attachedNonterminalEdgesOf

successorNodesOf

predecessorNodesOf

selectorLabelsOf

selectorTargetOf

countExternalNodes

externalNodes

externalNodeAt

isExternalNode

externalIndexOf

countNonterminalEdges

nonterminalEdges

rankOf

labelOf

attachedNodesOf

countVariableEdges

variableEdges

variableWith

nameOf

targetOf

getEmbeddingsOf

variableTargetOf

attachedNonterminalEdgesWithNonReductionTentacle

equals

hashCode

toString

size

hasEdge

getSuccessorsOf

getPredecessorsOf

getNodeLabel

getEdgeLabel

getExternalIndex

isEdgeBetweenMarkedNodes

isExternal