EntryAction (cache2k implementation 1.2.2.Final API)

java.lang.Object
- org.cache2k.core.EntryAction<K,V,R>

All Implemented Interfaces:

EventListener, AsyncCacheLoader.Callback<V>, AsyncCacheWriter.Callback, Progress<K,V,R>
```
public abstract class EntryAction<K,V,R>
extends Object
implements AsyncCacheLoader.Callback<V>, AsyncCacheWriter.Callback, Progress<K,V,R>
```
This is a method object to perform an operation on an entry.

Author:

Jens Wilke

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`EntryAction.ListenerException`
`static class`	`EntryAction.ProcessingFailureException`
`static class`	`EntryAction.StorageReadException`
`static class`	`EntryAction.StorageWriteException`

Constructor Summary

Constructors
Constructor and Description
`EntryAction(HeapCache<K,V> _heapCache, InternalCache<K,V> _userCache, Semantic<K,V,R> op, K k, Entry<K,V> e)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`callListeners()`
`void`	`checkKeepOrRemove()` In case we have a expiry of 0, this means that the entry should not be cached.
`protected org.cache2k.event.CacheEntryCreatedListener<K,V>[]`	`entryCreatedListeners()` Provide the registered listeners for entry creation.
`protected org.cache2k.event.CacheEntryExpiredListener<K,V>[]`	`entryExpiredListeners()`
`protected org.cache2k.event.CacheEntryRemovedListener<K,V>[]`	`entryRemovedListeners()` Provide the registered listeners for entry removal.
`void`	`entryResult(ExaminationEntry e)` Returns a cache entry as result.
`protected org.cache2k.event.CacheEntryUpdatedListener<K,V>[]`	`entryUpdatedListeners()` Provide the registered listeners for entry update.
`void`	`examinationAbort(org.cache2k.CustomizationException t)`
`void`	`examine()`
`void`	`expire(long expiryTime)` Reset expiry to the specified value.
`void`	`expiredImmediatelyAndRemove()`
`void`	`expiredImmediatelyKeepData()`
`void`	`expiryCalculated()`
`void`	`expiryCalculationException(Throwable t)`
`void`	`failure(RuntimeException t)` Failure call on Progress from Semantic.
`void`	`finish()`
`long`	`getCurrentTime()` The current time in millis or the value when it was first called.
`void`	`heapHit(Entry<K,V> e)`
`void`	`heapMiss()`
`boolean`	`isPresent()` Entry has valid data in the cache and is not expired.
`boolean`	`isPresentOrInRefreshProbation()` Same as `Progress.isPresent()` but also true if the entry is in refresh probation.
`boolean`	`isPresentOrMiss()` Entry has valid data in the cache and is not expired.
`void`	`load()` Request that the entry value gets loaded from loader.
`void`	`loadAndExpiryCalculatedMutateAgain()`
`void`	`loadAndMutation()` Request a load, however call update again for the final outcome.
`void`	`loadCompleted()`
`protected org.cache2k.integration.AdvancedCacheLoader<K,V>`	`loader()` Provide the cache loader, if present.
`protected CommonMetrics.Updater`	`metrics()` Provide the standard metrics for updating.
`protected boolean`	`mightHaveListeners()` True if there is any listener defined.
`void`	`mutationAbort(RuntimeException t)`
`void`	`mutationCalculateExpiry()`
`void`	`mutationDone()`
`void`	`mutationMayCallWriter()` Entry mutation, call writer if needed or skip to `mutationMayStore()`
`void`	`mutationMayStore()` Entry mutation, call storage if needed
`void`	`mutationReleaseLockAndStartTimer()`
`void`	`mutationUpdateHeap()`
`void`	`noMutationRequested()`
`void`	`onLoadFailure(Throwable t)`
`void`	`onLoadSuccess(V value)`
`void`	`onWriteFailure(Throwable t)`
`void`	`onWriteSuccess()`
`RuntimeException`	`propagateException(K key, org.cache2k.integration.ExceptionInformation inf)` Needed for the mutable entry getValue() to throw an exception.
`void`	`put(V value)` Update the entry with the new value.
`void`	`putAndSetExpiry(V value, long expiryTime, long refreshTime)` Set new value, skip expiry calculation and set expiry time directly.
`void`	`ready()`
`void`	`refresh()` Same as load but counting statistics as refresh.
`void`	`remove()` The entry will be removed.
`void`	`result(R r)` Sets the operation result.
`void`	`retrieveDataFromHeap()`
`void`	`reviveRefreshedEntry(long nrt)`
`void`	`skipStore()`
`void`	`skipWritingForException()`
`void`	`skipWritingNoWriter()`
`protected abstract TimingHandler<K,V>`	`timing()`
`void`	`updateDidNotTriggerDifferentMutationStoreLoadedValue()`
`void`	`updateMutationStatistics()`
`void`	`updateOnlyReadStatistics()`
`void`	`wantData()` Requests that the cache content for an entry will be provided.
`void`	`wantMutation()` The entry gets locked for mutation.
`protected org.cache2k.integration.CacheWriter<K,V>`	`writer()` Provide the writer, default null.

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

- Constructor Detail
  - EntryAction
```
public EntryAction(HeapCache<K,V> _heapCache,
                   InternalCache<K,V> _userCache,
                   Semantic<K,V,R> op,
                   K k,
                   Entry<K,V> e)
