QueueContainer (Hazelcast Root 3.9.3 API)

java.lang.Object
- com.hazelcast.collection.impl.queue.QueueContainer

All Implemented Interfaces:

DataSerializable, IdentifiedDataSerializable
```
public class QueueContainer
extends Object
implements IdentifiedDataSerializable
```
The QueueContainer contains the actual queue and provides functionalities such as :
- queue functionalities
- transactional operation functionalities
- schedules queue destruction if it is configured to be destroyed once empty

Constructor Summary

Constructors
Constructor and Description
`QueueContainer()` The default no-args constructor is only meant for factory usage.
`QueueContainer(String name)`
`QueueContainer(String name, QueueConfig config, NodeEngine nodeEngine, QueueService service)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Map<Long,Data>`	`addAll(Collection<Data> dataList)` Adds all items from the `dataList` to the queue.
`void`	`addAllBackup(Map<Long,Data> dataMap)` Offers the items to the backup map in bulk.
`int`	`backupSize()` Returns the number of queue items contained on this backup replica.
`void`	`cancelEvictionIfExists()`
`Map<Long,Data>`	`clear()`
`void`	`clearBackup(Set<Long> itemIdSet)`
`Map<Long,Data>`	`compareAndRemove(Collection<Data> dataList, boolean retain)` Compares if the queue contains the items in the dataList and removes them according to the retain parameter.
`void`	`compareAndRemoveBackup(Set<Long> itemIdSet)`
`boolean`	`contains(Collection<Data> dataSet)` Checks if the queue contains all items in the dataSet.
`void`	`destroy()`
`Map<Long,Data>`	`drain(int maxSize)` Removes items from the queue and the queue store (if configured), up to `maxSize` or the size of the queue, whichever is smaller.
`void`	`drainFromBackup(Set<Long> itemIdSet)`
`List<Data>`	`getAsDataList()` Returns data in the queue.
`Map<Long,QueueItem>`	`getBackupMap()` Return the map containing queue items when this instance is a backup replica.
`QueueConfig`	`getConfig()`
`Data`	`getDataFromMap(long itemId)`
`int`	`getFactoryId()` Returns DataSerializableFactory factory ID for this class.
`int`	`getId()` Returns type identifier for this class.
`Deque<QueueItem>`	`getItemQueue()` Returns the item queue on the partition owner.
`QueueWaitNotifyKey`	`getOfferWaitNotifyKey()`
`QueueWaitNotifyKey`	`getPollWaitNotifyKey()`
`QueueStoreWrapper`	`getStore()`
`boolean`	`hasEnoughCapacity()` Returns if this queue can accommodate one item.
`boolean`	`hasEnoughCapacity(int delta)` Returns if this queue can accommodate for `delta` items.
`void`	`init(boolean fromBackup)` Initializes the item queue with items from the queue store if the store is enabled and if item queue is not being initialized as a part of a backup operation.
`boolean`	`isEvictable()`
`void`	`mapDrainIterator(int maxSize, Map map)`
`void`	`mapIterateAndRemove(Map<Long,Data> map)` Deletes items from the queue which have IDs contained in the key set of the given map.
`long`	`offer(Data data)`
`void`	`offerBackup(Data data, long itemId)` Offers the item to the backup map.
`QueueItem`	`peek()` Retrieves, but does not remove, the head of this queue, or returns `null` if this queue is empty.
`QueueItem`	`poll()` Retrieves and removes the head of the queue (in other words, the first item), or returns `null` if it is empty.
`void`	`pollBackup(long itemId)` Polls an item on the backup replica.
`void`	`readData(ObjectDataInput in)` Reads fields from the input stream
`long`	`remove(Data data)` iterates all items, checks equality with data This method does not trigger store load.
`void`	`removeBackup(long itemId)` Removes a queue item from the backup map.
`void`	`rollbackTransaction(String transactionId)`
`void`	`setConfig(QueueConfig config, NodeEngine nodeEngine, QueueService service)`
`void`	`setStats(LocalQueueStatsImpl stats)`
`int`	`size()`
`int`	`txMapSize()`
`boolean`	`txnCheckReserve(long itemId)` Checks if there is a reserved item (within a transaction) with the given `itemId`.
`boolean`	`txnCommitOffer(long itemId, Data data, boolean backup)` Sets the data of a reserved item and commits the change so it can be visible outside a transaction.
`Data`	`txnCommitPoll(long itemId)`
`Data`	`txnCommitPollBackup(long itemId)` Commits the effects of the `txnPollReserve(long, String)`}.
`void`	`txnEnsureBackupReserve(long itemId, String transactionId, boolean pollOperation)`
`void`	`txnOfferBackupReserve(long itemId, String transactionId)` Reserves an ID for a future queue item and associates it with the given `transactionId`.
`long`	`txnOfferReserve(String transactionId)` Reserves an ID for a future queue item and associates it with the given `transactionId`.
`QueueItem`	`txnPeek(long offerId, String transactionId)` Retrieves, but does not remove, the head of the queue.
`void`	`txnPollBackupReserve(long itemId, String transactionId)` Makes a reservation for a poll operation.
`QueueItem`	`txnPollReserve(long reservedOfferId, String transactionId)` Tries to obtain an item by removing the head of the queue or removing an item previously reserved by invoking `txnOfferReserve(String)` with `reservedOfferId`.
`boolean`	`txnRollbackOffer(long itemId)` Removes a reserved item with the given `itemId`.
`boolean`	`txnRollbackOfferBackup(long itemId)` Removes a reserved item with the given `itemId`.
`boolean`	`txnRollbackPoll(long itemId, boolean backup)` Rolls back the effects of the `txnPollReserve(long, String)`.
`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
  - QueueContainer
```
public QueueContainer()
```
    The default no-args constructor is only meant for factory usage.
  - QueueContainer
```
public QueueContainer(String name)
```
  - QueueContainer
```
public QueueContainer(String name,
                      QueueConfig config,
                      NodeEngine nodeEngine,
                      QueueService service)
