org.aksw.commons.collections.trees

Class TreeUtils

java.lang.Object

org.aksw.commons.collections.trees.TreeUtils

public class TreeUtils
extends Object

Constructor Summary

Constructors

Constructor and Description
TreeUtils()

Method Summary

Modifier and Type	Method and Description
static <T> int	childIndexOf(TreeOps2<T> ops, T node)
static <T> Map<T,com.google.common.collect.Multimap<T,T>>	clusterNodesByFirstMultiaryAncestor(Tree<T> tree, com.google.common.collect.Multimap<T,T> mapping) Input: A mapping from cache nodes to candidate query nodes represented as a Multimap.
static <T> long	depth(Tree<T> tree)
static <T> long	depth(Tree<T> tree, T node)
static <A,B> com.google.common.collect.Multimap<A,B>	deriveParentMapping(Tree<A> aTree, Tree<B> bTree, com.google.common.collect.Multimap<A,B> childMapping) Given a mapping of child nodes, determine which parents may be mapped to each other.
static <T> T	findAncestor(Tree<T> tree, T node, java.util.function.Predicate<T> predicate) Find the first ancestor for which the predicate evaluates to true
static <T> T	firstMultiaryAncestor(Tree<T> tree, T node) Return a node's first ancestor having an arity > 1 null if there is none.
static <T> T	getFirstMultiaryAncestor(Tree<T> tree, T node)
static <T> void	getLeafs(Collection<T> result, Tree<T> tree, T node)
static <T> List<T>	getLeafs(Tree<T> tree)
static <T> Set<T>	getParentsOf(Tree<T> tree, Iterable<T> children) Get the set of immediate parents for a given set of children
static <X> List<X>	getUnaryAncestors(X x, Tree<X> tree, Tree<X> multiaryTree)
static <T> com.google.common.collect.Multimap<T,T>	groupByParent(Tree<T> tree, Collection<T> nodes, com.google.common.collect.Multimap<T,T> result)
static <T> int	indexOf(List<T> list, T find, java.util.function.BiPredicate<? super T,? super T> isEquiv)
static <T> List<List<T>>	innerNodesPerLevel(Tree<T> tree) For each level, yield the inner nodes The root node will always be part of the list, even if it does not have children
static <T> java.util.stream.Stream<T>	inOrderSearch(T node, java.util.function.Function<T,? extends Iterable<T>> parentToChildren)
static <T,V> java.util.stream.Stream<Map.Entry<T,V>>	inOrderSearch(T node, java.util.function.Function<T,? extends Iterable<T>> parentToChildren, java.util.function.Function<? super T,V> nodeToValue, java.util.function.BiPredicate<T,V> doDescend) In-order-search starting from the given node and descending into the tree.
static <T> java.util.stream.Stream<T>	leafStream(Tree<T> tree)
static <T> long	nodeCount(Tree<T> tree)
static <T> List<List<T>>	nodesPerLevel(Tree<T> tree) Returns the set of nodes in each level of the tree The set containing the root will be the first item in the list
static <T> void	parentMap(Map<T,T> result, T parent, java.util.function.Function<T,List<T>> parentToChildren)
static <T> Map<T,T>	parentMap(T root, java.util.function.Function<T,List<T>> parentToChildren) Traverse an op structure and create a map from each subOp to its immediate parent NOTE It must be ensured that common sub expressions are different objects, since we are using an identity hash map for mapping children to parents
static <T> Set<T>	propagateBottomUpLabel(Tree<T> tree, java.util.function.Predicate<T> predicate) Given a predicate, return the minimum set of nodes, for which all nodes in their subtree satisfy the predicate.
static <T> Tree<T>	remapSubTreesToLeafs(Tree<T> tree, java.util.function.Function<? super T,? extends T> remapFn) Create a new tree object which has certain nodes remapped with *leaf* nodes
static <T> Tree<T>	removeUnaryNodes(Tree<T> tree)
static <T> T	removeUnaryNodes(Tree<T> tree, T node, com.google.common.collect.ListMultimap<T,T> parentToChildren)
static <T> Tree<T>	replace(Tree<T> tree, T node, T replacement)
static <T> T	replaceNode(Tree<T> tree, T node, T replacement, java.util.function.BiPredicate<? super T,? super T> isEquiv)
static <T> T	substitute(T node, boolean descendIntoSubst, java.util.function.Function<? super T,? extends Collection<? extends T>> getChildrenFn, java.util.function.Function<? super T,? extends T> transformFn, java.util.function.BiFunction<T,List<T>,T> copyFn)
static <T> T	substitute(T node, boolean descendIntoSubst, TreeOps2<T> ops, java.util.function.Function<? super T,? extends T> transformFn)
static <T> Tree<T>	subTree(Tree<T> tree, T newRoot)

