Entry (cache2k core package 0.21.1 API)

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

All Implemented Interfaces:

CacheEntry<K,T>, MutableCacheEntry<K,T>, StorageEntry

Direct Known Subclasses:

ArcCache.Entry, LruCache.Entry
```
public class Entry<E extends Entry,K,T>
extends Object
implements MutableCacheEntry<K,T>, StorageEntry
```
The cache entry. This is a combined hashtable entry with hashCode and and collision list (other field) and it contains a double linked list (next and previous) for the eviction algorithm.

Author:

Jens Wilke

Field Summary

Fields
Modifier and Type	Field and Description
`Entry<E,K,T>`	`another` Hash implementation: Link to another entry in the same hash table slot when the hash code collides.
`long`	`fetchedTime` Time the entry was last updated by put or by fetching it from the cache source.
`int`	`hashCode` Hash implementation: the calculated, modified hash code, retrieved from the key when the entry is inserted in the cache
`K`	`key`
`E`	`next` Lru list: pointer to next element or list head
`long`	`nextRefreshTime` Contains the next time a refresh has to occur.
`E`	`prev` Lru list: pointer to previous element or list head
`BaseCache.MyTimerTask`	`task`
`T`	`value`

Constructor Summary

Constructors
Constructor and Description

Entry()

Constructors
Constructor and Description
`Entry()`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`ensureFetchAbort(boolean _finished)` If fetch is not stopped, abort and make entry invalid.
`boolean`	`equals(Object obj)` Cache entries always have the object identity as equals method.
`void`	`finishFetch(long _nextRefreshTime)`
`long`	`getCreatedOrUpdated()` Used for the storage interface.
`long`	`getEntryExpiryTime()` Used for the storage interface.
`Throwable`	`getException()`
`K`	`getKey()` Key of the stored entry
`long`	`getLastModification()`
`T`	`getValue()`
`long`	`getValueExpiryTime()` Expiry time or 0.
`Object`	`getValueOrException()` Used for the storage interface.
`boolean`	`hasException()`
`boolean`	`hasFreshData()` Returns true if the entry has a valid value and is fresh / not expired.
`boolean`	`hasFreshData(long now)` Same as `hasFreshData()`, optimization if current time is known.
`boolean`	`hasFreshData(long now, long _nextRefreshTime)`
`boolean`	`isBeeingReput()`
`boolean`	`isDataValidState()` The entry value was fetched and is valid, which means it can be returned by the cache.
`boolean`	`isDirty()` Memory entry needs to be send to the storage.
`boolean`	`isExpiredState()` The entry expired, but still in the cache.
`boolean`	`isFetchInProgress()`
`boolean`	`isFetchNextTimeState()`
`boolean`	`isGettingRefresh()`
`boolean`	`isLoadedNonValid()`
`boolean`	`isLoadedNonValidAndFetch()`
`boolean`	`isPinned()` Entry is not allowed to be evicted
`boolean`	`isRemovedFromReplacementList()` Check that this entry is removed from the list, may be used in assertions.
`boolean`	`isRemovedState()`
`boolean`	`isStale()`
`boolean`	`isVirgin()`
`boolean`	`needsTimeCheck()`
`void`	`removedFromList()` Reset next as a marker for `isRemovedFromReplacementList()`
`void`	`resetDirty()`
`void`	`setException(Throwable exception)`
`void`	`setExpiredState()` Entry is kept in the cache but has expired
`void`	`setGettingRefresh()`
`void`	`setLastModification(long t)`
`void`	`setLastModificationFromStorage(long t)`
`void`	`setLoadedNonValidAndFetch()`
`void`	`setRemovedState()`
`void`	`setStale()`
`void`	`setValue(T v)`
`E`	`shortCircuit()`
`void`	`startFetch()` Starts long operation on entry.
`String`	`toString()`
`void`	`waitForFetch()`

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

- Field Detail
  - task
```
public BaseCache.MyTimerTask task
```
  - fetchedTime
```
public long fetchedTime
```
    Time the entry was last updated by put or by fetching it from the cache source. The time is the time in millis times 2. A set bit 1 means the entry is fetched from the storage and not modified since then.
  - nextRefreshTime
```
public volatile long nextRefreshTime
```
    Contains the next time a refresh has to occur. Low values have a special meaning, see defined constants. Negative values means the refresh time was expired, and we need to check the time.
  - key
```
public K key
```
  - value
```
public volatile T value
```
  - hashCode
```
public int hashCode
```
    Hash implementation: the calculated, modified hash code, retrieved from the key when the entry is inserted in the cache
    
    See Also:
    BaseCache.modifiedHash(int)
  - another
```
public Entry<E extends Entry,K,T> another
```
    Hash implementation: Link to another entry in the same hash table slot when the hash code collides.
  - next
```
public E extends Entry next
```
    Lru list: pointer to next element or list head
  - prev
```
public E extends Entry prev
```
    Lru list: pointer to previous element or list head
- Constructor Detail
  - Entry
```
public Entry()
```
- Method Detail
  - setLastModification
```
public void setLastModification(long t)
```
  - isDirty
```
public boolean isDirty()
```
    Memory entry needs to be send to the storage.
  - setLastModificationFromStorage
```
public void setLastModificationFromStorage(long t)
```
  - resetDirty