```
- Method Detail
  - init
```
public void init(boolean fromBackup)
```
    Initializes the item queue with items from the queue store if the store is enabled and if item queue is not being initialized as a part of a backup operation. If the item queue is being initialized as a part of a backup operation then the operation is in charge of adding items to a queue and the items are not loaded from a queue store.
    
    Parameters:
    
    fromBackup - indicates if this item queue is being initialized from a backup operation. If false, the item queue will initialize from the queue store. If true, it will not initialize
  - getStore
```
public QueueStoreWrapper getStore()
```
  - txnCheckReserve
```
public boolean txnCheckReserve(long itemId)
```
    Checks if there is a reserved item (within a transaction) with the given itemId.
    
    Parameters:
    
    itemId - the ID which is to be checked
    
    Returns:
    
    true if there is an item reserved with this ID
    
    Throws:
    
    TransactionException - if there is no reserved item with the ID
  - txnEnsureBackupReserve
```
public void txnEnsureBackupReserve(long itemId,
                                   String transactionId,
                                   boolean pollOperation)
```
  - txnPollReserve
```
public QueueItem txnPollReserve(long reservedOfferId,
                                String transactionId)
```
    Tries to obtain an item by removing the head of the queue or removing an item previously reserved by invoking txnOfferReserve(String) with reservedOfferId.
    If the queue item does not have data in-memory it will load the data from the queue store if the queue store is configured and enabled.
    
    Parameters:
    
    reservedOfferId - the ID of the reserved item to be returned if the queue is empty
    
    transactionId - the transaction ID for which this poll is invoked
    
    Returns:
    
    the head of the queue or a reserved item with the reservedOfferId if there is any
  - txnPollBackupReserve
```
public void txnPollBackupReserve(long itemId,
                                 String transactionId)
