AbstractDelegatingInternalDataContainer (Red Hat JBoss Enterprise Application Platform 7.4.0.GA public API)

java.lang.Object
- org.infinispan.container.impl.AbstractDelegatingInternalDataContainer<K,V>

All Implemented Interfaces:

Iterable<InternalCacheEntry<K,V>>, DataContainer<K,V>, InternalDataContainer<K,V>

Direct Known Subclasses:

SegmentedBoundedOffHeapDataContainer
```
public abstract class AbstractDelegatingInternalDataContainer<K,V>
extends Object
implements InternalDataContainer<K,V>
```
Delegating data container that delegates all calls to the container returned from delegate()

Since:

9.0

Author:

wburns

Nested Class Summary
- Nested classes/interfaces inherited from interface org.infinispan.container.DataContainer
  DataContainer.ComputeAction<K,V>

Constructor Summary

Constructors
Constructor and Description

AbstractDelegatingInternalDataContainer()

Constructors
Constructor and Description
`AbstractDelegatingInternalDataContainer()`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addRemovalListener(Consumer<Iterable<InternalCacheEntry<K,V>>> listener)` Adds a listener that is invoked whenever `InternalDataContainer.removeSegments(IntSet)` is invoked providing a way for the listener to see what actual entries were removed from the container.
`void`	`addSegments(IntSet segments)` Sets what segments this data container should be using.
`long`	`capacity()` Returns the capacity of the underlying container.
`void`	`clear()` Removes all entries in the container
`void`	`clear(IntSet segments)` Removes entries from the container whose key maps to one of the provided segments
`InternalCacheEntry<K,V>`	`compute(int segment, K key, DataContainer.ComputeAction<K,V> action)` Same as `DataContainer.compute(Object, ComputeAction)` except that the segment of the key can provided to update entries without calculating the segment for the given key.
`InternalCacheEntry<K,V>`	`compute(K key, DataContainer.ComputeAction<K,V> action)` Computes the new value for the key.
`boolean`	`containsKey(int segment, Object k)` Same as `DataContainer.containsKey(Object)` except that the segment of the key can provided to lookup if the entry exists without calculating the segment for the given key.
`boolean`	`containsKey(Object k)` Tests whether an entry exists in the container
`protected abstract InternalDataContainer<K,V>`	`delegate()`
`CompletionStage<Void>`	`evict(int segment, K key)` Same as `DataContainer.evict(Object)` except that the segment of the key can provided to remove the entry without calculating the segment for the given key.
`void`	`evict(K key)` Atomically, it removes the key from `DataContainer` and passivates it to persistence.
`long`	`evictionSize()` Returns how large the eviction size is currently.
`void`	`forEach(Consumer<? super InternalCacheEntry<K,V>> action)`
`void`	`forEach(IntSet segments, Consumer<? super InternalCacheEntry<K,V>> action)` Performs the given action for each element of the container that maps to the given set of segments until all elements have been processed or the action throws an exception.
`InternalCacheEntry<K,V>`	`get(int segment, Object k)` Same as `DataContainer.get(Object)` except that the segment of the key can provided to lookup entries without calculating the segment for the given key
`InternalCacheEntry<K,V>`	`get(Object k)` Retrieves a cached entry
`Iterator<InternalCacheEntry<K,V>>`	`iterator()`
`Iterator<InternalCacheEntry<K,V>>`	`iterator(IntSet segments)` Same as `DataContainer.iterator()` except that only entries that map to the provided segments are returned via the iterator.
`Iterator<InternalCacheEntry<K,V>>`	`iteratorIncludingExpired()` Same as `DataContainer.iterator()` except that is also returns expired entries.
`Iterator<InternalCacheEntry<K,V>>`	`iteratorIncludingExpired(IntSet segments)` Same as `DataContainer.iteratorIncludingExpired()` except that only entries that map to the provided segments are returned via the iterator.
`InternalCacheEntry<K,V>`	`peek(int segment, Object k)` Same as `DataContainer.peek(Object)` except that the segment of the key can provided to lookup entries without calculating the segment for the given key
`InternalCacheEntry<K,V>`	`peek(Object k)` Retrieves a cache entry in the same way as `DataContainer.get(Object)`} except that it does not update or reorder any of the internal constructs.
`void`	`put(int segment, K k, V v, Metadata metadata, PrivateMetadata internalMetadata, long createdTimestamp, long lastUseTimestamp)` Same as `DataContainer.put(Object, Object, Metadata)` except that the segment of the key can provided to write/lookup entries without calculating the segment for the given key.
`void`	`put(K k, V v, Metadata metadata)` Puts an entry in the cache along with metadata adding information such lifespan of entry, max idle time, version information...etc.
`InternalCacheEntry<K,V>`	`remove(int segment, Object k)` Same as `DataContainer.remove(Object)` except that the segment of the key can provided to remove the entry without calculating the segment for the given key.
`InternalCacheEntry<K,V>`	`remove(Object k)` Removes an entry from the cache The `key` must be activate by invoking `ActivationManager.activateAsync(Object, int)`
`void`	`removeRemovalListener(Object listener)` Removes a previously registered listener via `InternalDataContainer.addRemovalListener(Consumer)`.
`void`	`removeSegments(IntSet segments)` Removes and un-associates the given segments.
`void`	`resize(long newSize)` Resizes the capacity of the underlying container.
`int`	`size()`
`int`	`size(IntSet segments)` Returns how many entries are present in the data container that map to the given segments without counting entries that are currently expired.
`int`	`sizeIncludingExpired()`
`int`	`sizeIncludingExpired(IntSet segments)` Returns how many entries are present in the data container that map to the given segments including any entries that may be expired
`Spliterator<InternalCacheEntry<K,V>>`	`spliterator()`
`Spliterator<InternalCacheEntry<K,V>>`	`spliterator(IntSet segments)` Same as `DataContainer.spliterator()` except that only entries that map to the provided segments are returned via this spliterator.
`Spliterator<InternalCacheEntry<K,V>>`	`spliteratorIncludingExpired()` Same as `DataContainer.spliterator()` except that is also returns expired entries.
`Spliterator<InternalCacheEntry<K,V>>`	`spliteratorIncludingExpired(IntSet segments)` Same as `DataContainer.spliteratorIncludingExpired()` except that only entries that map to the provided segments are returned via this spliterator.
`boolean`	`touch(int segment, Object k, long currentTimeMillis)` Touches an entry in the data container.

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

Methods inherited from interface org.infinispan.container.impl.InternalDataContainer
cleanUp, publisher

- Constructor Detail
  - AbstractDelegatingInternalDataContainer
```
public AbstractDelegatingInternalDataContainer()
```
- Method Detail
  - delegate
```
protected abstract InternalDataContainer<K,V> delegate()
```
  - get
```
public InternalCacheEntry<K,V> get(Object k)
```
    Description copied from interface: InternalDataContainer
    
    Retrieves a cached entry
    We should only ever be using the non blocking variant InternalDataContainer.peek(int, Object) in Infinispan
    
    Specified by:
    
    get in interface DataContainer<K,V>
    
    Specified by:
    
    get in interface InternalDataContainer<K,V>
    
    Parameters:
    
    k - key under which entry is stored
    
    Returns:
    
    entry, if it exists and has not expired, or null if not
  - get
```
public InternalCacheEntry<K,V> get(int segment,
                                   Object k)
