net.sergeych.diff

Class Delta<T,U>

java.lang.Object

net.sergeych.diff.Delta<T,U>

Type Parameters:

T -

U -

Direct Known Subclasses:

ArrayDelta, ByteArrayDelta, ChangedItem, CreatedItem, ListDelta, MapDelta, RemovedItem

public abstract class Delta<T,U>
extends java.lang.Object

Deep compare of simple types, maps and lists. Found differences are provided as a hierarchy of Delta subclasses: simple and unknown types produce ChangedItem, Maps and lists procude MapDelta and ListDelta and plain arrays produce ArrayDelta.

Note that maps could be effectively compared only if use same key types. For maps, lists and arrays removed, added and changed keys are detected separately, using CreatedItem, RemovedItem. Changed items could be any Delta inherited instances.

Comaring is made in terms of the value being changed, from old value to new value.

To perform deep compare use between(Object, Object) method.

This is an abstract base class which is a root for implementations describing different types of differences ;)

Constructor Summary

Constructors

Constructor and Description
Delta(Delta parent, T oldValue, U newValue)

Method Summary

Modifier and Type	Method and Description
static <T,U,D extends Delta> D	between(T oldValue, U newValue) Deply compare two objects and calculate the difference.
java.util.List<Delta>	getNestedDelta()
Delta	getParent()
abstract boolean	isEmpty()
U	newValue()
T	oldValue()
protected void	registerInParent() Subclasses must call it after the difference item is completely constructed and isEmpty() return valid result.

Methods inherited from class java.lang.Object

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

Constructor Detail

Delta

public Delta(Delta parent,
             T oldValue,
             U newValue)

Method Detail

registerInParent

protected void registerInParent()

Subclasses must call it after the difference item is completely constructed and isEmpty() return valid result. This method builds parent-child tree of Delta instances, excluding empty ones.

getParent

public Delta getParent()

between

public static <T,U,D extends Delta> D between(T oldValue,
                                              U newValue)

Deply compare two objects and calculate the difference. Depending on its type, the MapDelta, ListDelta, ArrayDelta ioe ChangedItem will be returned. Deep diff traverse structures of Map, List and primitive java arrays. Difference in collection is showb with ChangedItem, CreatedItem and RemovedItem. Note that Map instances should use the same key type (for example, String) to properly calculate the delta. We use "old" and "new" item terminology for clarity, actually, if can compare any 2 objects.

Type Parameters:

T -

U -

D -

Parameters:

oldValue - first value to compare

newValue - second value to compare

Returns:

Delta or null if oldValue is deeply equal to the new value.

oldValue

public T oldValue()

newValue

public U newValue()

isEmpty

public abstract boolean isEmpty()

Returns:

true if the difference is not found. This is internal function to be implemented by subclasses.

getNestedDelta

public java.util.List<Delta> getNestedDelta()