```
    Makes a reservation for a poll operation. Should be executed as a part of the prepare phase for a transactional queue poll on the partition backup replica. The ID of the item being polled is determined by the partition owner.
    
    Parameters:
    
    itemId - the ID of the reserved item to be polled
    
    transactionId - the transaction ID
    
    See Also:
    
    txnPollReserve(long, String), TxnReservePollOperation
  - txnCommitPoll
```
public Data txnCommitPoll(long itemId)
```
  - txnCommitPollBackup
```
public Data txnCommitPollBackup(long itemId)
```
    Commits the effects of the txnPollReserve(long, String)}. Also deletes the item data from the queue data store if it is configured and enabled.
    
    Parameters:
    
    itemId - the ID of the item which was polled inside a transaction
    
    Returns:
    
    the data of the polled item
    
    Throws:
    
    HazelcastException - if there was any exception while removing the item from the queue data store
  - txnRollbackPoll
```
public boolean txnRollbackPoll(long itemId,
                               boolean backup)
```
    Rolls back the effects of the txnPollReserve(long, String). The backup parameter defines whether this item was stored on a backup queue or a primary queue. It will return the item to the queue or backup map if it wasn't offered as a part of the transaction. Cancels the queue eviction if one is scheduled.
    
    Parameters:
    
    itemId - the ID of the item which was polled in a transaction
    
    backup - if this is the primary or the backup replica for this queue
    
    Returns:
    
    if there was any polled item with the itemId inside a transaction
  - txnOfferReserve
```
public long txnOfferReserve(String transactionId)
```
    Reserves an ID for a future queue item and associates it with the given transactionId. The item is not yet visible in the queue, it is just reserved for future insertion.
    
    Parameters:
    
    transactionId - the ID of the transaction offering this item
    
    Returns:
    
    the ID of the reserved item
  - txnOfferBackupReserve
```
public void txnOfferBackupReserve(long itemId,
                                  String transactionId)
```
    Reserves an ID for a future queue item and associates it with the given transactionId. The item is not yet visible in the queue, it is just reserved for future insertion.
    
    Parameters:
    
    transactionId - the ID of the transaction offering this item
    
    itemId - the ID of the item being reserved
  - txnCommitOffer
```
public boolean txnCommitOffer(long itemId,
                              Data data,
                              boolean backup)
```
    Sets the data of a reserved item and commits the change so it can be visible outside a transaction. The commit means that the item is offered to the queue if backup is false or saved into a backup map if backup is true. This is because a node can hold backups for queues on other nodes. Cancels the queue eviction if one is scheduled.
    
    Parameters:
    
    itemId - the ID of the reserved item
    
    data - the data to be associated with the reserved item
    
    backup - if the item is to be offered to the underlying queue or stored as a backup
    
    Returns:
    
    true if the commit succeeded
    
    Throws:
    
    TransactionException - if there is no reserved item with the itemId
  - txnRollbackOffer
```
public boolean txnRollbackOffer(long itemId)
```
    Removes a reserved item with the given itemId. Also schedules the queue for destruction if it is empty or destroys it immediately if it is empty and QueueConfig.getEmptyQueueTtl() is 0.
    
    Parameters:
    
    itemId - the ID of the reserved item to be removed
    
    Returns:
    
    if an item was reserved with the given itemId
  - txnRollbackOfferBackup
```
public boolean txnRollbackOfferBackup(long itemId)
```
    Removes a reserved item with the given itemId.
    
    Parameters:
    
    itemId - the ID of the reserved item to be removed
    
    Returns:
    
    if an item was reserved with the given itemId
  - txnPeek
```
public QueueItem txnPeek(long offerId,
                         String transactionId)
```
    Retrieves, but does not remove, the head of the queue. If the queue is empty checks if there is a reserved item with the associated offerId and returns it. If the item was retrieved from the queue but does not contain any data and the queue store is enabled, this method will try load the data from the data store.
    
    Parameters:
    
    offerId - the ID of the reserved item to be returned if the queue is empty
    
    transactionId - currently ignored
    
    Returns:
    
    the head of the queue or a reserved item associated with the offerId if the queue is empty
    
    Throws:
    
    HazelcastException - if there is an exception while loading the data from the queue store
  - offer
```
public long offer(Data data)
```
  - offerBackup
```
public void offerBackup(Data data,
                        long itemId)
