Entry (cache2k implementation 1.2.2.Final API)

java.lang.Object
- org.cache2k.core.Entry<K,T>

All Implemented Interfaces:

org.cache2k.CacheEntry<K,T>, ExaminationEntry<K,T>, StorageEntry
```
public class Entry<K,T>
extends Object
implements org.cache2k.CacheEntry<K,T>, StorageEntry, ExaminationEntry<K,T>
```
The cache entry. This is a combined hash table entry with hashCode and and collision list (other field) and it contains a double linked list (next and previous) for the eviction algorithm.
When an entry is present and its value is updated, the entry objects stays the same. The entry object is used for locking and coordination of all concurrent accesses to it.
The entry is only used as CacheEntry directly and handed to the application when it is locked and the values are stable, that is for example when the loader is called.

Author:

Jens Wilke

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class Entry.ProcessingState
Different possible processing states.

Nested Classes
Modifier and Type	Class and Description
`static class`	`Entry.ProcessingState` Different possible processing states.

Field Summary

Fields
Modifier and Type	Field and Description
`Entry<K,T>`	`another` Hash implementation: Link to another entry in the same hash table slot when the hash code collides.
`static int`	`EXPIRY_TIME_MIN` A value greater as means it is a time value.
`int`	`hashCode` Hash implementation: the calculated, modified hash code, retrieved from the key when the entry is inserted in the cache
`long`	`hitCnt` Hit counter.
`protected static org.cache2k.core.CompactEntry.InitialValueInEntryNeverReturned`	`INITIAL_VALUE`
`Entry`	`next` Lru list: pointer to next element or list head
`protected long`	`nextRefreshTime` Contains the next time a refresh has to occur, or if no background refresh is configured, when the entry is expired.
`Entry`	`prev` Lru list: pointer to previous element or list head

Constructor Summary

Constructors
Constructor and Description

Entry()

Entry(K _key, int _hashCode)

Constructors
Constructor and Description
`Entry()`
`Entry(K _key, int _hashCode)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static boolean`	`checkCyclicListIntegrity(Entry e)`
`void`	`ensureAbort(boolean _finished)` Make sure entry processing is properly finished, otherwise threads waiting for an entry get stuck.
`boolean`	`equalsValue(T v)`
`long`	`getCreatedOrUpdated()` Used for the storage interface.
`static int`	`getCyclicListEntryCount(Entry e)`
`long`	`getEntryExpiryTime()` Deprecated. Always returns 0, only to fulfill the `StorageEntry` interface
`Throwable`	`getException()`
`K`	`getKey()`
`K`	`getKeyObj()` Get the raw object reference.
`long`	`getLastModification()` Deprecated.
`long`	`getNextRefreshTime()`
`<X> X`	`getPiggyBack(Class<X> _class)`
`int`	`getProcessingState()`
`long`	`getRefreshProbationNextRefreshTime()`
`long`	`getRefreshTime()`
`org.cache2k.integration.ExceptionInformation`	`getSuppressedLoadExceptionInformation()`
`SimpleTimerTask`	`getTask()`
`T`	`getValue()` Deprecated.
`long`	`getValueExpiryTime()` Expiry time or 0.
`T`	`getValueOrException()` The value of the entry or an `ExceptionWrapper`.
`boolean`	`hasFreshData(InternalClock t)` Returns true if the entry has a valid value and is fresh / not expired.
`static void`	`insertInList(Entry _head, Entry e)`
`static <E extends Entry> E`	`insertIntoTailCyclicList(E _head, E e)`
`boolean`	`isDataValid()` The entry value was fetched and is valid, which means it can be returned by the cache.
`boolean`	`isExpired()` The entry expired, still in the cache and subject to removal from the cache if `HeapCache.isKeepAfterExpired()` is false.
`boolean`	`isGettingRefresh()`
`boolean`	`isGone()` The entry is not present in the heap any more and was evicted, expired or removed.
`boolean`	`isHot()`
`boolean`	`isNotYetInsertedInReplacementList()` Entry was not inserted into the replacement list AND not removed from replacement list.
`boolean`	`isProcessing()`
`boolean`	`isRemovedFromReplacementList()` Check that this entry is removed from the list, may be used in assertions.
`boolean`	`isVirgin()` Initial state of an entry.
`boolean`	`needsTimeCheck()`
`void`	`nextProcessingStep(int ps)` Switch to another processing state that is other then done.
`static String`	`num2processingStateText(int ps)`
`void`	`processingDone()` Set processing state to done and notify all that wait for processing this entry.
`void`	`removedFromList()` Reset next as a marker for `isRemovedFromReplacementList()`
`static <E extends Entry> E`	`removeFromCyclicList(E _head, E e)`
`static Entry`	`removeFromCyclicList(Entry e)`
`static void`	`removeFromList(Entry e)`
`void`	`resetSuppressedLoadExceptionInformation()` If the entry carries information about a suppressed exception, clear it.
`void`	`setExpiredState()` Entry is kept in the cache but has expired
`void`	`setGone()`
`void`	`setHot(boolean f)`
`void`	`setNextRefreshTime(long _nextRefreshTime)`
`void`	`setRefreshProbationNextRefreshTime(long nrt)`
`void`	`setRefreshTime(long t)` Set modification time and marks entry as dirty.
`void`	`setSuppressedLoadExceptionInformation(org.cache2k.integration.ExceptionInformation w)`
`void`	`setTask(SimpleTimerTask v)`
`void`	`setValueOrException(T _valueOrException)`
`Entry`	`shortCircuit()`
`void`	`startProcessing(int ps)` Starts long operation on entry.
`String`	`toString()`
`String`	`toString(HeapCache c)`
`void`	`waitForProcessing()`

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

