Creates a family object

Family

Family(source)

Creates a family object

Returns: Family - returns new instance of family structure

add(parents, nodeid, node)

Adds new family member

adopt(parents, nodeid)

Makes node to be a child of every parent in the collection of parents

bundleChildren(parent, children, bundleItemId, bundleItem)

Adds extra bundle item in between parent and its children. The parent node becomes parent of the bundle node, and bundle becomes parent of the children. Existing parent child relations are removed.

Returns: boolean - returns true if nodes bundle is valid

bundleParents(child, parents, bundleItemId, bundleItem)

Adds extra bundle item in between child node and its parents. The child node becomes child of the bundle node, and bundle becomes child of the parents. Existing parent child relations are removed.

Returns: boolean - returns true if the bundle is valid

clone()

Clones family structure.

Returns: family - returns copy of the family structure.

countChildren(parent)

Returns number of children

Returns: number - number of children

countParents(child)

Returns number of parents

Returns: number - number of parents

eliminateManyToMany(onNewBundleItem)

Eliminates many to many relations in family structure It is needed to simplify layout process of the diagram

onNewFamilyNodeCallback()

Callback function for creation of new family nodes

Returns: object - returns new family node.

findLargestRoot()

Finds root node having largest number of nodes in its hierarchy

Returns: string - returns largest sub-hierarchy root node id.

firstChild(parent)

First available child

Returns: string - returns first available child id or null.

firstParent(child)

First available parent

Returns: string - returns first available parent id or null.

getFamilyWithoutGrandParentsRelations()

Eliminates direct relations between grand parent nodes.

Returns: family - returns family structure without direct grand parent relations.

getGraph(thisArg, onEdge)

Creates graph structure out of the family structure.

Returns: graph - returns graph structure of the family.

onFamilyEdgeCallback(from, to)

Callback for getting default edge value

Returns: object - returns new edge object.

getPlanarFamily(treeLevels)

Eliminates crossing parent child relations between nodes based of nodes order in treeLevels structure.

Returns: family - returns planar family structure.

groupBy(thisArg, size, onGroup, onGroupId)

Creates graph structure out of the family structure.

onFamilyGroupCallback(parent, child, nodes)

Callback for grouping nodes having common single parent and child

onFamilyGroupIdCallback(nodes)

Callback for getting group id for group of nodes

Returns: string - returns group id or null. null adds node to default group. return -1 to disable grouping.

hasCommonChild(parents)

Checks whether parents share a child node. Common child should belong only to the given collection of parents, if child's parents don't match given collection of parents, it is not considered as common child.

Returns: boolean - returns true if common child exist.

hasLoops()

Checks if family structure has loops in references.

Returns: boolean - returns true if family structure contains loops in references.

hasNodes()

Returns true if structure has nodes.

Returns: boolean - returns true if family structure has nodes

loop(thisArg, onItem)

Loops through nodes of family structure

onFamilyItemCallback(itemid, item)

Callback for iterating family nodes

Returns: boolean - returns true to break the loop

loopChildren(thisArg, nodeid, onItem)

Loops through child nodes of family structure level by level

onFamilyItemWithLevelCallback(itemid, item, levelIndex)

Callback for iterating family nodes level by level

Returns: number - returns break to break the loop and exit. returns skip to skip node's branch traversing.

loopLevels(thisArg, parentAligned, onItem)

Loops through nodes of family structure level by level. This function aligns nodes top or bottom.

onFamilyItemWithLevelCallback(itemid, item, levelIndex)

Callback for iterating family nodes level by level

Returns: number - returns break to break the loop and exit. returns skip to skip node's branch traversing.

loopNeighbours(thisArg, itemid, onItem)

Loops through the node neighbours of the family structure level by level

onFamilyItemNeighbourCallback(itemid, item, levelIndex)

Callback for iterating family node neighbours level by level

Returns: number - returns true to skip further neighbous traversing.

loopParents(thisArg, nodeid, onItem)

Loops through parent nodes of family structure level by level

onFamilyItemWithLevelCallback(itemid, item, levelIndex)

Callback for iterating family nodes level by level

Returns: number - returns break to break the loop and exit. returns skip to skip node's branch traversing.

