ArrayRingbuffer (Hazelcast Root 3.10-BETA-2 API)

java.lang.Object
- com.hazelcast.ringbuffer.impl.ArrayRingbuffer<E>

Type Parameters:

E - the type of the data stored in the ringbuffer

All Implemented Interfaces:

Ringbuffer<E>
```
public class ArrayRingbuffer<E>
extends Object
implements Ringbuffer<E>
```
The ArrayRingbuffer is responsible for storing the actual content of a ringbuffer.
Currently the Ringbuffer is not a partitioned data-structure. So all data of a ringbuffer is stored in a single partition and replicated to the replica's. No thread-safety is needed since a partition can only be accessed by a single thread at any given moment.
The ringItems is the ring that contains the actual items.

Constructor Summary

Constructors
Constructor and Description

ArrayRingbuffer(int capacity)

Constructors
Constructor and Description
`ArrayRingbuffer(int capacity)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`long`	`add(E item)` Adds an item to the tail of the ringbuffer.
`void`	`checkBlockableReadSequence(long readSequence)` Check if the sequence can be read from the ringbuffer or if the sequence is of the next item to be added into the ringbuffer.
`void`	`checkReadSequence(long sequence)` Check if the sequence can be read from the ringbuffer.
`void`	`clear()` Clears the data in the ringbuffer.
`long`	`getCapacity()` Returns the capacity of this ringbuffer.
`long`	`headSequence()` Returns the sequence of the head.
`boolean`	`isEmpty()` Checks if the ringbuffer is empty.
`long`	`merge(MergingEntry<Long,E> mergingEntry, SplitBrainMergePolicy mergePolicy, long remainingCapacity)` Merges the given `MergingEntry` with the given `SplitBrainMergePolicy`.
`long`	`peekNextTailSequence()` Returns the next sequence which the tail will be at after the next item is added.
`E`	`read(long sequence)` Reads one item from the ringbuffer.
`void`	`set(long seq, E data)` Sets the item at the given sequence.
`void`	`setHeadSequence(long sequence)` Sets the head sequence.
`void`	`setSerializationService(SerializationService serializationService)` Sets the `SerializationService` for this ringbuffer.
`void`	`setTailSequence(long sequence)` Sets the tail sequence.
`long`	`size()` Returns number of items in the ringbuffer (meaning the number of items between the `Ringbuffer.headSequence()` and `Ringbuffer.tailSequence()`).
`long`	`tailSequence()` Returns the sequence of the tail.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - ArrayRingbuffer
```
public ArrayRingbuffer(int capacity)
```
- Method Detail
  - tailSequence
```
public long tailSequence()
```
    Description copied from interface: Ringbuffer
    
    Returns the sequence of the tail. The tail is the side of the ringbuffer where the items are added to.
    The initial value of the tail is -1.
    
    Specified by:
    
    tailSequence in interface Ringbuffer<E>
    
    Returns:
    
    the sequence of the tail
  - peekNextTailSequence
```
public long peekNextTailSequence()
```
    Description copied from interface: Ringbuffer
    
    Returns the next sequence which the tail will be at after the next item is added. Please note that there is no item in the Ringbuffer with the returned sequence at the time of the call.
    
    Specified by:
    
    peekNextTailSequence in interface Ringbuffer<E>
    
    Returns:
    
    the next sequence of the tail
  - setTailSequence
```
public void setTailSequence(long sequence)
```
    Description copied from interface: Ringbuffer
    
    Sets the tail sequence. The tail sequence cannot be less than Ringbuffer.headSequence() - 1.
    
    Specified by:
    
    setTailSequence in interface Ringbuffer<E>
    
    Parameters:
    
    sequence - the new tail sequence
  - headSequence
```
public long headSequence()
```
    Description copied from interface: Ringbuffer
    
    Returns the sequence of the head. The head is the side of the ringbuffer where the oldest items in the ringbuffer are found.
    If the RingBuffer is empty, the head will be one more than the Ringbuffer.tailSequence().
    The initial value of the head is 0 (1 more than tail).
    
    Specified by:
    
    headSequence in interface Ringbuffer<E>
    
    Returns:
    
    the sequence of the head
  - setHeadSequence
```
public void setHeadSequence(long sequence)
```
    Description copied from interface: Ringbuffer
    
    Sets the head sequence. The head sequence cannot be larger than Ringbuffer.tailSequence() + 1
    
    Specified by:
    
    setHeadSequence in interface Ringbuffer<E>
    
    Parameters:
    
    sequence - the new head sequence
  - getCapacity
```
public long getCapacity()
```
    Description copied from interface: Ringbuffer
    
    Returns the capacity of this ringbuffer.
    
    Specified by:
    
    getCapacity in interface Ringbuffer<E>
    
    Returns:
    
    the capacity
  - size
```
public long size()
```
    Description copied from interface: Ringbuffer
    
    Returns number of items in the ringbuffer (meaning the number of items between the Ringbuffer.headSequence() and Ringbuffer.tailSequence()).
    
    Specified by:
    
    size in interface Ringbuffer<E>
    
    Returns:
    
    the size
  - isEmpty
```
public boolean isEmpty()
```
    Description copied from interface: Ringbuffer
    
    Checks if the ringbuffer is empty.
    
    Specified by:
    
    isEmpty in interface Ringbuffer<E>
    
    Returns:
    
    true if the ringbuffer is empty, false otherwise
  - add
```
public long add(E item)
```
    Description copied from interface: Ringbuffer
    
    Adds an item to the tail of the ringbuffer. If there is no space in the ringbuffer, the add will overwrite the oldest item in the ringbuffer. The method allows null values.
    The returned value is the sequence of the added item. Using this sequence you can read the added item.
    Using the sequence as ID
    This sequence will always be unique for this ringbuffer instance so it can be used as a unique ID generator if you are publishing items on this ringbuffer. However you need to take care of correctly determining an initial ID when any node uses the ringbuffer for the first time. The most reliable way to do that is to write a dummy item into the ringbuffer and use the returned sequence as initial ID. On the reading side, this dummy item should be discard. Please keep in mind that this ID is not the sequence of the item you are about to publish but from a previously published item. So it can't be used to find that item.
    
    Specified by:
    
    add in interface Ringbuffer<E>
    
    Parameters:
    
    item - the item to add
    
    Returns:
    
    the sequence of the added item
  - read
```
public E read(long sequence)
```
    Description copied from interface: Ringbuffer
    
    Reads one item from the ringbuffer.
    This method is not destructive unlike e.g. a queue.take. So the same item can be read by multiple readers or it can be read multiple times by the same reader.
    
    Specified by:
    
    read in interface Ringbuffer<E>
    
    Parameters:
    
    sequence - the sequence of the item to read
    
    Returns:
    
    the read item
  - checkBlockableReadSequence
```
public void checkBlockableReadSequence(long readSequence)
```
    Description copied from interface: Ringbuffer
    
    Check if the sequence can be read from the ringbuffer or if the sequence is of the next item to be added into the ringbuffer. This method also allows the sequence to be one greater than the Ringbuffer.tailSequence(), giving the opportunity to block until the item is added into the ringbuffer.
    
    Specified by:
    
    checkBlockableReadSequence in interface Ringbuffer<E>
    
    Parameters:
    
    readSequence - the sequence wanting to be read
  - checkReadSequence
```
public void checkReadSequence(long sequence)
```
    Description copied from interface: Ringbuffer
    
    Check if the sequence can be read from the ringbuffer.
    
    Specified by:
    
    checkReadSequence in interface Ringbuffer<E>
    
    Parameters:
    
    sequence - the sequence wanting to be read
  - set
```
public void set(long seq,
                E data)