```
- Method Detail
  - loader
```
protected org.cache2k.integration.AdvancedCacheLoader<K,V> loader()
```
    Provide the cache loader, if present.
  - metrics
```
protected CommonMetrics.Updater metrics()
```
    Provide the standard metrics for updating.
  - writer
```
protected org.cache2k.integration.CacheWriter<K,V> writer()
```
    Provide the writer, default null.
  - mightHaveListeners
```
protected boolean mightHaveListeners()
```
    True if there is any listener defined. Default false.
  - entryCreatedListeners
```
protected org.cache2k.event.CacheEntryCreatedListener<K,V>[] entryCreatedListeners()
```
    Provide the registered listeners for entry creation.
  - entryUpdatedListeners
```
protected org.cache2k.event.CacheEntryUpdatedListener<K,V>[] entryUpdatedListeners()
```
    Provide the registered listeners for entry update.
  - entryRemovedListeners
```
protected org.cache2k.event.CacheEntryRemovedListener<K,V>[] entryRemovedListeners()
```
    Provide the registered listeners for entry removal.
  - entryExpiredListeners
```
protected org.cache2k.event.CacheEntryExpiredListener<K,V>[] entryExpiredListeners()
```
  - timing
```
protected abstract TimingHandler<K,V> timing()
```
  - getCurrentTime
```
public long getCurrentTime()
```
    Description copied from interface: Progress
    
    The current time in millis or the value when it was first called.
    
    Specified by:
    
    getCurrentTime in interface Progress<K,V,R>
  - isPresent
```
public boolean isPresent()
```
    Description copied from interface: Progress
    
    Entry has valid data in the cache and is not expired. This is used for operations that do not want to access the value.
    
    Specified by:
    
    isPresent in interface Progress<K,V,R>
  - isPresentOrInRefreshProbation
```
public boolean isPresentOrInRefreshProbation()
```
    Description copied from interface: Progress
    
    Same as Progress.isPresent() but also true if the entry is in refresh probation.
    
    Specified by:
    
    isPresentOrInRefreshProbation in interface Progress<K,V,R>
  - isPresentOrMiss
```
public boolean isPresentOrMiss()
```
    Description copied from interface: Progress
    
    Entry has valid data in the cache and is not expired. Counts a miss, if no entry is available, this is used for operations that do want to access the value.
    
    Specified by:
    
    isPresentOrMiss in interface Progress<K,V,R>
  - wantData
```
public void wantData()
```
    Description copied from interface: Progress
    
    Requests that the cache content for an entry will be provided. If the cache is tiered, the data will be read into the heap cache. Last command of semantic method. Calls back on Semantic.examine(Progress, ExaminationEntry)
    
    Specified by:
    
    wantData in interface Progress<K,V,R>
  - retrieveDataFromHeap
```
public void retrieveDataFromHeap()
```
  - heapMiss
```
public void heapMiss()
```
  - heapHit
```
public void heapHit(Entry<K,V> e)
```
  - examine
```
public void examine()
```
  - wantMutation
```
public void wantMutation()
```
    Description copied from interface: Progress
    
    The entry gets locked for mutation. Last command of semantic method. Calls back on Semantic.update(Progress, ExaminationEntry)
    
    Specified by:
    
    wantMutation in interface Progress<K,V,R>
  - finish
```
public void finish()
```
  - loadAndMutation
```
public void loadAndMutation()
```
    Description copied from interface: Progress
    
    Request a load, however call update again for the final outcome.
    
    Specified by:
    
    loadAndMutation in interface Progress<K,V,R>
  - refresh
```
public void refresh()
```
    Description copied from interface: Progress
    
    Same as load but counting statistics as refresh.
    
    Specified by:
    
    refresh in interface Progress<K,V,R>
  - load
```
public void load()
```
    Description copied from interface: Progress
    
    Request that the entry value gets loaded from loader. Last command of semantic method. By default the loaded value will be set as operation result. Defined in Semantic.Base
    
    Specified by:
    
    load in interface Progress<K,V,R>
  - reviveRefreshedEntry
```
public void reviveRefreshedEntry(long nrt)
```
  - onLoadSuccess
```
public void onLoadSuccess(V value)
```
    Specified by:
    
    onLoadSuccess in interface AsyncCacheLoader.Callback<V>
  - onLoadFailure
```
public void onLoadFailure(Throwable t)
```
    Specified by:
    
    onLoadFailure in interface AsyncCacheLoader.Callback<V>
  - loadCompleted
```
public void loadCompleted()
```
  - result
```
public void result(R r)
```
    Description copied from interface: Progress
    
    Sets the operation result.
    
    Specified by:
    
    result in interface Progress<K,V,R>
  - entryResult
```
public void entryResult(ExaminationEntry e)
```
    Description copied from interface: Progress
    
    Returns a cache entry as result. The entry will be copied before returning.
    
    Specified by:
    
    entryResult in interface Progress<K,V,R>
  - propagateException
```
public RuntimeException propagateException(K key,
                                           org.cache2k.integration.ExceptionInformation inf)
