/** * Getter to the cache entry to be removed * * @return the cache entry */ public CacheEntry getEntry() { return new CacheEntry(key, getOldElement()); } }
private BatchAsyncOperation createBatchOprForType(Class operationClass, Collection<SingleAsyncOperation> operations) { if (operationClass == WriteAsyncOperation.class) { final List<Element> elements = new ArrayList<Element>(); for (SingleAsyncOperation operation : operations) { elements.add(operation.getElement()); } return new WriteAllAsyncOperation(elements); } if (operationClass == DeleteAsyncOperation.class) { List<CacheEntry> entries = new ArrayList<CacheEntry>(); for (SingleAsyncOperation operation : operations) { entries.add(new CacheEntry(operation.getKey(), operation.getElement())); } return new DeleteAllAsyncOperation(entries); } throw new RuntimeException("no batch operation created for " + operationClass.getName()); }
private synchronized Element removeInternal(Object key, CacheWriterManager writerManager) throws CacheException { // remove single item. removeObserver.begin(); Element element = (Element) map.remove(key); if (writerManager != null) { writerManager.remove(new CacheEntry(key, element)); } removeObserver.end(RemoveOutcome.SUCCESS); if (element != null) { return element; } else { return null; } }
/** * {@inheritDoc} */ public final Element removeWithWriter(Object key, CacheWriterManager writerManager) throws CacheException { if (key == null) { return null; } // remove single item. Element element; final ReentrantReadWriteLock.WriteLock writeLock = map.lockFor(key).writeLock(); writeLock.lock(); try { element = map.remove(key); if (writerManager != null) { writerManager.remove(new CacheEntry(key, element)); } } finally { writeLock.unlock(); } if (element == null && LOG.isDebugEnabled()) { LOG.debug(cache.getName() + "Cache: Cannot remove entry as key " + key + " was not found"); } return element; }
@Override public void performSingleOperation(CacheWriter cacheWriter) { cacheWriter.delete(new CacheEntry(getKey(), getElement())); }
/** * {@inheritDoc} */ public Element removeWithWriter(Object key, CacheWriterManager writerManager) { int hash = hash(key.hashCode()); final ReentrantReadWriteLock.WriteLock writeLock = segmentFor(hash).writeLock(); writeLock.lock(); try { Element removed = remove(key); if (writerManager != null) { writerManager.remove(new CacheEntry(key, removed)); } return removed; } finally { writeLock.unlock(); } }
/** * {@inheritDoc} */ public Element removeWithWriter(Object key, CacheWriterManager writerManager) throws CacheException { LOG.debug("cache {} removeWithWriter {}", cache.getName(), key); // this forces enlistment so the XA transaction timeout can be propagated to the XA resource getOrCreateTransactionContext(); Element oldElement = getQuietFromUnderlyingStore(key); if (writerManager != null) { writerManager.remove(new CacheEntry(key, null)); } else { cache.getWriterManager().remove(new CacheEntry(key, null)); } return removeInternal(new StoreRemoveCommand(key, oldElement)); }
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())); } }
/** * {@inheritDoc} */ public Element removeWithWriter(final Object key, final CacheWriterManager writerManager) throws CacheException { registerInJtaContext(); try { Element removed = underlyingStore.remove(key); final CacheEntry cacheEntry = new CacheEntry(key, getQuiet(key)); transactionManager.getTransaction().registerSynchronization(new Synchronization() { public void beforeCompletion() { if (writerManager != null) { writerManager.remove(cacheEntry); } else { cache.getWriterManager().remove(cacheEntry); } } public void afterCompletion(int status) { // } }); return removed; } catch (CacheException e) { setRollbackOnly(); throw e; } catch (RollbackException e) { throw new TransactionException("error registering writer synchronization", e); } catch (SystemException e) { throw new TransactionException("error registering writer synchronization", e); } }
/** * {@inheritDoc} */ public Element removeWithWriter(final Object key, final CacheWriterManager writerManager) throws CacheException { if (key == null) { return null; } assertNotTimedOut(); Element removed = remove(key); final CacheEntry cacheEntry = new CacheEntry(key, getQuiet(key)); getCurrentTransactionContext().addListener(new TransactionListener() { public void beforeCommit() { if (writerManager != null) { writerManager.remove(cacheEntry); } else { cache.getWriterManager().remove(cacheEntry); } } public void afterCommit() { } public void afterRollback() { } }); return removed; }
@Override public Element removeWithWriter(Object key, CacheWriterManager writerManager) throws CacheException { if (key == null) { return null; } String pKey = generatePortableKeyFor(key); ToolkitLock lock = getLockForKey(pKey); ToolkitTransaction transaction = transactionController.beginTransaction(transactionType); try { lock.lock(); try { writerManager.remove(new CacheEntry(key, get(key))); return remove(key); } finally { lock.unlock(); } } finally { transaction.commit(); } }
/** * Getter to the cache entry to be removed * * @return the cache entry */ public CacheEntry getEntry() { return new CacheEntry(key, getOldElement()); } }
/** * Getter to the cache entry to be removed * * @return the cache entry */ public CacheEntry getEntry() { return new CacheEntry(key, getOldElement()); } }
/** * Getter to the cache entry to be removed * * @return the cache entry */ public CacheEntry getEntry() { return new CacheEntry(key, getOldElement()); } }
private synchronized Element removeInternal(Object key, CacheWriterManager writerManager) throws CacheException { // remove single item. Element element = (Element) map.remove(key); if (writerManager != null) { writerManager.remove(new CacheEntry(key, element)); } if (element != null) { return element; } else { return null; } }
/** * {@inheritDoc} */ public Element removeWithWriter(Object key, CacheWriterManager writerManager) { Element removed = remove(key); if (writerManager != null) { writerManager.remove(new CacheEntry(key, removed)); } return removed; }
public BatchAsyncOperation createBatchOperation(List<SingleAsyncOperation> operations, SerializationStrategy serializationStrategy) throws ClassNotFoundException, IOException { final List<CacheEntry> entries = new ArrayList<CacheEntry>(); for (SingleAsyncOperation operation : operations) { DeleteAsyncOperation deleteOperation = (DeleteAsyncOperation) operation; entries.add(new CacheEntry(deleteOperation.getKey(serializationStrategy), deleteOperation.createElement(serializationStrategy))); } return new DeleteAllAsyncOperation(entries); }
@Override public Element removeWithWriter( Object key, CacheWriterManager writerManager ) throws CacheException { Element removed = remove( key ); if ( writerManager != null ) { writerManager.remove( new CacheEntry( key, removed ) ); } return removed; }
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 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())); } }