```
    Description copied from interface: InternalDataContainer
    
    Same as DataContainer.get(Object) except that the segment of the key can provided to lookup entries without calculating the segment for the given key
    
    Specified by:
    
    get in interface InternalDataContainer<K,V>
    
    Parameters:
    
    segment - segment for the key
    
    k - key under which entry is stored
    
    Returns:
    
    entry, if it exists and has not expired, or null if not
  - peek
```
public InternalCacheEntry<K,V> peek(Object k)
```
    Description copied from interface: DataContainer
    
    Retrieves a cache entry in the same way as DataContainer.get(Object)} except that it does not update or reorder any of the internal constructs. I.e., expiration does not happen, and in the case of the LRU container, the entry is not moved to the end of the chain.
    This method should be used instead of DataContainer.get(Object)} when called while iterating through the data container using methods like DataContainer.iterator() to avoid changing the underlying collection's order.
    
    Specified by:
    
    peek in interface DataContainer<K,V>
    
    Parameters:
    
    k - key under which entry is stored
    
    Returns:
    
    entry, if it exists, or null if not
  - peek
```
public InternalCacheEntry<K,V> peek(int segment,
                                    Object k)
```
    Description copied from interface: InternalDataContainer
    
    Same as DataContainer.peek(Object) except that the segment of the key can provided to lookup entries without calculating the segment for the given key
    
    Specified by:
    
    peek in interface InternalDataContainer<K,V>
    
    Parameters:
    
    segment - segment for the key
    
    k - key under which entry is stored
    
    Returns:
    
    entry, if it exists, or null if not
  - touch
```
public boolean touch(int segment,
                     Object k,
                     long currentTimeMillis)
