de.unkrig.commons.util

Class TreeComparator<N extends TreeComparator.Node<N>,EX extends java.lang.Throwable>

java.lang.Object

de.unkrig.commons.util.TreeComparator<N,EX>

Type Parameters:

N - The node type

EX - The exception that the abstract methods may throw

public abstract class TreeComparator<N extends TreeComparator.Node<N>,EX extends java.lang.Throwable>
extends java.lang.Object

Recursively compares two trees of nodes. Non-leaf nodes have a SortedSet of keys to child nodes.

See Also:

compare(Node, Node)

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	TreeComparator.Node<N extends TreeComparator.Node<N>> The base interface for leaf nodes and non-leaf nodes.

Constructor Summary

Constructors

Constructor and Description
TreeComparator()

Method Summary

Modifier and Type	Method and Description
long	compare(N node1, N node2) If both nodes are non-leaf nodes, nodeDeleted(N) and nodeAdded(N) are called for each child that exists only in the first resp. only in the second child set.
protected abstract void	leafNodeChangedToNonLeafNode(N node1, N node2) This abstract method is invoked by compare(Node, Node) for every node that is a leaf node under node1 and a non-leaf node under node2.
protected abstract void	leafNodeRemains(N node1, N node2) This abstract method is invoked by compare(Node, Node) for every leaf node that exists under node1 and under node2.
protected abstract void	nodeAdded(N node) This abstract method is invoked by compare(Node, Node) for every node that does not exist under node1, but under node2.
protected abstract void	nodeDeleted(N node) This abstract method is invoked by compare(Node, Node) for every node that exists under node1, but not under node2.
protected abstract void	nonLeafNodeChangedToLeafNode(N node1, N node2) This abstract method is invoked by compare(Node, Node) for every node that is a non-leaf node under node1 and a leaf node under node2.

Methods inherited from class java.lang.Object

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

Constructor Detail

TreeComparator

public TreeComparator()

Method Detail

compare

public long compare(N node1,
                    N node2)
             throws EX extends java.lang.Throwable

If both nodes are non-leaf nodes, nodeDeleted(N) and nodeAdded(N) are called for each child that exists only in the first resp. only in the second child set. For each child that exists in both child sets, this method is invoked recursively.

Otherwise, if one of the nodes is a leaf node and the other is not, leafNodeChangedToNonLeafNode(N, N) or nonLeafNodeChangedToLeafNode(N, N) is invoked.

Otherwise, both nodes are leaf nodes, and leafNodeRemains(N, N) is invoked.

Returns:

The number of differences between the two trees

Throws:

EX extends java.lang.Throwable

nodeAdded

protected abstract void nodeAdded(N node)
                           throws EX extends java.lang.Throwable

This abstract method is invoked by compare(Node, Node) for every node that does not exist under node1, but under node2.

Throws:

EX extends java.lang.Throwable

nodeDeleted

protected abstract void nodeDeleted(N node)
                             throws EX extends java.lang.Throwable

This abstract method is invoked by compare(Node, Node) for every node that exists under node1, but not under node2.

Throws:

EX extends java.lang.Throwable

nonLeafNodeChangedToLeafNode

protected abstract void nonLeafNodeChangedToLeafNode(N node1,
                                                     N node2)
                                              throws EX extends java.lang.Throwable

This abstract method is invoked by compare(Node, Node) for every node that is a non-leaf node under node1 and a leaf node under node2.

Throws:

EX extends java.lang.Throwable

leafNodeChangedToNonLeafNode

protected abstract void leafNodeChangedToNonLeafNode(N node1,
                                                     N node2)
                                              throws EX extends java.lang.Throwable

This abstract method is invoked by compare(Node, Node) for every node that is a leaf node under node1 and a non-leaf node under node2.

Throws:

EX extends java.lang.Throwable

leafNodeRemains

protected abstract void leafNodeRemains(N node1,
                                        N node2)
                                 throws EX extends java.lang.Throwable

This abstract method is invoked by compare(Node, Node) for every leaf node that exists under node1 and under node2.

Throws:

EX extends java.lang.Throwable