loopRoots(thisArg, onItem)

Loops root nodes of family structure.

onFamilyItemCallback(itemid, item)

Callback for iterating family nodes

Returns: boolean - returns true to break the loop

loopTopo(thisArg, onItem)

Loops through topologically sorted nodes of family structure

onFamilyTopoCallback(itemid, item, position)

Callback for iterating family nodes in topological sort order

Returns: boolean - returns true to break the loop and exit.

loopTopoReversed(thisArg, onItem)

Loops through reversed order topologically sorted nodes of family structure

onFamilyTopoCallback(itemid, item, position)

Callback for iterating family nodes in topological sort order

Returns: boolean - returns true to break the loop and exit.

node(nodeid)

Returns family node by id

Returns: object|undefined - a reference to the node or undefined if id does not exists

optimizeReferences(onNewBundleItem)

Optimizes references between family members. It creates bundles eliminating excessive intersections between nodes relations.

onNewFamilyNodeCallback()

Callback function for creation of new family nodes

Returns: object - returns new family node.

removeChildRelation(parentid, childid)

Removes child relation

Returns: true - if relation was broken

removeNode(nodeid)

Removes node

removeRelation(fromid, toid)

Removes first available parent child or child parent relation

Returns: true - if relation was broken

validate(info)

Validates internal data structure consistency of the family.

Creates family alignment data structure. This structure aligns horizontally planar family of nodes.

FamilyAlignment

FamilyAlignment(thisArg, family, treeLevels, onItemSize)

Creates family alignment data structure. This structure aligns horizontally planar family of nodes.

Returns: FamilyAlignment - returns family alignment structure

getOffset(nodeid)

Returns horizontal node offset from left margin of the family diagram

Returns: number - node offset

Creates Fibonacci Heap structure

FibonacciHeap

FibonacciHeap(isMaximum)

Creates Fibonacci Heap structure

Returns: FibonacciHeap - returns new fibonacciheap object

add(key, priority, item)

Adds a new item into the heap

deleteKey(key)

Deletes heap element by key

extractRoot()

Returns heap root element with removal

Returns: HeapResult - returns root element of the heap

getPriority(key)

Gets priority of element by key

Returns: number - returns priority of the element

heapRoot()

Returns heap root element

Returns: HeapResult - returns root element of the heap

setPriority(key, priority)

Sets priority of an element by key

validate()

Validates internal structure consistency.

Returns: boolean - returns true if structure pass data consistency check.

Creates an undirected graph structure backed by adjacency lists. Each edge stores a context object provided by the caller.

Graph

Graph()

Creates an undirected graph structure backed by adjacency lists. Each edge stores a context object provided by the caller.

Returns: Graph - a new graph instance

addEdge(from, to, edge)

Adds an undirected edge between two nodes. If the edge already exists, it will not be replaced.

dfsLoop(thisArg, startNode, onEdge, onNode)

Performs a depth-first traversal starting at a node. Edge usability is determined by the onEdge callback.

onPathEdgeCallback(from, to, edge)

Callback used for filtering usable edges during DFS path search.

Returns: boolean - true if the edge may be used in traversal

onNodeCallback(to)

Callback for node iteration functions.

Returns: boolean - return true to stop traversal early

dfsPath(thisArg, startNode, endNode, onEdge)

Finds any path between two nodes using depth-first search.

Returns: string[] - array of node ids forming the found path

onPathEdgeCallback(from, to, edge)

Callback used for filtering usable edges during DFS path search.

Returns: boolean - true if the edge may be used in traversal

edge(from, to)

Retrieves the stored edge context object for a given pair of nodes.

Returns: object|null - the edge's context object, or null if none exists

getLevelGraph(thisArg, startNode, onEdge)

Computes a level graph starting from a given node. Levels are assigned via BFS using only edges allowed by the callback.

Returns: Graph - a new graph representing the level structure

onPathEdgeCallback(from, to, edge)

Callback used for filtering usable edges during DFS path search.

Returns: boolean - true if the edge may be used in traversal

getMinimumWeightGrowthSequence(thisArg, startNode, onEdgeWeight, onItem)