```
    Description copied from interface: Progress
    
    Needed for the mutable entry getValue() to throw an exception.
    
    Specified by:
    
    propagateException in interface Progress<K,V,R>
  - put
```
public void put(V value)
```
    Description copied from interface: Progress
    
    Update the entry with the new value. Last command of semantic method.
    
    Specified by:
    
    put in interface Progress<K,V,R>
  - remove
```
public void remove()
```
    Description copied from interface: Progress
    
    The entry will be removed. Last command of semantic method.
    
    Specified by:
    
    remove in interface Progress<K,V,R>
  - expire
```
public void expire(long expiryTime)
```
    Description copied from interface: Progress
    
    Reset expiry to the specified value. Don't change the value.
    
    Specified by:
    
    expire in interface Progress<K,V,R>
  - putAndSetExpiry
```
public void putAndSetExpiry(V value,
                            long expiryTime,
                            long refreshTime)
```
    Description copied from interface: Progress
    
    Set new value, skip expiry calculation and set expiry time directly.
    
    Specified by:
    
    putAndSetExpiry in interface Progress<K,V,R>
  - mutationCalculateExpiry
```
public void mutationCalculateExpiry()
```
  - expiryCalculationException
```
public void expiryCalculationException(Throwable t)
```
  - expiryCalculated
```
public void expiryCalculated()
```
  - loadAndExpiryCalculatedMutateAgain
```
public void loadAndExpiryCalculatedMutateAgain()
```
  - updateDidNotTriggerDifferentMutationStoreLoadedValue
```
public void updateDidNotTriggerDifferentMutationStoreLoadedValue()
```
  - mutationMayCallWriter
```
public void mutationMayCallWriter()
```
    Entry mutation, call writer if needed or skip to mutationMayStore()
  - onWriteSuccess
```
public void onWriteSuccess()
```
    Specified by:
    
    onWriteSuccess in interface AsyncCacheWriter.Callback
  - onWriteFailure
```
public void onWriteFailure(Throwable t)
```
    Specified by:
    
    onWriteFailure in interface AsyncCacheWriter.Callback
  - skipWritingForException
```
public void skipWritingForException()
```
  - skipWritingNoWriter
```
public void skipWritingNoWriter()
```
  - checkKeepOrRemove
```
public void checkKeepOrRemove()
```
    In case we have a expiry of 0, this means that the entry should not be cached. If there is a valid entry, we remove it if we do not keep the data.
  - expiredImmediatelyKeepData
```
public void expiredImmediatelyKeepData()
```
  - expiredImmediatelyAndRemove
```
public void expiredImmediatelyAndRemove()
```
  - mutationUpdateHeap
```
public void mutationUpdateHeap()
```
  - mutationMayStore
```
public void mutationMayStore()
```
    Entry mutation, call storage if needed
  - skipStore
```
public void skipStore()
```
  - callListeners
```
public void callListeners()
```
  - mutationReleaseLockAndStartTimer
```
public void mutationReleaseLockAndStartTimer()
```
  - updateMutationStatistics
```
public void updateMutationStatistics()
```
  - updateOnlyReadStatistics
```
public void updateOnlyReadStatistics()
```
  - failure
```
public void failure(RuntimeException t)
```
    Failure call on Progress from Semantic.
    
    Specified by:
    
    failure in interface Progress<K,V,R>
  - examinationAbort
```
public void examinationAbort(org.cache2k.CustomizationException t)
```
  - mutationAbort
```
public void mutationAbort(RuntimeException t)
```
  - mutationDone
```
public void mutationDone()
```
  - noMutationRequested
```
public void noMutationRequested()
```
  - ready
```
public void ready()
```

Class EntryAction<K,V,R>

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

EntryAction

Method Detail

loader

metrics

writer

mightHaveListeners

entryCreatedListeners

entryUpdatedListeners

entryRemovedListeners

entryExpiredListeners

timing

getCurrentTime

isPresent

isPresentOrInRefreshProbation

isPresentOrMiss

wantData

retrieveDataFromHeap

heapMiss

heapHit

examine

wantMutation

finish

loadAndMutation

refresh

load

reviveRefreshedEntry

onLoadSuccess

onLoadFailure

loadCompleted

result

entryResult

propagateException

put

remove

expire

putAndSetExpiry

mutationCalculateExpiry

expiryCalculationException

expiryCalculated

loadAndExpiryCalculatedMutateAgain

updateDidNotTriggerDifferentMutationStoreLoadedValue

mutationMayCallWriter

onWriteSuccess

onWriteFailure

skipWritingForException

skipWritingNoWriter

checkKeepOrRemove

expiredImmediatelyKeepData

expiredImmediatelyAndRemove

mutationUpdateHeap

mutationMayStore

skipStore

callListeners

mutationReleaseLockAndStartTimer

updateMutationStatistics

updateOnlyReadStatistics

failure

examinationAbort

mutationAbort

mutationDone

noMutationRequested

ready