Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| JGraph X 1.4.0.9
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.mxgraph.layout.hierarchical.model
Class mxGraphHierarchyModel

    java.lang.Object
      com.mxgraph.layout.hierarchical.model.mxGraphHierarchyModel

    public class mxGraphHierarchyModel

extends Object

Internal model of a hierarchical graph. This model stores nodes and edges equivalent to the real graph nodes and edges, but also stores the rank of the cells, the order within the ranks and the new candidate locations of cells. The internal model also reverses edge direction were appropriate , ignores self-loop and groups parallels together under one edge object.

Nested Class Summary
`static interface` | `mxGraphHierarchyModel.CellVisitor` Defines the interface that visitors use to perform operations upon the graph information during depth first search (dfs) or other tree-traversal strategies implemented by subclassers.

Field Summary
`protected boolean` | `deterministic` Whether or not cells are ordered according to the order in the graph model.
`protected int` | `dfsCount` Count of the number of times the ancestor dfs has been used
`protected Map<Object,mxGraphHierarchyEdge>` | `edgeMapper` Map from graph edges to internal model edges
`int` | `maxRank` Stores the largest rank number allocated
`Object` | `parent` The parent cell whose children are being laid out
`Map<Integer,mxGraphHierarchyRank>` | `ranks` Mapping from rank number to actual rank
`List<Object>` | `roots` Store of roots of this hierarchy model, these are real graph cells, not internal cells
`protected boolean` | `scanRanksFromSinks` Whether the rank assignment is done from the sinks or sources.
`protected Map<Object,mxGraphHierarchyNode>` | `vertexMapper` Map from graph vertices to internal model nodes

Constructor Summary
`mxGraphHierarchyModel(mxHierarchicalLayout layout, Object[] vertices, List<Object> roots, Object parent, boolean ordered, boolean deterministic, boolean scanRanksFromSinks)` Creates an internal ordered graph model using the vertices passed in.

Method Summary
`protected void` | `createInternalCells(mxHierarchicalLayout layout, Object[] vertices, mxGraphHierarchyNode[] internalVertices)` Creates all edges in the internal model
`void` | `dfs(mxGraphHierarchyNode parent, mxGraphHierarchyNode root, mxGraphHierarchyEdge connectingEdge, mxGraphHierarchyModel.CellVisitor visitor, Set<mxGraphHierarchyNode> seen, int layer)` Performs a depth first search on the internal hierarchy model
`void` | `dfs(mxGraphHierarchyNode parent, mxGraphHierarchyNode root, mxGraphHierarchyEdge connectingEdge, mxGraphHierarchyModel.CellVisitor visitor, Set<mxGraphHierarchyNode> seen, int[] ancestors, int childHash, int layer)` Performs a depth first search on the internal hierarchy model.
`void` | `fixRanks()` Fixes the layer assignments to the values stored in the nodes.
`void` | `formOrderedHierarchy(mxHierarchicalLayout layout, Object[] vertices, Object parent)` Creates an internal ordered graph model using the vertices passed in.
`int` | `getDfsCount()`
`Map<Object,mxGraphHierarchyEdge>` | `getEdgeMapper()`
`Map<Object,mxGraphHierarchyNode>` | `getVertexMapping()`
`void` | `initialRank()` Basic determination of minimum layer ranking by working from from sources or sinks and working through each node in the relevant edge direction.
`boolean` | `isDeterministic()`
`void` | `setDeterministic(boolean deterministic)`
`void` | `setDfsCount(int dfsCount)`
`void` | `setEdgeMapper(Map<Object,mxGraphHierarchyEdge> edgeMapper)`
`void` | `setVertexMapping(Map<Object,mxGraphHierarchyNode> vertexMapping)`
`void` | `visit(mxGraphHierarchyModel.CellVisitor visitor, mxGraphHierarchyNode[] dfsRoots, boolean trackAncestors, Set<mxGraphHierarchyNode> seenNodes)` A depth first search through the internal hierarchy model

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### scanRanksFromSinks

    protected boolean scanRanksFromSinks

  Whether the rank assignment is done from the sinks or sources.

### maxRank

    public int maxRank

  Stores the largest rank number allocated

### vertexMapper

    protected Map<Object,mxGraphHierarchyNode> vertexMapper

  Map from graph vertices to internal model nodes

### edgeMapper

    protected Map<Object,mxGraphHierarchyEdge> edgeMapper

  Map from graph edges to internal model edges

### ranks

    public Map<Integer,mxGraphHierarchyRank> ranks

  Mapping from rank number to actual rank

### roots

    public List<Object> roots

  Store of roots of this hierarchy model, these are real graph cells, not internal cells

### parent

    public Object parent

  The parent cell whose children are being laid out

### dfsCount

    protected int dfsCount

  Count of the number of times the ancestor dfs has been used

### deterministic

    protected boolean deterministic

  Whether or not cells are ordered according to the order in the graph model. Defaults to false since sorting usually produces quadratic performance. Note that since JGraph 6 returns edges in a deterministic order, it might be that this layout is always deterministic using that JGraph regardless of this flag setting (i.e. leave it false in that case)

Constructor Detail

