org.axonframework.eventhandling

Class Segment

java.lang.Object

org.axonframework.eventhandling.Segment

All Implemented Interfaces:

Comparable<Segment>

public class Segment
extends Object
implements Comparable<Segment>

A representation of a segment and corresponding mask with various capabilities.

Definition

A Segment is a fraction of the total population of events. The 'mask' is a bitmask to be applied to an identifier, resulting in the segmentId of the Segment.

Field Summary

Fields

Modifier and Type	Field and Description
static Segment	ROOT_SEGMENT Represents the Segment that matches against all input, but can be split to start processing elements in parallel.

Method Summary

Modifier and Type	Method and Description
int	compareTo(Segment that)
static Segment[]	computeSegments(int... segments) Compute the Segment's from a given list of segmentId's.
boolean	equals(Object o)
int	getMask() Getter for the segment mask.
int	getSegmentId() Getter for the segment identifier.
int	hashCode()
boolean	isMergeableWith(Segment other) Indicates whether this segment can be merged with the given other segment.
boolean	matches(int value) Returns true when the mask applied to the given value, matches the segment id.
boolean	matches(Object value) Indicates whether the given value matches this segment.
int	mergeableSegmentId() Returns the segmentId of the segment this one can be merged with
Segment	mergedWith(Segment other) Calculates the Segment that represents the merger of this segment with the given other segment.
Segment[]	split() Returns an array with two segments with a corresponding mask. The first entry contains the original segmentId, with the newly calculated mask.
static List<Segment>	splitBalanced(Segment segment, int numberOfTimes) Split a given Segment n-times in round robin fashion.
String	toString()

Methods inherited from class java.lang.Object

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

Field Detail

ROOT_SEGMENT

public static final Segment ROOT_SEGMENT

Represents the Segment that matches against all input, but can be split to start processing elements in parallel.

Method Detail

computeSegments

public static Segment[] computeSegments(int... segments)

Compute the Segment's from a given list of segmentId's.

Parameters:

segments - The segment id's for which to compute Segments.

Returns:

an array of computed Segment

splitBalanced

public static List<Segment> splitBalanced(Segment segment,
                                          int numberOfTimes)

Split a given Segment n-times in round robin fashion.

Parameters:

segment - The Segment to split.

numberOfTimes - The number of times to split it.

Returns:

a collection of Segment's.

mergedWith

public Segment mergedWith(Segment other)

Calculates the Segment that represents the merger of this segment with the given other segment.

Parameters:

other - the segment to merge this one with

Returns:

The Segment representing the merged segments

mergeableSegmentId

public int mergeableSegmentId()

Returns the segmentId of the segment this one can be merged with

Returns:

the segmentId of the segment this one can be merged with

isMergeableWith

public boolean isMergeableWith(Segment other)

Indicates whether this segment can be merged with the given other segment.

Two segments can be merged when their mask is identical, and the only difference in SegmentID is in the first 1-bit of their mask.

Parameters:

other - the Segment to verify mergeability for

Returns:

true if the segments can be merged, otherwise false

getSegmentId

public int getSegmentId()

Getter for the segment identifier.

Returns:

the Segment identifier.

getMask

public int getMask()

Getter for the segment mask.

Returns:

the Segment mask.

matches

public boolean matches(int value)

Returns true when the mask applied to the given value, matches the segment id.

Parameters:

value - The value to be tested.

Returns:

true when matching this segment.

matches

public boolean matches(Object value)

Indicates whether the given value matches this segment. A value matches when the hashCode of a value, after applying this segments mask, equals to this segment ID.

Parameters:

value - The value to verify against.

Returns:

true if the given value matches this segment, otherwise false

split

public Segment[] split()

Returns an array with two segments with a corresponding mask.

The first entry contains the original segmentId, with the newly calculated mask. (Simple left shift, adding a '1' as LSB). The 2nd entry is a new segmentId with the same derived mask.

Callers must ensure that either the two returned Segments are used, or the instance from which they are derived, but not both.

Returns:

an array of two Segment's.

equals

public boolean equals(Object o)

Overrides:

equals in class Object

toString

public String toString()

Overrides:

toString in class Object

hashCode

public int hashCode()

Overrides:

hashCode in class Object

compareTo

public int compareTo(Segment that)

Specified by:

compareTo in interface Comparable<Segment>