```
    Description copied from interface: InternalDataContainer
    
    Touches an entry in the data container. This will update the last access time of the entry as well as count this as a access for eviction based recency.
    
    Specified by:
    
    touch in interface InternalDataContainer<K,V>
    
    Parameters:
    
    segment - segment for the key
    
    k - key under which entry is stored
    
    currentTimeMillis - the current time in milliseconds to touch the entry with
    
    Returns:
    
    true if the entry timestamp was touched
  - put
```
public void put(K k,
                V v,
                Metadata metadata)
```
    Description copied from interface: DataContainer
    
    Puts an entry in the cache along with metadata adding information such lifespan of entry, max idle time, version information...etc.
    The key must be activate by invoking ActivationManager.activateAsync(Object, int) boolean)}.
    
    Specified by:
    
    put in interface DataContainer<K,V>
    
    Parameters:
    
    k - key under which to store entry
    
    v - value to store
    
    metadata - metadata of the entry
  - put
```
public void put(int segment,
                K k,
                V v,
                Metadata metadata,
                PrivateMetadata internalMetadata,
                long createdTimestamp,
                long lastUseTimestamp)
```
    Description copied from interface: InternalDataContainer
    
    Same as DataContainer.put(Object, Object, Metadata) except that the segment of the key can provided to write/lookup entries without calculating the segment for the given key.
    Note: The timestamps ignored if the entry already exists in the data container.
    
    Specified by:
    
    put in interface InternalDataContainer<K,V>
    
    Parameters:
    
    segment - segment for the key
    
    k - key under which to store entry
    
    v - value to store
    
    metadata - metadata of the entry
    
    createdTimestamp - creation timestamp, or -1 to use the current time
    
    lastUseTimestamp - last use timestamp, or -1 to use the current time
  - containsKey
```
public boolean containsKey(Object k)
```
    Description copied from interface: DataContainer
    
    Tests whether an entry exists in the container
    
    Specified by:
    
    containsKey in interface DataContainer<K,V>
    
    Parameters:
    
    k - key to test
    
    Returns:
    
    true if entry exists and has not expired; false otherwise
  - containsKey
```
public boolean containsKey(int segment,
                           Object k)
```
    Description copied from interface: InternalDataContainer
    
    Same as DataContainer.containsKey(Object) except that the segment of the key can provided to lookup if the entry exists without calculating the segment for the given key.
    
    Specified by:
    
    containsKey in interface InternalDataContainer<K,V>
    
    Parameters:
    
    segment - segment for the key
    
    k - key under which entry is stored
    
    Returns:
    
    true if entry exists and has not expired; false otherwise
  - remove
```
public InternalCacheEntry<K,V> remove(Object k)
```
    Description copied from interface: DataContainer
    
    Removes an entry from the cache
    The key must be activate by invoking ActivationManager.activateAsync(Object, int)
    
    Specified by:
    
    remove in interface DataContainer<K,V>
    
    Parameters:
    
    k - key to remove
    
    Returns:
    
    entry removed, or null if it didn't exist or had expired
  - remove
```
public InternalCacheEntry<K,V> remove(int segment,
                                      Object k)