Get minimum weight graph growth sequence. The sequence of the traversing order of the graph nodes.

getGraphEdgeWeightCallback(edge, fromItem, toItem)

Returns edge weight used in certain algorithms.

Returns: number - the weight of the edge

onNodeCallback(to)

Callback for node iteration functions.

Returns: boolean - return true to stop traversal early

getShortestPath(thisArg, startNode, endNodes, getWeightFunc, onPathFound)

Computes the shortest paths from a start node to one or more target nodes.

getGraphEdgeWeightCallback(edge, fromItem, toItem)

Returns edge weight used in certain algorithms.

Returns: number - the weight of the edge

onPathFoundCallback(path, to)

Callback invoked when a full path has been reconstructed.

getSpanningTree(startNode, getWeightFunc)

Computes a maximum spanning tree using a priority queue. The graph may be disconnected; a start node is required.

Returns: tree - a tree structure containing the maximum spanning tree

getGraphEdgeWeightCallback(edge, fromItem, toItem)

Returns edge weight used in certain algorithms.

Returns: number - the weight of the edge

getTotalWeightGrowthSequence(thisArg, onEdgeWeight, onItem)

Get graph growth sequence. The sequence of graph traversing order.

getGraphEdgeWeightCallback(edge, fromItem, toItem)

Returns edge weight used in certain algorithms.

Returns: number - the weight of the edge

onNodeCallback(to)

Callback for node iteration functions.

Returns: boolean - return true to stop traversal early

hasNode(from)

Checks whether a node exists in the graph.

Returns: boolean - true if the node is present in the graph

loopEdges(thisArg, onEdge)

Iterates over all edges in the graph.

onEdgeCallback(from, to, edge)

Callback invoked for each edge during iteration.

loopNodeEdges(thisArg, itemid, onEdge)

Iterates over all edges connected to a specific node.

onEdgeCallback(from, to, edge)

Callback invoked for each edge during iteration.

loopNodes(thisArg, startNode, onItem)

Traverses all connected nodes starting from the given node. If no start node is provided, traversal begins with the first available node.

onNodeCallback(to)

Callback for node iteration functions.

Returns: boolean - return true to stop traversal early

Creates Lowest Common Ancestor Structure for the given tree

LCA

LCA(tree)

Creates Lowest Common Ancestor Structure for the given tree

Returns: LCA - returns lowest common ancestor structure

getLowestCommonAncestor(from, to)

Returns lowest common ancestor for the given pair of tree nodes

Returns: string - returns the lowest common ancestor tree node id

Creates linked hash list collection.

LinkedHashItems

LinkedHashItems()

Creates linked hash list collection.

Returns: LinkedHashItems - returns linked hash list structure

add(key, item)

Adds new item to collection

attach(list)

Appends one list to another

empty()

Empties collection

endKey()

Last collection item key

Returns: string - returns key of the last item in the collection

insertAfter(afterKey, key, item)

Inserts new item into the list after the given key

insertBefore(beforeKey, key, item)

Inserts new item into the list before the given key

isEmpty()

Checks if collection is empty

Returns: boolean - returns true if collection is empty

item(key)

Item context object

Returns: object - returns context object

iterate(onItem, startKey, endKey)

Loops items of the collection

onLinkedHashItemsCallback(item, key)

Callback function for iterating list items

Returns: boolean - returns true to break the iteration process

iterateBack(onItem, startKey, endKey)

Loops items of the collection backward

onLinkedHashItemsCallback(item, key)

Callback function for iterating list items

Returns: boolean - returns true to break the iteration process

nextKey(key)

Gets next key

Returns: string - returns key of the next collection item

prevKey(key)

Gets previous key

Returns: string - returns key of the previous collection item

remove(key)

Removes item

startKey()

First collection item key

Returns: string - returns the key of the first item in the collection

toArray()

Returns a regular javascript array of collection items

Returns: object[] - returns array containing items of the collection

unshift(key, item)

Adds new item to the head of the list

Returns: string - returns key of the last item in the collection

validate(info)

Validates internal data consistency of the structure

Returns: boolean - returns true if it pass validation