### mxGraphHierarchyModel

    public mxGraphHierarchyModel(mxHierarchicalLayout layout,
                                 Object[] vertices,
                                 List<Object> roots,
                                 Object parent,
                                 boolean ordered,
                                 boolean deterministic,
                                 boolean scanRanksFromSinks)

  Creates an internal ordered graph model using the vertices passed in. If there are any, leftward edge need to be inverted in the internal model

  Parameters:
    `layout` - the enclosing layout object
    `vertices` - the vertices for this hierarchy
    `ordered` - whether or not the vertices are already ordered
    `deterministic` - whether or not this layout should be deterministic on each
    `scanRanksFromSinks` - Whether the rank assignment is done from the sinks or sources. usage

Method Detail

### formOrderedHierarchy

    public void formOrderedHierarchy(mxHierarchicalLayout layout,
                                     Object[] vertices,
                                     Object parent)

  Creates an internal ordered graph model using the vertices passed in. If there are any, leftward edge need to be inverted in the internal model

  Parameters:
    `layout` - reference to the layout algorithm
    `vertices` - the vertices to be laid out

### createInternalCells

    protected void createInternalCells(mxHierarchicalLayout layout,
                                       Object[] vertices,
                                       mxGraphHierarchyNode[] internalVertices)

  Creates all edges in the internal model

  Parameters:
    `layout` - reference to the layout algorithm
    `vertices` - the vertices whom are to have an internal representation created
    `internalVertices` - the blank internal vertices to have their information filled in using the real vertices

### initialRank

    public void initialRank()

  Basic determination of minimum layer ranking by working from from sources or sinks and working through each node in the relevant edge direction. Starting at the sinks is basically a longest path layering algorithm.

### fixRanks

    public void fixRanks()

  Fixes the layer assignments to the values stored in the nodes. Also needs to create dummy nodes for edges that cross layers.

### visit

    public void visit(mxGraphHierarchyModel.CellVisitor visitor,
                      mxGraphHierarchyNode[] dfsRoots,
                      boolean trackAncestors,
                      Set<mxGraphHierarchyNode> seenNodes)

  A depth first search through the internal hierarchy model

  Parameters:
    `visitor` - the visitor pattern to be called for each node
    `trackAncestors` - whether or not the search is to keep track all nodes directly above this one in the search path

### dfs

    public void dfs(mxGraphHierarchyNode parent,
                    mxGraphHierarchyNode root,
                    mxGraphHierarchyEdge connectingEdge,
                    mxGraphHierarchyModel.CellVisitor visitor,
                    Set<mxGraphHierarchyNode> seen,
                    int layer)

  Performs a depth first search on the internal hierarchy model

  Parameters:
    `parent` - the parent internal node of the current internal node
    `root` - the current internal node
    `connectingEdge` - the internal edge connecting the internal node and the parent internal node, if any
    `visitor` - the visitor pattern to be called for each node
    `seen` - a set of all nodes seen by this dfs a set of all of the ancestor node of the current node
    `layer` - the layer on the dfs tree ( not the same as the model ranks )

### dfs

    public void dfs(mxGraphHierarchyNode parent,
                    mxGraphHierarchyNode root,
                    mxGraphHierarchyEdge connectingEdge,
                    mxGraphHierarchyModel.CellVisitor visitor,
                    Set<mxGraphHierarchyNode> seen,
                    int[] ancestors,
                    int childHash,
                    int layer)

  Performs a depth first search on the internal hierarchy model. This dfs extends the default version by keeping track of cells ancestors, but it should be only used when necessary because of it can be computationally intensive for deep searches.

  Parameters:
    `parent` - the parent internal node of the current internal node
    `root` - the current internal node
    `connectingEdge` - the internal edge connecting the internal node and the parent internal node, if any
    `visitor` - the visitor pattern to be called for each node
    `seen` - a set of all nodes seen by this dfs
    `ancestors` - the parent hash code
    `childHash` - the new hash code for this node
    `layer` - the layer on the dfs tree ( not the same as the model ranks )

### getVertexMapping

    public Map<Object,mxGraphHierarchyNode> getVertexMapping()

  Returns:
    Returns the vertexMapping.

### setVertexMapping

    public void setVertexMapping(Map<Object,mxGraphHierarchyNode> vertexMapping)

  Parameters:
    `vertexMapping` - The vertexMapping to set.

### getEdgeMapper

    public Map<Object,mxGraphHierarchyEdge> getEdgeMapper()

  Returns:
    Returns the edgeMapper.

### setEdgeMapper

    public void setEdgeMapper(Map<Object,mxGraphHierarchyEdge> edgeMapper)

  Parameters:
    `edgeMapper` - The edgeMapper to set.

### getDfsCount

    public int getDfsCount()

  Returns:
    Returns the dfsCount.

### setDfsCount

    public void setDfsCount(int dfsCount)

  Parameters:
    `dfsCount` - The dfsCount to set.

### isDeterministic

    public boolean isDeterministic()

  Returns:
    Returns the deterministic.

### setDeterministic

    public void setDeterministic(boolean deterministic)

  Parameters:
    `deterministic` - The deterministic to set.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| JGraph X 1.4.0.9
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright (c) 2010 Gaudenz Alder. All rights reserved.