```
    Description copied from interface: InternalDataContainer
    
    Same as DataContainer.remove(Object) except that the segment of the key can provided to remove the entry without calculating the segment for the given key.
    
    Specified by:
    
    remove in interface InternalDataContainer<K,V>
    
    Parameters:
    
    segment - segment for the key
    
    k - key to remove
    
    Returns:
    
    entry removed, or null if it didn't exist or had expired
  - evict
```
public void evict(K key)
```
    Description copied from interface: DataContainer
    
    Atomically, it removes the key from DataContainer and passivates it to persistence.
    The passivation must be done by invoking the method PassivationManager.passivateAsync(InternalCacheEntry).
    
    Specified by:
    
    evict in interface DataContainer<K,V>
    
    Parameters:
    
    key - The key to evict.
  - evict
```
public CompletionStage<Void> evict(int segment,
                                   K key)
```
    Description copied from interface: InternalDataContainer
    
    Same as DataContainer.evict(Object) except that the segment of the key can provided to remove the entry without calculating the segment for the given key.
    
    Specified by:
    
    evict in interface InternalDataContainer<K,V>
    
    Parameters:
    
    segment - segment for the key
    
    key - The key to evict.
  - compute
```
public InternalCacheEntry<K,V> compute(K key,
                                       DataContainer.ComputeAction<K,V> action)
```
    Description copied from interface: DataContainer
    
    Computes the new value for the key.
    See DataContainer.ComputeAction.compute(Object, org.infinispan.container.entries.InternalCacheEntry, InternalEntryFactory).
    The key must be activated by invoking ActivationManager.activateAsync(Object, int).
    Note the entry provided to DataContainer.ComputeAction may be expired as these entries are not filtered as many other methods do.
    
    Specified by:
    
    compute in interface DataContainer<K,V>
    
    Parameters:
    
    key - The key.
    
    action - The action that will compute the new value.
    
    Returns:
    
    The InternalCacheEntry associated to the key.
  - compute
```
public InternalCacheEntry<K,V> compute(int segment,
                                       K key,
                                       DataContainer.ComputeAction<K,V> action)