Creates pile structure used to sort and stack segments on top of each other so they occupy minimum number of rows.

Pile

Pile()

Creates pile structure used to sort and stack segments on top of each other so they occupy minimum number of rows.

Returns: Pile - returns pile structure

add(from, to, context)

Adds new segment to pile object.

resolve(thisArg, onItem)

Sorts and stack segments on top of each other so they occupy minimum number of rows.

Returns: number - number of stacked rows in pile.

onPileItemCallback(from, to, context, offset)

Callback function or iterating result offsets of the pile items in the stack.

Creates Quad Tree data structure. It distributes points into equal quadrants. So it is equivalent to 2 dimensional binary search tree.

QuadTree

QuadTree(minimalSize)

Creates Quad Tree data structure. It distributes points into equal quadrants. So it is equivalent to 2 dimensional binary search tree.

Returns: QuadTree - returns quad tree data structure.

addPoint(point)

Adds point

getPositions(selection)

Returns collection of quadrants created in the data structure Quadrants exists only when elements exists in them. This method is used for visual debugging of the structure.

Returns: Rect[] - returns collection of available quadrants. quadrants containing points within selection area have context.highlight property set to true.

loopArea(thisArg, rect, onItem)

Loops rectangular area of quad tree structure

onQuadTreePointCallback(point)

Callback function for iteration of points

Returns: boolean - returns true to break iteration process.

validate()

Validates internal data consistency of quad tree data structure

Returns: boolean - returns true if structure pass validation

Creates range minimum query structure

RMQ

RMQ(items)

Creates range minimum query structure

Returns: RMQ - returns range minimum query structure

getRangeMinimum(from, to)

Return minimum value for the given range

Returns: number - returns minimum value in the range

getRangeMinimumIndex(from, to)

Returns index of minimum item for the given range of items

Returns: number - returns index of the minimum item

Creates self-balancing binary search tree structure.

SortedList

SortedList()

Creates self-balancing binary search tree structure.

Returns: SortedList - returns sorted list collection.

add(value, context, thisArg, onDuplicate)

Adds value to sorted list collection

onSortedListDuplicateCallback(context)

Callback function to notify about duplicate values

loopBackward(thisArg, fromValue, onItem)

Loops sorted list values backward

onSortedListItemCallback(value, context)

Callback function for iterating values of the sorted list

Returns: boolean - returns true to break loop operation

loopForward(thisArg, fromValue, onItem)

Loops sorted list values

onSortedListItemCallback(value, context)

Callback function for iterating values of the sorted list

Returns: boolean - returns true to break loop operation

nextContext(fromValue)

Returns context object of the next value following the given one

Returns: object - returns context object of the first value in sorted list greater than the start value.

previousContext(fromValue)

Returns context object of the previous value preceding the given one

Returns: object - returns context object of the first value in sorted list less than the start value.

remove(value)

Removes value from the sorted list

validate()

Validate internal data consistency of the self-balancing binary search tree structure

Returns: boolean - returns true if structure pass validation

Create spatial index structure. It uses collection of sizes to distribute rectangles into buckets of similar size elements. Elements of the same bucket are approximated to points. The search of rectangles is transformed to search of points within given range plus offset for maximum linear rectangle size.

SpatialIndex

SpatialIndex(sizes)

Create spatial index structure. It uses collection of sizes to distribute rectangles into buckets of similar size elements. Elements of the same bucket are approximated to points. The search of rectangles is transformed to search of points within given range plus offset for maximum linear rectangle size.

Returns: SpatialIndex - returns spacial index data structure.

addRect(rect)

Adds rectangle to spacial index

loopArea(thisArg, rect, onItem)

Loops rectangular area of spacial index

onSpatialIndexItemCallback(rect)

Callback function for iteration of spacial index rectangles

Returns: boolean - returns true to break iteration process.

Creates tree structure

Tree

Tree(source)

Creates tree structure

Returns: Tree - returns new tree structure

add(parentid, nodeid, node, position)

Adds new tree item

adopt(parentid, nodeid)

Adds existing node to the children of the parent node

arrangeChildren(nodeid, children)

Orders children of the given node

clone()

Clones tree structure

Returns: tree - returns clone of the tree