```
    Offers the item to the backup map. If the memory limit has been achieved the item data will not be kept in-memory. Executed on the backup replica
    
    Parameters:
    
    data - the item data
    
    itemId - the item ID as determined by the primary replica
  - addAll
```
public Map<Long,Data> addAll(Collection<Data> dataList)
```
    Adds all items from the dataList to the queue. The data will be stored in the queue store if configured and enabled. If the store is enabled, only QueueStoreWrapper.getMemoryLimit() item data will be stored in memory. Cancels the eviction if one is scheduled.
    
    Parameters:
    
    dataList - the items to be added to the queue and stored in the queue store
    
    Returns:
    
    map of item ID and items added
  - addAllBackup
```
public void addAllBackup(Map<Long,Data> dataMap)
```
    Offers the items to the backup map in bulk. If the memory limit has been achieved the item data will not be kept in-memory. Executed on the backup replica
    
    Parameters:
    
    dataMap - the map from item ID to queue item
    
    See Also:
    
    offerBackup(Data, long)
  - peek
```
public QueueItem peek()
```
    Retrieves, but does not remove, the head of this queue, or returns null if this queue is empty. Loads the data from the queue store if the item data is empty.
    
    Returns:
    
    the first item in the queue
  - poll
```
public QueueItem poll()
```
    Retrieves and removes the head of the queue (in other words, the first item), or returns null if it is empty. Also calls the queue store for item deletion by item ID.
    
    Returns:
    
    the first item in the queue
  - pollBackup
```
public void pollBackup(long itemId)
```
    Polls an item on the backup replica. The item ID is predetermined when executing the poll operation on the partition owner. Executed on the backup replica
    
    Parameters:
    
    itemId - the item ID as determined by the primary replica
  - drain
```
public Map<Long,Data> drain(int maxSize)
```
    Removes items from the queue and the queue store (if configured), up to maxSize or the size of the queue, whichever is smaller. Also schedules the queue for destruction if it is empty or destroys it immediately if it is empty and QueueConfig.getEmptyQueueTtl() is 0.
    
    Parameters:
    
    maxSize - the maximum number of items to be removed
    
    Returns:
    
    the map of IDs and removed (drained) items
  - mapDrainIterator
```
public void mapDrainIterator(int maxSize,
                             Map map)
```
  - drainFromBackup
```
public void drainFromBackup(Set<Long> itemIdSet)
```
  - size
```
public int size()
```
  - txMapSize
```
public int txMapSize()
```
  - backupSize
```
public int backupSize()
```
    Returns the number of queue items contained on this backup replica. A transaction might temporarily reserve a poll operation by removing an item from this map. If the transaction is committed, the map will remain the same. If the transaction is aborted, the item is returned to the map.
    
    Returns:
    
    the number of items on this backup replica
  - clear
```
public Map<Long,Data> clear()
```
  - clearBackup
```
public void clearBackup(Set<Long> itemIdSet)
```
  - remove
```
public long remove(Data data)
```
    iterates all items, checks equality with data This method does not trigger store load.
  - removeBackup
```
public void removeBackup(long itemId)
```
    Removes a queue item from the backup map. This should be executed on the backup replica.
    
    Parameters:
    
    itemId - the queue item ID
  - contains
```
public boolean contains(Collection<Data> dataSet)
```
    Checks if the queue contains all items in the dataSet. This method does not trigger store load.
    
    Parameters:
    
    dataSet - the items which should be stored in the queue
    
    Returns:
    
    true if the queue contains all items, false otherwise
  - getAsDataList
```
public List<Data> getAsDataList()
```
    Returns data in the queue. This method triggers store load.
    
    Returns:
    
    the item data in the queue.
  - compareAndRemove
```
public Map<Long,Data> compareAndRemove(Collection<Data> dataList,
                                       boolean retain)