```
    Description copied from interface: InternalDataContainer
    
    Same as DataContainer.compute(Object, ComputeAction) except that the segment of the key can provided to update entries without calculating the segment for the given key.
    
    Specified by:
    
    compute in interface InternalDataContainer<K,V>
    
    Parameters:
    
    segment - segment for the key
    
    key - The key.
    
    action - The action that will compute the new value.
    
    Returns:
    
    The InternalCacheEntry associated to the key.
  - clear
```
public void clear()
```
    Description copied from interface: DataContainer
    
    Removes all entries in the container
    
    Specified by:
    
    clear in interface DataContainer<K,V>
  - clear
```
public void clear(IntSet segments)
```
    Description copied from interface: InternalDataContainer
    
    Removes entries from the container whose key maps to one of the provided segments
    
    Specified by:
    
    clear in interface InternalDataContainer<K,V>
    
    Parameters:
    
    segments - segments of entries to remove
  - spliterator
```
public Spliterator<InternalCacheEntry<K,V>> spliterator()
```
    Description copied from interface: DataContainer
    
    This spliterator only returns entries that are not expired, however it will not remove them while doing so.
    
    Specified by:
    
    spliterator in interface Iterable<InternalCacheEntry<K,V>>
    
    Specified by:
    
    spliterator in interface DataContainer<K,V>
    
    Returns:
    
    spliterator that doesn't produce expired entries
  - spliterator
```
public Spliterator<InternalCacheEntry<K,V>> spliterator(IntSet segments)
```
    Description copied from interface: InternalDataContainer
    
    Same as DataContainer.spliterator() except that only entries that map to the provided segments are returned via this spliterator. The spliterator will not return expired entries.
    
    Specified by:
    
    spliterator in interface InternalDataContainer<K,V>
    
    Parameters:
    
    segments - segments of entries to return
    
    Returns:
    
    spliterator containing entries mapping to those segments that aren't expired
  - spliteratorIncludingExpired
```
public Spliterator<InternalCacheEntry<K,V>> spliteratorIncludingExpired()
```
    Description copied from interface: DataContainer
    
    Same as DataContainer.spliterator() except that is also returns expired entries.
    
    Specified by:
    
    spliteratorIncludingExpired in interface DataContainer<K,V>
    
    Returns:
    
    spliterator that returns all entries including expired ones
  - spliteratorIncludingExpired
```
public Spliterator<InternalCacheEntry<K,V>> spliteratorIncludingExpired(IntSet segments)
```
    Description copied from interface: InternalDataContainer
    
    Same as DataContainer.spliteratorIncludingExpired() except that only entries that map to the provided segments are returned via this spliterator. The spliterator will return expired entries as well.
    
    Specified by:
    
    spliteratorIncludingExpired in interface InternalDataContainer<K,V>
    
    Parameters:
    
    segments - segments of entries to use
    
    Returns:
    
    spliterator containing entries mapping to those segments that could be expired
  - iterator
```
public Iterator<InternalCacheEntry<K,V>> iterator()
```
    Description copied from interface: DataContainer
    
    This iterator only returns entries that are not expired, however it will not remove them while doing so.
    
    Specified by:
    
    iterator in interface Iterable<InternalCacheEntry<K,V>>
    
    Specified by:
    
    iterator in interface DataContainer<K,V>
    
    Returns:
    
    iterator that doesn't produce expired entries
  - iterator
```
public Iterator<InternalCacheEntry<K,V>> iterator(IntSet segments)
```
    Description copied from interface: InternalDataContainer
    
    Same as DataContainer.iterator() except that only entries that map to the provided segments are returned via the iterator. The iterator will not return expired entries.
    
    Specified by:
    
    iterator in interface InternalDataContainer<K,V>
    
    Parameters:
    
    segments - segments of entries to use
    
    Returns:
    
    iterator that returns all entries mapped to the given segments
  - iteratorIncludingExpired
```
public Iterator<InternalCacheEntry<K,V>> iteratorIncludingExpired()
```
    Description copied from interface: DataContainer
    
    Same as DataContainer.iterator() except that is also returns expired entries.
    
    Specified by:
    
    iteratorIncludingExpired in interface DataContainer<K,V>
    
    Returns:
    
    iterator that returns all entries including expired ones
  - iteratorIncludingExpired
```
public Iterator<InternalCacheEntry<K,V>> iteratorIncludingExpired(IntSet segments)
```
    Description copied from interface: InternalDataContainer
    
    Same as DataContainer.iteratorIncludingExpired() except that only entries that map to the provided segments are returned via the iterator. The iterator can return expired entries.
    
    Specified by:
    
    iteratorIncludingExpired in interface InternalDataContainer<K,V>
    
    Parameters:
    
    segments - segments of entries to use
    
    Returns:
    
    iterator that returns all entries mapped to the given segments that could be expired
  - forEach
```
public void forEach(Consumer<? super InternalCacheEntry<K,V>> action)
```
    Specified by:
    
    forEach in interface Iterable<InternalCacheEntry<K,V>>
  - forEach
```
public void forEach(IntSet segments,
                    Consumer<? super InternalCacheEntry<K,V>> action)
