RingbufferContainer (Hazelcast Root 3.8 API)

java.lang.Object
- com.hazelcast.ringbuffer.impl.RingbufferContainer

All Implemented Interfaces:

DataSerializable, IdentifiedDataSerializable
```
public class RingbufferContainer
extends Object
implements IdentifiedDataSerializable
```
The RingbufferContainer is responsible for creating the actual ring buffer, handling optional ring buffer storage, keeping the wait/notify key for blocking operations, ring buffer item expiration and other things not related to the actual ring buffer data structure.
The expirationPolicy contains the expiration policy of the items. If a time to live is set, the policy is created, otherwise it is null to save space.

Constructor Summary

Constructors
Constructor and Description
`RingbufferContainer()` This constructor only supports IdentifiedDataSerializable instance creation.
`RingbufferContainer(String name)` Constructs the ring buffer container with only the name and the key for blocking operations.
`RingbufferContainer(String name, RingbufferConfig config, SerializationService serializationService, ClassLoader configClassLoader)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`long`	`add(Data item)` Adds one item to the ring buffer.
`long`	`addAll(Data[] items)` Adds all items to the ring buffer.
`void`	`checkBlockableReadSequence(long readSequence)` Check if the sequence is of an item that can be read immediately or is the sequence of the next item to be added into the ringbuffer.
`void`	`cleanup()`
`long`	`getCapacity()`
`RingbufferConfig`	`getConfig()`
`int`	`getFactoryId()` Returns DataSerializableFactory factory id for this class.
`int`	`getId()` Returns type identifier for this class.
`RingbufferWaitNotifyKey`	`getRingEmptyWaitNotifyKey()` Gets the wait/notify key for the blocking operations of reading from the ring buffer.
`RingbufferStoreWrapper`	`getStore()`
`long`	`headSequence()`
`void`	`init(String name, RingbufferConfig config, SerializationService serializationService, ClassLoader configClassLoader)` Initializes the ring buffer with references to other services, the ring buffer store and the config.
`boolean`	`isEmpty()`
`Data`	`read(long sequence)` Reads one item from the ring buffer.
`void`	`readData(ObjectDataInput in)` Reads fields from the input stream
`long`	`readMany(long beginSequence, ReadResultSetImpl result)`
`long`	`remainingCapacity()` Returns the remaining capacity of the ring buffer.
`void`	`set(long sequenceId, Data dataItem)` Sets the item at the given sequence ID and updates the expiration time if TTL is configured.
`void`	`setHeadSequence(long sequence)`
`boolean`	`shouldWait(long sequence)` Returns if the sequence is one after the sequence of the newest item in the ring buffer.
`long`	`size()`
`long`	`tailSequence()`
`void`	`writeData(ObjectDataOutput out)` Writes object fields to output stream

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

- Constructor Detail
  - RingbufferContainer
```
public RingbufferContainer()
```
    This constructor only supports IdentifiedDataSerializable instance creation. For any other purpose, use other constructors in this class.
  - RingbufferContainer
```
public RingbufferContainer(String name)
```
    Constructs the ring buffer container with only the name and the key for blocking operations. This does not fully prepare the container for usage. The caller must invoke the init(String, RingbufferConfig, SerializationService, ClassLoader) method to complete the initialization before usage.
    
    Parameters:
    
    name - the name of the ring buffer container
  - RingbufferContainer
```
public RingbufferContainer(String name,
                           RingbufferConfig config,
                           SerializationService serializationService,
                           ClassLoader configClassLoader)
```
- Method Detail
  - init
```
public void init(String name,
                 RingbufferConfig config,
                 SerializationService serializationService,
                 ClassLoader configClassLoader)
```
    Initializes the ring buffer with references to other services, the ring buffer store and the config. This is because on a replication operation the container is only partially constructed. The init method finishes the configuration of the ring buffer container for further usage.
    
    Parameters:
    
    name - the name of the ring buffer
    
    config - the configuration of the ring buffer
    
    serializationService - the serialization service
    
    configClassLoader - the class loader for which the ring buffer store classes will be loaded
  - getStore
```
public RingbufferStoreWrapper getStore()
```
  - getRingEmptyWaitNotifyKey
```
public RingbufferWaitNotifyKey getRingEmptyWaitNotifyKey()
```
    Gets the wait/notify key for the blocking operations of reading from the ring buffer.
    
    Returns:
    
    the wait/notify key
  - getConfig
```
public RingbufferConfig getConfig()
```
  - tailSequence
```
public long tailSequence()
```
  - headSequence
```
public long headSequence()
```
  - setHeadSequence
```
public void setHeadSequence(long sequence)
```
  - getCapacity
```
public long getCapacity()
```
  - size
```
public long size()
```
  - isEmpty
```
public boolean isEmpty()
```
  - shouldWait
```
public boolean shouldWait(long sequence)
```
    Returns if the sequence is one after the sequence of the newest item in the ring buffer. In this case, the caller needs to wait for the item to be available. This method will throw an exception if the requested instance is larger than the sequence of the next item to be added (e.g. the second or third next item to added). If the ring buffer store is configured and enabled, this method will allow sequence values older than the head sequence.
    
    Parameters:
    
    sequence - the requested sequence
    
    Returns:
    
    should the caller wait for
    
    Throws:
    
    StaleSequenceException - if the requested sequence is 1. greater than the tail sequence + 1 or 2. smaller than the head sequence and the data store is not enabled
  - remainingCapacity
```
public long remainingCapacity()
```
    Returns the remaining capacity of the ring buffer. If TTL is enabled, then the returned capacity is equal to the total capacity of the ringbuffer minus the number of used slots in the ringbuffer which have not yet been marked as expired and cleaned up. Keep in mind that some slots could have expired items that have not yet been cleaned up and that the returned value could be stale as soon as it is returned.
    If TTL is disabled, the remaining capacity is equal to the total ringbuffer capacity.
    
    Returns:
    
    the remaining capacity of the ring buffer
  - add
```
public long add(Data item)
```
    Adds one item to the ring buffer. Sets the expiration time if TTL is configured and also attempts to store the item in the data store if one is configured.
    
    Parameters:
    
    item - item to be stored in the ring buffer and data store
    
    Returns:
    
    the sequence id of the item stored in the ring buffer
    
    Throws:
    
    HazelcastException - if there was any exception thrown by the data store
    
    HazelcastSerializationException - if the ring buffer is configured to keep items in object format and the item could not be deserialized
  - addAll
```
public long addAll(Data[] items)
```
    Adds all items to the ring buffer. Sets the expiration time if TTL is configured and also attempts to store the items in the data store if one is configured.
    
    Parameters:
    
    items - items to be stored in the ring buffer and data store
    
    Returns:
    
    the sequence id of the last item stored in the ring buffer
    
    Throws:
    
    HazelcastException - if there was any exception thrown by the data store
    
    HazelcastSerializationException - if the ring buffer is configured to keep items in object format and the item could not be deserialized
  - set
```
public void set(long sequenceId,
                Data dataItem)