```
    Compares if the queue contains the items in the dataList and removes them according to the retain parameter. If the retain parameter is true, it will remove items which are not in the dataList (retaining the items which are in the list). If the retain parameter is false, it will remove items which are in the dataList (retaining all other items which are not in the list).
    Note: this method will trigger store load.
    
    Parameters:
    
    dataList - the list of items which are to be retained in the queue or which are to be removed from the queue
    
    retain - does the method retain the items in the list (true) or remove them from the queue (false)
    
    Returns:
    
    map of removed items by ID
  - mapIterateAndRemove
```
public void mapIterateAndRemove(Map<Long,Data> map)
```
    Deletes items from the queue which have IDs contained in the key set of the given map. Also schedules the queue for destruction if it is empty or destroys it immediately if it is empty and QueueConfig.getEmptyQueueTtl() is 0.
    
    Parameters:
    
    map - the map of items which to be removed.
  - compareAndRemoveBackup
```
public void compareAndRemoveBackup(Set<Long> itemIdSet)
```
  - hasEnoughCapacity
```
public boolean hasEnoughCapacity()
```
    Returns if this queue can accommodate one item.
    
    Returns:
    
    if the queue has capacity for one item
  - hasEnoughCapacity
```
public boolean hasEnoughCapacity(int delta)
```
    Returns if this queue can accommodate for delta items.
    
    Parameters:
    
    delta - the number of items that should be stored in the queue
    
    Returns:
    
    if the queue has enough capacity for the items
  - getItemQueue
```
public Deque<QueueItem> getItemQueue()
```
    Returns the item queue on the partition owner. This method will also move the items from the backup map if this member has been promoted from a backup replica to the partition owner and clear the backup map.
    
    Returns:
    
    the item queue
  - getBackupMap
```
public Map<Long,QueueItem> getBackupMap()
```
    Return the map containing queue items when this instance is a backup replica. The map contains both items that are parts of different transactions and items which have already been committed to the queue.
    
    Returns:
    
    backup replica map from item ID to queue item
  - getDataFromMap
```
public Data getDataFromMap(long itemId)
```
  - setConfig
```
public void setConfig(QueueConfig config,
                      NodeEngine nodeEngine,
                      QueueService service)
```
  - getPollWaitNotifyKey
```
public QueueWaitNotifyKey getPollWaitNotifyKey()
```
  - getOfferWaitNotifyKey
```
public QueueWaitNotifyKey getOfferWaitNotifyKey()
```
  - getConfig
```
public QueueConfig getConfig()
```
  - setStats
```
public void setStats(LocalQueueStatsImpl stats)
```
  - cancelEvictionIfExists
```
public void cancelEvictionIfExists()
```
  - isEvictable
```
public boolean isEvictable()
```
  - rollbackTransaction
```
public void rollbackTransaction(String transactionId)
```
  - 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
  - destroy
```
public void destroy()
```
  - 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. It should be unique per DataSerializableFactory.
    
    Specified by:
    
    getId in interface IdentifiedDataSerializable
    
    Returns:
    
    type ID

Class QueueContainer

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

QueueContainer

QueueContainer

QueueContainer

Method Detail

init

getStore

txnCheckReserve

txnEnsureBackupReserve

txnPollReserve

txnPollBackupReserve

txnCommitPoll

txnCommitPollBackup

txnRollbackPoll

txnOfferReserve

txnOfferBackupReserve

txnCommitOffer

txnRollbackOffer

txnRollbackOfferBackup

txnPeek

offer

offerBackup

addAll

addAllBackup

peek

poll

pollBackup

drain

mapDrainIterator

drainFromBackup

size

txMapSize

backupSize

clear

clearBackup

remove

removeBackup

contains

getAsDataList

compareAndRemove

mapIterateAndRemove

compareAndRemoveBackup

hasEnoughCapacity

hasEnoughCapacity

getItemQueue

getBackupMap

getDataFromMap

setConfig

getPollWaitNotifyKey

getOfferWaitNotifyKey

getConfig

setStats

cancelEvictionIfExists

isEvictable

rollbackTransaction

writeData

readData

destroy

getFactoryId

getId