```
    Description copied from interface: InternalDataContainer
    
    Performs the given action for each element of the container that maps to the given set of segments until all elements have been processed or the action throws an exception. Unless otherwise specified by the implementing class, actions are performed in the order of iteration (if an iteration order is specified). Exceptions thrown by the action are relayed to the caller.
    
    Specified by:
    
    forEach in interface InternalDataContainer<K,V>
    
    action - The action to be performed for each element
  - size
```
public int size()
```
    Specified by:
    
    size in interface DataContainer<K,V>
    
    Returns:
    
    count of the number of entries in the container excluding expired entries
  - size
```
public int size(IntSet segments)
```
    Description copied from interface: InternalDataContainer
    
    Returns how many entries are present in the data container that map to the given segments without counting entries that are currently expired.
    
    Specified by:
    
    size in interface InternalDataContainer<K,V>
    
    Parameters:
    
    segments - segments of entries to count
    
    Returns:
    
    count of the number of entries in the container excluding expired entries
  - sizeIncludingExpired
```
public int sizeIncludingExpired()
```
    Specified by:
    
    sizeIncludingExpired in interface DataContainer<K,V>
    
    Returns:
    
    count of the number of entries in the container including expired entries
  - sizeIncludingExpired
```
public int sizeIncludingExpired(IntSet segments)
```
    Description copied from interface: InternalDataContainer
    
    Returns how many entries are present in the data container that map to the given segments including any entries that may be expired
    
    Specified by:
    
    sizeIncludingExpired in interface InternalDataContainer<K,V>
    
    Parameters:
    
    segments - segments of entries to count
    
    Returns:
    
    count of the number of entries in the container including expired entries
  - addSegments
```
public void addSegments(IntSet segments)
```
    Description copied from interface: InternalDataContainer
    
    Sets what segments this data container should be using. Already associated segments are unaffected by this and takes a union of existing and new segments.
    
    Specified by:
    
    addSegments in interface InternalDataContainer<K,V>
    
    Parameters:
    
    segments - segments to associate with this container
  - removeSegments
```
public void removeSegments(IntSet segments)
```
    Description copied from interface: InternalDataContainer
    
    Removes and un-associates the given segments. This will notify any listeners registered via InternalDataContainer.addRemovalListener(Consumer) of entries that were removed due to no longer being associated with this container. There is no guarantee if the consumer is invoked once or multiple times for a given group of segments and could be in any order.
    When this method is invoked an implementation is free to remove any entries that don't map to segments currently associated with this container. Note that entries that were removed due to their segments never being associated with this container do not notify listeners registered via InternalDataContainer.addRemovalListener(Consumer).
    
    Specified by:
    
    removeSegments in interface InternalDataContainer<K,V>
    
    Parameters:
    
    segments - segments that should no longer be associated with this container
  - addRemovalListener
```
public void addRemovalListener(Consumer<Iterable<InternalCacheEntry<K,V>>> listener)
```
    Description copied from interface: InternalDataContainer
    
    Adds a listener that is invoked whenever InternalDataContainer.removeSegments(IntSet) is invoked providing a way for the listener to see what actual entries were removed from the container.
    
    Specified by:
    
    addRemovalListener in interface InternalDataContainer<K,V>
    
    Parameters:
    
    listener - listener that invoked of removed entries
  - removeRemovalListener
```
public void removeRemovalListener(Object listener)
```
    Description copied from interface: InternalDataContainer
    
    Removes a previously registered listener via InternalDataContainer.addRemovalListener(Consumer).
    
    Specified by:
    
    removeRemovalListener in interface InternalDataContainer<K,V>
    
    Parameters:
    
    listener - the listener to remove
  - capacity
```
public long capacity()
```
    Description copied from interface: DataContainer
    
    Returns the capacity of the underlying container. This is only supported if the container is bounded. An UnsupportedOperationException is thrown otherwise.
    
    Specified by:
    
    capacity in interface DataContainer<K,V>
    
    Returns:
  - evictionSize
```
public long evictionSize()
```
    Description copied from interface: DataContainer
    
    Returns how large the eviction size is currently. This is only supported if the container is bounded. An UnsupportedOperationException is thrown otherwise. This value will always be lower than the value returned from DataContainer.capacity()
    
    Specified by:
    
    evictionSize in interface DataContainer<K,V>
    
    Returns:
    
    how large the counted eviction is
  - resize
```
public void resize(long newSize)
```
    Description copied from interface: DataContainer
    
    Resizes the capacity of the underlying container. This is only supported if the container is bounded. An UnsupportedOperationException is thrown otherwise.
    
    Specified by:
    
    resize in interface DataContainer<K,V>
    
    Parameters:
    
    newSize - the new size

Class AbstractDelegatingInternalDataContainer<K,V>

Nested Class Summary

Nested classes/interfaces inherited from interface org.infinispan.container.DataContainer

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.infinispan.container.impl.InternalDataContainer

Constructor Detail

AbstractDelegatingInternalDataContainer

Method Detail

delegate

get

get

peek

peek

touch

put

put

containsKey

containsKey

remove

remove

evict

evict

compute

compute

clear

clear

spliterator

spliterator

spliteratorIncludingExpired

spliteratorIncludingExpired

iterator

iterator

iteratorIncludingExpired

iteratorIncludingExpired

forEach

forEach

size

size

sizeIncludingExpired

sizeIncludingExpired

addSegments

removeSegments

addRemovalListener

removeRemovalListener

capacity

evictionSize

resize