```
    Sets the item at the given sequence ID and updates the expiration time if TTL is configured. Unlike other methods for adding items into the ring buffer, does not attempt to store the item in the data store. This method expand the ring buffer tail and head sequence to accommodate for the sequence. This means that it will move the head or tail sequence to the target sequence if the target sequence is less than the head sequence or greater than the tail sequence.
    
    Parameters:
    
    sequenceId - the sequence ID under which the item is stored
    
    dataItem - item to be stored in the ring buffer and data store
    
    Throws:
    
    HazelcastSerializationException - if the ring buffer is configured to keep items in object format and the item could not be deserialized
  - read
```
public Data read(long sequence)
```
    Reads one item from the ring buffer.
    
    Parameters:
    
    sequence - The sequence of the item to be read
    
    Returns:
    
    The item read
    
    Throws:
    
    StaleSequenceException - if the sequence is : 1. larger than the tailSequence or 2. smaller than the headSequence and the data store is disabled
  - readMany
```
public long readMany(long beginSequence,
                     ReadResultSetImpl result)
```
    Parameters:
    
    beginSequence - the sequence of the first item to read.
    
    result - the List where the result are stored in.
    
    Returns:
    
    returns the sequenceId of the next item to read. This is needed if not all required items are found.
    
    Throws:
    
    StaleSequenceException - if the sequence is : 1. larger than the tailSequence or 2. smaller than the headSequence and the data store is disabled
  - cleanup
```
public void cleanup()
```
  - checkBlockableReadSequence
```
public void checkBlockableReadSequence(long readSequence)
```
    Check if the sequence is of an item that can be read immediately or is the sequence of the next item to be added into the ringbuffer. Since this method allows the sequence to be one larger than the {@link #tailSequence()}, the caller can use this method to determine if he is checking the sequence ID before performing a possibly blocking read. Also, the requested sequence can be smaller than the head sequence if the data store is enabled.
    
    Parameters:
    
    readSequence - the sequence wanting to be read
    
    Throws:
    
    StaleSequenceException - if the requested sequence is smaller than the head sequence and the data store is not enabled
    
    IllegalArgumentException - if the requested sequence is greater than the tail sequence + 1 or
  - writeData
```
public void writeData(ObjectDataOutput out)
               throws IOException
```
    Description copied from interface: DataSerializable
    
    Writes object fields to output stream
    
    Specified by:
    
    writeData in interface DataSerializable
    
    Parameters:
    
    out - output
    
    Throws:
    
    IOException
  - readData
```
public void readData(ObjectDataInput in)
              throws IOException
```
    Description copied from interface: DataSerializable
    
    Reads fields from the input stream
    
    Specified by:
    
    readData in interface DataSerializable
    
    Parameters:
    
    in - input
    
    Throws:
    
    IOException
  - getFactoryId
```
public int getFactoryId()
```
    Description copied from interface: IdentifiedDataSerializable
    
    Returns DataSerializableFactory factory id for this class.
    
    Specified by:
    
    getFactoryId in interface IdentifiedDataSerializable
    
    Returns:
    
    factory id
  - getId
```
public int getId()
```
    Description copied from interface: IdentifiedDataSerializable
    
    Returns type identifier for this class. Id should be unique per DataSerializableFactory.
    
    Specified by:
    
    getId in interface IdentifiedDataSerializable
    
    Returns:
    
    type id

Class RingbufferContainer

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

RingbufferContainer

RingbufferContainer

RingbufferContainer

Method Detail

init

getStore

getRingEmptyWaitNotifyKey

getConfig

tailSequence

headSequence

setHeadSequence

getCapacity

size

isEmpty

shouldWait

remainingCapacity

add

addAll

set

read

readMany

cleanup

checkBlockableReadSequence

writeData

readData

getFactoryId

getId