Methods inherited from class java.lang.Object

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

Constructor Detail

TreeUtils

public TreeUtils()

Method Detail

groupByParent

public static <T> com.google.common.collect.Multimap<T,T> groupByParent(Tree<T> tree,
                                                                        Collection<T> nodes,
                                                                        com.google.common.collect.Multimap<T,T> result)

propagateBottomUpLabel

public static <T> Set<T> propagateBottomUpLabel(Tree<T> tree,
                                                java.util.function.Predicate<T> predicate)

Given a predicate, return the minimum set of nodes, for which all nodes in their subtree satisfy the predicate. The algo starts with the set X of leaf nodes satisfying the predicate, and moves upwards. If all children of a parent satisfy the predicate, the children are removed from X and the parent is added instead. Note: Uses IdentityHashSet

Parameters:

tree -

predicate -

Returns:

subTree

public static <T> Tree<T> subTree(Tree<T> tree,
                                  T newRoot)

nodeCount

public static <T> long nodeCount(Tree<T> tree)

depth

public static <T> long depth(Tree<T> tree)

depth

public static <T> long depth(Tree<T> tree,
                             T node)

childIndexOf

public static <T> int childIndexOf(TreeOps2<T> ops,
                                   T node)

replace

public static <T> Tree<T> replace(Tree<T> tree,
                                  T node,
                                  T replacement)

indexOf

public static <T> int indexOf(List<T> list,
                              T find,
                              java.util.function.BiPredicate<? super T,? super T> isEquiv)

replaceNode

public static <T> T replaceNode(Tree<T> tree,
                                T node,
                                T replacement,
                                java.util.function.BiPredicate<? super T,? super T> isEquiv)

substitute

public static <T> T substitute(T node,
                               boolean descendIntoSubst,
                               TreeOps2<T> ops,
                               java.util.function.Function<? super T,? extends T> transformFn)

substitute

public static <T> T substitute(T node,
                               boolean descendIntoSubst,
                               java.util.function.Function<? super T,? extends Collection<? extends T>> getChildrenFn,
                               java.util.function.Function<? super T,? extends T> transformFn,
                               java.util.function.BiFunction<T,List<T>,T> copyFn)

findAncestor

public static <T> T findAncestor(Tree<T> tree,
                                 T node,
                                 java.util.function.Predicate<T> predicate)

Find the first ancestor for which the predicate evaluates to true

Parameters:

tree -

node -

predicate -

Returns:

inOrderSearch

public static <T> java.util.stream.Stream<T> inOrderSearch(T node,
                                                           java.util.function.Function<T,? extends Iterable<T>> parentToChildren)

inOrderSearch

public static <T,V> java.util.stream.Stream<Map.Entry<T,V>> inOrderSearch(T node,
                                                                          java.util.function.Function<T,? extends Iterable<T>> parentToChildren,
                                                                          java.util.function.Function<? super T,V> nodeToValue,
                                                                          java.util.function.BiPredicate<T,V> doDescend)

In-order-search starting from the given node and descending into the tree. Each node may be mapped to a value. A predicate determines whether to stop descending further into a sub-tree. Useful for extracting patterns from a tree.

Parameters:

node -

