voldemort.versioning
Class VectorClock

java.lang.Object
  voldemort.versioning.VectorClock

All Implemented Interfaces:

java.io.Serializable, Version

public class VectorClock
extends java.lang.Object
implements Version, java.io.Serializable

A vector of the number of writes mastered by each node. The vector is stored sparely, since, in general, writes will be mastered by only one node. This means implicitly all the versions are at zero, but we only actually store those greater than zero.

See Also:

Serialized Form

Constructor Summary

VectorClock()
Construct an empty VectorClock

VectorClock(byte[] bytes)
Takes the bytes of a VectorClock and creates a java object from them.

VectorClock(byte[] bytes, int offset)
Read the vector clock from the given bytes starting from a particular offset

VectorClock(java.util.List<ClockEntry> versions, long timestamp)
Create a VectorClock with the given version and timestamp

VectorClock(long timestamp)

Method Summary

VectorClock	clone()
static Occured	compare(VectorClock v1, VectorClock v2) Is this Reflexive, AntiSymetic, and Transitive? Compare two VectorClocks, the outcomes will be one of the following: -- Clock 1 is BEFORE clock 2 if there exists an i such that c1(i) <= c(2) and there does not exist a j such that c1(j) > c2(j).
Occured	compare(Version v) Return whether or not the given version preceeded this one, succeeded it, or is concurrant with it
boolean	equals(java.lang.Object object)
java.util.List<ClockEntry>	getEntries()
long	getMaxVersion()
long	getTimestamp()
int	hashCode()
VectorClock	incremented(int nodeId, long time) Get new vector clock based on this clock but incremented on index nodeId
void	incrementVersion(int node, long time) Increment the version info associated with the given node
VectorClock	merge(VectorClock clock)
int	sizeInBytes()
byte[]	toBytes()
java.lang.String	toString()

Methods inherited from class java.lang.Object

finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

VectorClock

public VectorClock()

Construct an empty VectorClock

VectorClock

public VectorClock(long timestamp)

VectorClock

public VectorClock(java.util.List<ClockEntry> versions,
                   long timestamp)

Create a VectorClock with the given version and timestamp

Parameters:

versions - The version to prepopulate

timestamp - The timestamp to prepopulate

VectorClock

public VectorClock(byte[] bytes)

Takes the bytes of a VectorClock and creates a java object from them. For efficiency reasons the extra bytes can be attached to the end of the byte array that are not related to the VectorClock

Parameters:

bytes - The serialized bytes of the VectorClock

VectorClock

public VectorClock(byte[] bytes,
                   int offset)

Read the vector clock from the given bytes starting from a particular offset

Parameters:

bytes - The bytes to read from

offset - The offset to start reading from

Method Detail

toBytes

public byte[] toBytes()

sizeInBytes

public int sizeInBytes()

incrementVersion

public void incrementVersion(int node,
                             long time)

Increment the version info associated with the given node

Parameters:

node - The node

incremented

public VectorClock incremented(int nodeId,
                               long time)

Get new vector clock based on this clock but incremented on index nodeId

Parameters:

nodeId - The id of the node to increment

Returns:

A vector clock equal on each element execept that indexed by nodeId

clone

public VectorClock clone()

Overrides:

clone in class java.lang.Object

equals

public boolean equals(java.lang.Object object)

Overrides:

equals in class java.lang.Object

hashCode

public int hashCode()

Overrides:

hashCode in class java.lang.Object

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object

getMaxVersion

public long getMaxVersion()

merge

public VectorClock merge(VectorClock clock)

compare

public Occured compare(Version v)

Description copied from interface: Version

Return whether or not the given version preceeded this one, succeeded it, or is concurrant with it

Specified by:

compare in interface Version

Parameters:

v - The other version

compare

public static Occured compare(VectorClock v1,
                              VectorClock v2)

Is this Reflexive, AntiSymetic, and Transitive? Compare two VectorClocks, the outcomes will be one of the following: -- Clock 1 is BEFORE clock 2 if there exists an i such that c1(i) <= c(2) and there does not exist a j such that c1(j) > c2(j). -- Clock 1 is CONCURRENT to clock 2 if there exists an i, j such that c1(i) < c2(i) and c1(j) > c2(j) -- Clock 1 is AFTER clock 2 otherwise

Parameters:

v1 - The first VectorClock

v2 - The second VectorClock

getTimestamp

public long getTimestamp()

getEntries

public java.util.List<ClockEntry> getEntries()