```
    Description copied from interface: Ringbuffer
    
    Sets the item at the given sequence. The method allows null data.
    
    Specified by:
    
    set in interface Ringbuffer<E>
    
    Parameters:
    
    seq - the target sequence
    
    data - the data to be set
  - clear
```
public void clear()
```
    Description copied from interface: Ringbuffer
    
    Clears the data in the ringbuffer.
    
    Specified by:
    
    clear in interface Ringbuffer<E>
  - setSerializationService
```
public void setSerializationService(SerializationService serializationService)
```
    Description copied from interface: Ringbuffer
    
    Sets the SerializationService for this ringbuffer.
    
    Specified by:
    
    setSerializationService in interface Ringbuffer<E>
    
    Parameters:
    
    serializationService - the SerializationService for this ringbuffer
  - merge
```
public long merge(MergingEntry<Long,E> mergingEntry,
                  SplitBrainMergePolicy mergePolicy,
                  long remainingCapacity)
```
    Description copied from interface: Ringbuffer
    
    Merges the given MergingEntry with the given SplitBrainMergePolicy.
    
    Specified by:
    
    merge in interface Ringbuffer<E>
    
    Parameters:
    
    mergingEntry - the MergingEntry instance to merge
    
    mergePolicy - the SplitBrainMergePolicy instance to use
    
    remainingCapacity - the remaining ringbuffer capacity, which is checked if a new item has to be added
    
    Returns:
    
    the sequence ID of the merged item or -1 if no item was merged

Class ArrayRingbuffer<E>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ArrayRingbuffer

Method Detail

tailSequence

peekNextTailSequence

setTailSequence

headSequence

setHeadSequence

getCapacity

size

isEmpty

add

Using the sequence as ID

read

checkBlockableReadSequence

checkReadSequence

set

clear

setSerializationService

merge