Methods inherited from interface org.cache2k.CacheEntry
getException, getKey, getValue

Methods inherited from interface org.cache2k.core.storageApi.StorageEntry
getKey, getValueOrException

Methods inherited from interface org.cache2k.core.operation.ExaminationEntry
getKey, getValueOrException

- Field Detail
  - EXPIRY_TIME_MIN
```
public static final int EXPIRY_TIME_MIN
```
    A value greater as means it is a time value.
    
    See Also:
    
    Constant Field Values
  - next
```
public Entry next
```
    Lru list: pointer to next element or list head
  - prev
```
public Entry prev
```
    Lru list: pointer to previous element or list head
  - INITIAL_VALUE
```
protected static final org.cache2k.core.CompactEntry.InitialValueInEntryNeverReturned INITIAL_VALUE
```
  - nextRefreshTime
```
protected volatile long nextRefreshTime
```
    Contains the next time a refresh has to occur, or if no background refresh is configured, when the entry is expired. Low values have a special meaning, see defined constants. Negative values means that we need to check against the wall clock.
  - hashCode
```
public final int hashCode
```
    Hash implementation: the calculated, modified hash code, retrieved from the key when the entry is inserted in the cache
    
    See Also:
    
    HeapCache.modifiedHash(int)
  - another
```
public Entry<K,T> another
```
    Hash implementation: Link to another entry in the same hash table slot when the hash code collides.
  - hitCnt
```
public long hitCnt
```
    Hit counter. Modified directly by heap cache and eviction algorithm.
    
    See Also:
    
    HeapCache.recordHit(Entry)
- Constructor Detail
  - Entry
```
public Entry(K _key,
             int _hashCode)
```
  - Entry
```
public Entry()
```
- Method Detail
  - setRefreshTime
```
public void setRefreshTime(long t)
```
    Set modification time and marks entry as dirty. Bit 0 was used as dirty bit for the storage attachment. Not used at the moment.
  - getRefreshTime
```
public long getRefreshTime()
```
    Specified by:
    
    getRefreshTime in interface ExaminationEntry<K,T>
  - getLastModification
```
@Deprecated
public long getLastModification()
```
    Deprecated.
    
    Specified by:
    
    getLastModification in interface org.cache2k.CacheEntry<K,T>
  - num2processingStateText
```
public static String num2processingStateText(int ps)
```
  - getProcessingState
```
public int getProcessingState()
```
  - startProcessing
```
public void startProcessing(int ps)
```
    Starts long operation on entry. Pins the entry in the cache.
  - nextProcessingStep
```
public void nextProcessingStep(int ps)
```
    Switch to another processing state that is other then done.
  - processingDone
```
public void processingDone()
```
    Set processing state to done and notify all that wait for processing this entry.
  - getNextRefreshTime
```
public long getNextRefreshTime()
```
  - setNextRefreshTime
```
public void setNextRefreshTime(long _nextRefreshTime)
```
  - ensureAbort
```
public void ensureAbort(boolean _finished)
```
    Make sure entry processing is properly finished, otherwise threads waiting for an entry get stuck.
    Usually no exceptions happens, but the CacheClosedException is happening out of order and stops processing to properly finish.
  - isProcessing
```
public boolean isProcessing()
```
  - waitForProcessing
```
public void waitForProcessing()
```
  - isGettingRefresh
```
public boolean isGettingRefresh()
```
  - removedFromList
```
public final void removedFromList()
```
    Reset next as a marker for isRemovedFromReplacementList()
  - isRemovedFromReplacementList
```
public boolean isRemovedFromReplacementList()
```
    Check that this entry is removed from the list, may be used in assertions.
  - isNotYetInsertedInReplacementList
```
public boolean isNotYetInsertedInReplacementList()
```
    Entry was not inserted into the replacement list AND not removed from replacement list. In practise it may happen that an entry gets removed before even entering the replacement list, because of clear.
  - shortCircuit
```
public Entry shortCircuit()
```
  - isVirgin
```
public final boolean isVirgin()
```
    Initial state of an entry.
  - isDataValid
```
public final boolean isDataValid()
```
    The entry value was fetched and is valid, which means it can be returned by the cache. If a valid entry gets removed from the cache the data is still valid. This is because a concurrent get needs to return the data. There is also the chance that an entry is removed by eviction, or is never inserted to the cache, before the get returns it.
    Even if this is true, the data may be expired. Use hasFreshData() to make sure to get not expired data.
  - hasFreshData
```
public final boolean hasFreshData(InternalClock t)
```
    Returns true if the entry has a valid value and is fresh / not expired.
  - setExpiredState