countChildren(nodeid)

Returns number of children

Returns: number - returns number of child nodes

countSiblings(nodeid)

Returns number of siblings

Returns: number - returns number of siblings

getChild(parentid, index)

Returns child node by index in the children's collection

Returns: object - returns child node

hasChildren(nodeid)

Returns true if node has children

Returns: boolean - returns true if node has children

hasNodes()

Return true if structure has nodes

Returns: boolean - returns true if structure has nodes

indexOf(nodeid)

Returns index of the node in the children's collection

Returns: number - returns node index

insert(nodeid, bundleid, bundle)

Inserts bundle node into the tree structure. The new bundle node becomes only child node of the parent node. All immediate children of the parent node become children of the inserted bundle node.

loop(thisArg, onItem)

Loops through nodes of tree structure

onTreeItemCallback(itemid, item)

Callback for iterating tree nodes

Returns: boolean - returns true to break the loop

loopChildren(thisArg, nodeid, onItem)

Loops immediate children of the given node. Breaks iteration if callback function returns true.

onTreeChildItemCallback(nodeid, node, index, lastIndex)

Callback function to loop through children of the given node

Returns: boolean - returns true to break the iteration of nodes and exit.

loopChildrenRange(thisArg, nodeid, fromIndex, toIndex, onItem)

Loops range of immediate children of the given node. Breaks iteration if callback function returns true.

onTreeNodeWithIndexItemCallback(nodeid, node, index)

Callback function to loop through range of children for the given node

Returns: boolean - returns true to break the iteration of nodes and exit.

loopChildrenReversed(thisArg, nodeid, onItem)

Loops immediate children of the given node in reversed order. Breaks iteration if callback function returns true.

onTreeChildItemCallback(nodeid, node, index, lastIndex)

Callback function to loop through children of the given node

Returns: boolean - returns true to break the iteration of nodes and exit.

loopEulerWalk(thisArg, onItem)

Loops tree nodes in "Euler Walk" order

onItemEulerWalkCallback(nodeid, node, level)

Callback for iterating nodes in euler walk order

Returns: boolean - returns true to break the iteration of nodes and exit.

loopLevels(thisArg, arg0, arg1)

Loops through child nodes of the tree structure level by level

onTreeItemWithLevelCallback(nodeid, node, levelIndex)

Callback for iterating the tree nodes level by level

Returns: number - returns break to break the loop and exit. returns skip to skip node's branch traversing.

loopNeighbours(thisArg, itemid, distance, onItem)

Loops through the node neighbours of the tree structure level by level

onTreeItemNeighbourCallback(itemid, item, distance)

Callback for iterating tree node neighbours level by level

Returns: number - returns true to skip further neighbous traversing.

loopParents(thisArg, nodeid, onItem, includingStartItem)

Loops parents up to the root of the hierarchy starting with the given node. Breaks iteration if callback function returns true.

onTreeItemCallback(itemid, item)

Callback for iterating tree nodes

Returns: boolean - returns true to break the loop

loopPostOrder(thisArg, onItem)

Traverse tree structure in post order. Children first - parent last

onTreeItemWithParentCallback(nodeid, node, parentid, parent)

Callback for iterating nodes and providing parent in parameters

Returns: number - returns break to break the loop and exit. returns skip to skip node's branch traversing.

loopPreOrder(thisArg, arg0, arg1)

Traverse tree structure in pre order. Parent first - children next

onTreeItemWithParentCallback(nodeid, node, parentid, parent)

Callback for iterating nodes and providing parent in parameters

Returns: number - returns break to break the loop and exit. returns skip to skip node's branch traversing.

moveChildren(fromNodeid, toNodeId)

Moves children form one node to another.

node(nodeid)

Returns context object

Returns: object - context object of the node

parent(nodeid)

Returns context object of the parent node

Returns: object - returns context object of the parent node

parentid(nodeid)

Returns parent node id

Returns: string - returns parent node id

validate()

Validates internal data integrity of the structure

Returns: boolean - returns true if structure pass validation

zipUp(thisArg, firstNodeId, secondNodeid, onZip)

