@Override public void notifyElementUpdated(Ehcache cache, Element element) throws CacheException { if (cache.equals(ehCache)) { delegate.onEntryUpdated(element.getObjectKey(), element.getObjectValue()); } }
@Override public void notifyElementExpired(Ehcache cache, Element element) { if (cache.equals(ehCache)) { delegate.onEntryExpired(element.getObjectKey()); } }
@Override public void notifyElementRemoved(Ehcache cache, Element element) throws CacheException { if (cache.equals(ehCache)) { delegate.onEntryRemoved(element.getObjectKey()); } }
@Override public void notifyElementEvicted(Ehcache cache, Element element) { if (cache.equals(ehCache)) { delegate.onEntryExpired(element.getObjectKey()); } }
@Override public void notifyElementPut(Ehcache cache, Element element) throws CacheException { if (cache.equals(ehCache)) { delegate.onEntryCreated(element.getObjectKey(), element.getObjectValue()); } }
/** * Create a Placeholder wrapping the given element and key. * * @param element the element to wrap */ Placeholder(Element element) { super(DiskStorageFactory.this); this.key = element.getObjectKey(); this.element = element; }
private void possiblyTriggerRefresh(Element elem, long timeToRefreshMillis) { if (checkForRefresh(elem, System.currentTimeMillis(), timeToRefreshMillis)) { // now add the key to the queue. smallest overhead we could get. refreshWorkQueue.offer(elem.getObjectKey()); } }
@Override public boolean putWithWriter(final Element element, final CacheWriterManager writerManager) throws CacheException { try { return authoritativeTier.putWithWriter(element, writerManager); } finally { cachingTier.remove(element.getObjectKey()); } }
@Override public Element putIfAbsent(final Element element) throws NullPointerException { Element previous = null; try { previous = authoritativeTier.putIfAbsent(element); } finally { if (previous == null) { cachingTier.remove(element.getObjectKey()); } } return previous; }
/** * Find a "relatively" unused element. * * @param elementJustAdded the element added by the action calling this check * @return the element chosen as candidate for eviction */ private Element findEvictionCandidate(final Element elementJustAdded) { Object objectKey = elementJustAdded != null ? elementJustAdded.getObjectKey() : null; Element[] elements = sampleElements(objectKey); // this can return null. Let the cache get bigger by one. return policy.selectedBasedOnPolicy(elements, elementJustAdded); }
/** * {@inheritDoc} */ public Element replace(Element element) throws NullPointerException { Object key = element.getObjectKey(); int hash = hash(key.hashCode()); return segmentFor(hash).replace(key, hash, element); }
/** * {@inheritDoc} */ public Element removeElement(Element element, ElementValueComparator comparator) throws NullPointerException { Object key = element.getObjectKey(); int hash = hash(key.hashCode()); return segmentFor(hash).remove(key, hash, element, comparator); }
/** * {@inheritDoc} */ public Element putIfAbsent(Element element) throws NullPointerException { Object key = element.getObjectKey(); int hash = hash(key.hashCode()); return segmentFor(hash).put(key, hash, element, true, false); }
/** * Check if adding an element won't provoke an eviction. * * @param element the element * @return true if the element can be added without provoking an eviction. */ public final boolean canPutWithoutEvicting(Element element) { if (element == null) { return true; } return !isFull() && poolAccessor.canAddWithoutEvicting(element.getObjectKey(), element.getObjectValue(), map.storedObject(element)); }
/** * {@inheritDoc} */ public boolean put(Element element) throws CacheException { LOG.debug("cache {} put {}", cache.getName(), element); // this forces enlistment so the XA transaction timeout can be propagated to the XA resource getOrCreateTransactionContext(); Element oldElement = getQuietFromUnderlyingStore(element.getObjectKey()); return internalPut(new StorePutCommand(oldElement, element)); }
/** * Create a new write operation for a particular element and creation time * * @param element the element to write * @param creationTime the creation time of the operation */ public WriteOperation(Element element, long creationTime) { this.element = new Element(element.getObjectKey(), element.getObjectValue(), element.getVersion(), element.getCreationTime(), element.getLastAccessTime(), element.getHitCount(), false, element.getTimeToLive(), element.getTimeToIdle(), element.getLastUpdateTime()); this.creationTime = creationTime; }
private CacheEntry duplicateCacheEntryElement(CacheEntry entry) { if (null == entry.getElement()) { return entry; } else { Element element = entry.getElement(); return new CacheEntry(entry.getKey(), new Element(element.getObjectKey(), element.getObjectValue(), element.getVersion(), element.getCreationTime(), element.getLastAccessTime(), element.getHitCount(), false, element.getTimeToLive(), element.getTimeToIdle(), element.getLastUpdateTime())); } }
private Element removeElementEventual(Element element, ElementValueComparator comparator) { String pKey = generatePortableKeyFor(element.getKey()); ElementData value = valueModeHandler.createElementData(element); if (backend.remove(pKey, value, new ElementValueComparatorToolkitWrapper(element.getObjectKey(), comparator))) { return element; } else { return null; } }
private Element replaceEventual(Element element) { String pKey = generatePortableKeyFor(element.getKey()); ElementData value = valueModeHandler.createElementData(element); return valueModeHandler.createElement(element.getObjectKey(), backend.replace(pKey, value)); }
private boolean replaceEventual(Element old, Element element, ElementValueComparator comparator) { String pKey = generatePortableKeyFor(element.getKey()); ElementData oldValue = valueModeHandler.createElementData(old); ElementData value = valueModeHandler.createElementData(element); return backend.replace(pKey, oldValue, value, new ElementValueComparatorToolkitWrapper(old.getObjectKey(), comparator)); }