```
public void setExpiredState()
```
    Entry is kept in the cache but has expired
  - isExpired
```
public boolean isExpired()
```
    The entry expired, still in the cache and subject to removal from the cache if HeapCache.isKeepAfterExpired() is false.
  - setGone
```
public void setGone()
```
  - isGone
```
public boolean isGone()
```
    The entry is not present in the heap any more and was evicted, expired or removed.
  - needsTimeCheck
```
public boolean needsTimeCheck()
```
  - isHot
```
public boolean isHot()
```
  - setHot
```
public void setHot(boolean f)
```
  - getValueExpiryTime
```
public long getValueExpiryTime()
```
    Expiry time or 0.
    
    Specified by:
    
    getValueExpiryTime in interface StorageEntry
  - getCreatedOrUpdated
```
public long getCreatedOrUpdated()
```
    Used for the storage interface.
    
    Specified by:
    
    getCreatedOrUpdated in interface StorageEntry
    
    See Also:
    
    StorageEntry
  - getEntryExpiryTime
```
public long getEntryExpiryTime()
```
    Deprecated. Always returns 0, only to fulfill the StorageEntry interface
    
    Used for the storage interface.
    
    Specified by:
    
    getEntryExpiryTime in interface StorageEntry
    
    See Also:
    
    StorageEntry
  - toString
```
public String toString(HeapCache c)
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - getTask
```
public SimpleTimerTask getTask()
```
  - getPiggyBack
```
public <X> X getPiggyBack(Class<X> _class)
```
  - setTask
```
public void setTask(SimpleTimerTask v)
```
  - setSuppressedLoadExceptionInformation
```
public void setSuppressedLoadExceptionInformation(org.cache2k.integration.ExceptionInformation w)
```
  - resetSuppressedLoadExceptionInformation
```
public void resetSuppressedLoadExceptionInformation()
```
    If the entry carries information about a suppressed exception, clear it.
  - getSuppressedLoadExceptionInformation
```
public org.cache2k.integration.ExceptionInformation getSuppressedLoadExceptionInformation()
```
  - setRefreshProbationNextRefreshTime
```
public void setRefreshProbationNextRefreshTime(long nrt)
```
  - getRefreshProbationNextRefreshTime
```
public long getRefreshProbationNextRefreshTime()
```
  - removeFromList
```
public static void removeFromList(Entry e)
```
  - insertInList
```
public static void insertInList(Entry _head,
                                Entry e)
```
  - insertIntoTailCyclicList
```
public static <E extends Entry> E insertIntoTailCyclicList(E _head,
                                                           E e)
```
  - removeFromCyclicList
```
public static <E extends Entry> E removeFromCyclicList(E _head,
                                                       E e)
```
  - removeFromCyclicList
```
public static Entry removeFromCyclicList(Entry e)
```
  - getCyclicListEntryCount
```
public static int getCyclicListEntryCount(Entry e)
```
  - checkCyclicListIntegrity
```
public static boolean checkCyclicListIntegrity(Entry e)
```
  - setValueOrException
```
public void setValueOrException(T _valueOrException)
```
  - getException
```
public Throwable getException()
```
  - equalsValue
```
public boolean equalsValue(T v)
```
  - getValue
```
@Deprecated
public T getValue()
```
    Deprecated.
  - getValueOrException
```
public T getValueOrException()
```
    The value of the entry or an ExceptionWrapper.
  - getKey
```
public K getKey()
```
  - getKeyObj
```
public K getKeyObj()
```
    Get the raw object reference. Is null for the IntHeapCache.

Class Entry<K,T>

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.cache2k.CacheEntry

Methods inherited from interface org.cache2k.core.storageApi.StorageEntry

Methods inherited from interface org.cache2k.core.operation.ExaminationEntry

Field Detail

EXPIRY_TIME_MIN

next

prev

INITIAL_VALUE

nextRefreshTime

hashCode

another

hitCnt

Constructor Detail

Entry

Entry

Method Detail

setRefreshTime

getRefreshTime

getLastModification

num2processingStateText

getProcessingState

startProcessing

nextProcessingStep

processingDone

getNextRefreshTime

setNextRefreshTime

ensureAbort

isProcessing

waitForProcessing

isGettingRefresh

removedFromList

isRemovedFromReplacementList

isNotYetInsertedInReplacementList

shortCircuit

isVirgin

isDataValid

hasFreshData

setExpiredState

isExpired

setGone

isGone

needsTimeCheck

isHot

setHot

getValueExpiryTime

getCreatedOrUpdated

getEntryExpiryTime

toString

toString

getTask

getPiggyBack

setTask

setSuppressedLoadExceptionInformation

resetSuppressedLoadExceptionInformation

getSuppressedLoadExceptionInformation

setRefreshProbationNextRefreshTime

getRefreshProbationNextRefreshTime

removeFromList

insertInList

insertIntoTailCyclicList

removeFromCyclicList

removeFromCyclicList

getCyclicListEntryCount

checkCyclicListIntegrity

setValueOrException

getException

equalsValue

getValue

getValueOrException

getKey

getKeyObj