```
public void resetDirty()
```
  - 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.
  - shortCircuit
```
public E shortCircuit()
```
  - isVirgin
```
public final boolean isVirgin()
```
  - isFetchNextTimeState
```
public final boolean isFetchNextTimeState()
```
  - isDataValidState
```
public final boolean isDataValidState()
```
    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.
  - startFetch
```
public void startFetch()
```
    Starts long operation on entry. Pins the entry in the cache.
  - finishFetch
```
public void finishFetch(long _nextRefreshTime)
```
  - ensureFetchAbort
```
public void ensureFetchAbort(boolean _finished)
```
    If fetch is not stopped, abort and make entry invalid. This is a safety measure, since during entry processing an exceptions may happen. This can happen regularly e.g. if storage is set to read only and a cache put is made.
  - isPinned
```
public boolean isPinned()
```
    Entry is not allowed to be evicted
  - isFetchInProgress
```
public boolean isFetchInProgress()
```
  - waitForFetch
```
public void waitForFetch()
```
  - hasFreshData
```
public final boolean hasFreshData()
```
    Returns true if the entry has a valid value and is fresh / not expired.
  - hasFreshData
```
public final boolean hasFreshData(long now)
```
    Same as hasFreshData(), optimization if current time is known.
  - hasFreshData
```
public final boolean hasFreshData(long now,
                   long _nextRefreshTime)
```
  - isLoadedNonValid
```
public boolean isLoadedNonValid()
```
  - setLoadedNonValidAndFetch
```
public void setLoadedNonValidAndFetch()
```
  - isLoadedNonValidAndFetch
```
public boolean isLoadedNonValidAndFetch()
```
  - setExpiredState
```
public void setExpiredState()
```
    Entry is kept in the cache but has expired
  - isExpiredState
```
public boolean isExpiredState()
```
    The entry expired, but still in the cache. This may happen if BaseCache.hasKeepAfterExpired() is true.
  - setRemovedState
```
public void setRemovedState()
```
  - isRemovedState
```
public boolean isRemovedState()
```
  - setGettingRefresh
```
public void setGettingRefresh()
```
  - isGettingRefresh
```
public boolean isGettingRefresh()
```
  - isBeeingReput
```
public boolean isBeeingReput()
```
  - needsTimeCheck
```
public boolean needsTimeCheck()
```
  - isStale
```
public boolean isStale()
```
  - setStale
```
public void setStale()
```
  - hasException
```
public boolean hasException()
```
  - getException
```
public Throwable getException()
```
    Specified by:
    
    getException in interface CacheEntry<K,T>
  - setException
```
public void setException(Throwable exception)
```
    Specified by:
    
    setException in interface MutableCacheEntry<K,T>
  - getValue
```
public T getValue()
```
    Specified by:
    
    getValue in interface CacheEntry<K,T>
  - setValue
```
public void setValue(T v)
```
    Specified by:
    
    setValue in interface MutableCacheEntry<K,T>
  - getKey
```
public K getKey()
```
    Description copied from interface: StorageEntry
    
    Key of the stored entry
    
    Specified by:
    
    getKey in interface CacheEntry<K,T>
    
    Specified by:
    
    getKey in interface StorageEntry
  - getLastModification
```
public long getLastModification()
```
    Specified by:
    
    getLastModification in interface CacheEntry<K,T>
  - getValueExpiryTime
```
public long getValueExpiryTime()
```
    Expiry time or 0.
    
    Specified by:
    
    getValueExpiryTime in interface StorageEntry
  - getValueOrException
```
public Object getValueOrException()
```
    Used for the storage interface.
    
    Specified by:
    
    getValueOrException in interface StorageEntry
    
    See Also:
    StorageEntry
  - getCreatedOrUpdated
```
public long getCreatedOrUpdated()
```
    Used for the storage interface.
    
    Specified by:
    
    getCreatedOrUpdated in interface StorageEntry
    
    See Also:
    StorageEntry
  - getEntryExpiryTime
```
public long getEntryExpiryTime()
```
    Used for the storage interface.
    
    Specified by:
    
    getEntryExpiryTime in interface StorageEntry
    
    See Also:
    StorageEntry
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - equals
```
public final boolean equals(Object obj)
```
    Cache entries always have the object identity as equals method.
    
    Overrides:
    
    equals in class Object

Class Entry<E extends Entry,K,T>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

task

fetchedTime

nextRefreshTime

key

value

hashCode

another

next

prev

Constructor Detail

Entry

Method Detail

setLastModification

isDirty

setLastModificationFromStorage

resetDirty

removedFromList

isRemovedFromReplacementList

shortCircuit

isVirgin

isFetchNextTimeState

isDataValidState

startFetch

finishFetch

ensureFetchAbort

isPinned

isFetchInProgress

waitForFetch

hasFreshData

hasFreshData

hasFreshData

isLoadedNonValid

setLoadedNonValidAndFetch

isLoadedNonValidAndFetch

setExpiredState

isExpiredState

setRemovedState

isRemovedState

setGettingRefresh

isGettingRefresh

isBeeingReput

needsTimeCheck

isStale

setStale

hasException

getException

setException

getValue

setValue

getKey

getLastModification

getValueExpiryTime

getValueOrException

getCreatedOrUpdated

getEntryExpiryTime

toString

equals