Iterates hierarchy nodes by pairs starting with given pair of start and second nodes and up to the root of the hierarchy. Breaks iteration when callback function returns true.

onZipUpPairCallback(firstNodeId, firstParentId, secondNodeid, secondParentId)

Callback function to return pairs of nodes

Returns: boolean - returns true to break the iteration of nodes and exit.

Creates Tree Levels structure. It is diagraming specific auxiliary structure that keeps tree nodes order level by level.

TreeLevels

TreeLevels(source)

Creates Tree Levels structure. It is diagraming specific auxiliary structure that keeps tree nodes order level by level.

Returns: TreeLevels - returns tree levels structure.

addItem(levelIndex, itemid, context)

Adds element

addLevel(level, context)

Adds new level. Structure keeps levels sorted by their indexes. The level index can be positive and negative as well. Structure auto expands collection of levels in both directions and keeps them ordered.

binarySearch(thisArg, levelIndex, onGetDistance)

Searches element at level using binary search

onTreeLevelDistanceCallback(itemid, item)

Callback for finding distance for element

Returns: number - returns distance for the element

clone()

Clones tree levels structure.

Returns: TreeLevels - returns cloned copy of the structure

createLevel(index)

Creates new level

Returns: object - returns new level empty context object

getEndLevelIndex(itemid)

Returns element's end level index in the structure. Element may occupy multiple levels of the tree levels structure.

Returns: number - returns end level index

getItemAtPosition(levelIndex, position)

Gets element at position

Returns: number - returns element id

getItemContext(itemid)

Gets element context object

Returns: object - returns context object of the element

getItemPosition(itemid, level)

Gets element position at level

Returns: number - returns position of the element

getLevelLength(levelIndex)

Gets number of elements at level

Returns: number - returns number of elements at the level

getNextItem(itemid, itemLevel)

Gets next element

Returns: number - returns next element id

getPrevItem(itemid, itemLevel)

Gets previous element

Returns: number - returns previous element id

getStartLevelIndex(itemid)

Returns element's start level index in the structure. Element may occupy multiple levels of the tree levels structure.

Returns: number - returns start level index

hasItem(itemid)

Checks if structure contains element

Returns: boolean - returns true if structure contains given element id

hasLevel(levelIndex)

Checks if structure contains level

Returns: boolean - returns true if structure contains given level index

isEmpty()

Checks if structure has elements.

Returns: boolean - returns true if structure has elements.

length()

Number of levels

Returns: number - returns number of levels in structure.

loopFromItem(thisArg, itemid, isLeft, onItem, level)

Loops level elements starting with the given item

onTreeLevelMergedItemCallback(itemid, item)

Callback for iterating items

Returns: number - returns true to break iteration process.

loopItems(thisArg, onItem)

Loops elements level by level

onTreeLevelsItemCallback(itemid, item, position, levelIndex, level)

Callback function for iteration of elements level by level

Returns: boolean - returns true to break iteration process.

loopLevelItems(thisArg, levelIndex, onItem)

Loops level elements

onTreeLevelItemCallback(itemid, item, position)

Callback function for iteration of level elements

Returns: boolean - returns true to break iteration process.

loopLevels(thisArg, onItem)

Loops levels

onTreeLevelCallback(levelIndex, level)

Callback function for iteration of levels

Returns: boolean - returns true to break iteration process.

loopLevelsFromItem(thisArg, itemid, isBelow, onItem)

Loops levels starting with the given element end level. Element may occupy multiple levels, so this method starts level iteration from next level after or before item levels.

onTreeLevelCallback(levelIndex, level)

Callback function for iteration of levels

Returns: boolean - returns true to break iteration process.

loopLevelsReversed(thisArg, onItem)

Loops levels in reversed order

onTreeLevelCallback(levelIndex, level)

Callback function for iteration of levels

Returns: boolean - returns true to break iteration process.

loopMerged(thisArg, getItemWeight, onItem)

Loops merged elements of tree level structure by weight

onTreeLevelItemWeightCallback(itemid, item)

Callback for finding weight of element

Returns: number - returns distance for the element

onTreeLevelMergedItemCallback(itemid, item)

Callback for iterating items

Returns: number - returns true to break iteration process.