parentToChildren -

nodeToValue -

doDescend -

Returns:

innerNodesPerLevel

public static <T> List<List<T>> innerNodesPerLevel(Tree<T> tree)

For each level, yield the inner nodes The root node will always be part of the list, even if it does not have children

nodesPerLevel

public static <T> List<List<T>> nodesPerLevel(Tree<T> tree)

Returns the set of nodes in each level of the tree The set containing the root will be the first item in the list

Parameters:

tree -

Returns:

leafStream

public static <T> java.util.stream.Stream<T> leafStream(Tree<T> tree)

getLeafs

public static <T> List<T> getLeafs(Tree<T> tree)

getLeafs

public static <T> void getLeafs(Collection<T> result,
                                Tree<T> tree,
                                T node)

getParentsOf

public static <T> Set<T> getParentsOf(Tree<T> tree,
                                      Iterable<T> children)

Get the set of immediate parents for a given set of children

Parameters:

tree -

children -

Returns:

parentMap

public static <T> Map<T,T> parentMap(T root,
                                     java.util.function.Function<T,List<T>> parentToChildren)

Traverse an op structure and create a map from each subOp to its immediate parent NOTE It must be ensured that common sub expressions are different objects, since we are using an identity hash map for mapping children to parents

Parameters:

op -

Returns:

parentMap

public static <T> void parentMap(Map<T,T> result,
                                 T parent,
                                 java.util.function.Function<T,List<T>> parentToChildren)

remapSubTreesToLeafs

public static <T> Tree<T> remapSubTreesToLeafs(Tree<T> tree,
                                               java.util.function.Function<? super T,? extends T> remapFn)

Create a new tree object which has certain nodes remapped with *leaf* nodes

Parameters:

tree -

remapFn -

Returns:

removeUnaryNodes

public static <T> Tree<T> removeUnaryNodes(Tree<T> tree)

removeUnaryNodes

public static <T> T removeUnaryNodes(Tree<T> tree,
                                     T node,
                                     com.google.common.collect.ListMultimap<T,T> parentToChildren)

clusterNodesByFirstMultiaryAncestor

public static <T> Map<T,com.google.common.collect.Multimap<T,T>> clusterNodesByFirstMultiaryAncestor(Tree<T> tree,
                                                                                                     com.google.common.collect.Multimap<T,T> mapping)

Input: A mapping from cache nodes to candidate query nodes represented as a Multimap. Output: The mapping partitioned by each node's first multiary ancestor. Output could also be: Multimap - fmaToNodesCache For every cacheFma, map to the corresponding queryFmas - and for each of these mappings yield the candidate node mappings of the children Multimap>> Q: What if cache nodes do not have a fma? A: In this case the fma would be null, which means that there can only be a single cache node which would be grouped with a null fma. In the query, we can then check whether we are pairing a union with another union or null. We always map from cache to query. Map So the challenge is now again how to represent all the facts and how to perform the permutations / combinations...

Parameters:

cacheTree -

tree -

cacheToQueryCands -

Returns:

getFirstMultiaryAncestor

public static <T> T getFirstMultiaryAncestor(Tree<T> tree,
                                             T node)

firstMultiaryAncestor

public static <T> T firstMultiaryAncestor(Tree<T> tree,
                                          T node)

Return a node's first ancestor having an arity > 1 null if there is none.

Parameters:

tree -

node -

Returns:

getUnaryAncestors

public static <X> List<X> getUnaryAncestors(X x,
                                            Tree<X> tree,
                                            Tree<X> multiaryTree)

deriveParentMapping

public static <A,B> com.google.common.collect.Multimap<A,B> deriveParentMapping(Tree<A> aTree,
                                                                                Tree<B> bTree,
                                                                                com.google.common.collect.Multimap<A,B> childMapping)

Given a mapping of child nodes, determine which parents may be mapped to each other. For any nodes mapped in 'childMapping', their parents may be mapped as well.

Parameters:

aTree -

bTree -

childMapping -

Returns: