/** * The assumption is that this method will be invoked only by cache.putAll and cache.removeAll methods. */ @Override public Map<K, ValueHolder<V>> bulkCompute(final Set<? extends K> keys, final Function<Iterable<? extends Map.Entry<? extends K, ? extends V>>, Iterable<? extends Map.Entry<? extends K, ? extends V>>> remappingFunction) throws StoreAccessException { Map<K, ValueHolder<V>> valueHolderMap = new HashMap<>(); if(remappingFunction instanceof Ehcache.PutAllFunction) { Ehcache.PutAllFunction<K, V> putAllFunction = (Ehcache.PutAllFunction<K, V>)remappingFunction; Map<K, V> entriesToRemap = putAllFunction.getEntriesToRemap(); for(Map.Entry<K, V> entry: entriesToRemap.entrySet()) { PutStatus putStatus = silentPut(entry.getKey(), entry.getValue()); if(putStatus == PutStatus.PUT) { putAllFunction.getActualPutCount().incrementAndGet(); valueHolderMap.put(entry.getKey(), new ClusteredValueHolder<>(entry.getValue())); } } } else if(remappingFunction instanceof Ehcache.RemoveAllFunction) { Ehcache.RemoveAllFunction<K, V> removeAllFunction = (Ehcache.RemoveAllFunction<K, V>)remappingFunction; for (K key : keys) { boolean removed = silentRemove(key); if(removed) { removeAllFunction.getActualRemoveCount().incrementAndGet(); } } } else { throw new UnsupportedOperationException("This bulkCompute method is not yet capable of handling generic computation functions"); } return valueHolderMap; }
@Override public ValueHolder<V> putIfAbsent(final K key, final V value, Consumer<Boolean> put) throws StoreAccessException { putIfAbsentObserver.begin(); V result = silentPutIfAbsent(key, value); if(result == null) { putIfAbsentObserver.end(StoreOperationOutcomes.PutIfAbsentOutcome.PUT); return null; } else { putIfAbsentObserver.end(StoreOperationOutcomes.PutIfAbsentOutcome.HIT); return new ClusteredValueHolder<>(result); } }
@Override public ValueHolder<V> replace(final K key, final V value) throws StoreAccessException { replaceObserver.begin(); V result = silentReplace(key, value); if(result == null) { replaceObserver.end(StoreOperationOutcomes.ReplaceOutcome.MISS); return null; } else { replaceObserver.end(StoreOperationOutcomes.ReplaceOutcome.REPLACED); return new ClusteredValueHolder<>(result); } }
long expirationTime = resolvedChain.getExpirationTime(); if (expirationTime == Long.MAX_VALUE) { holder = new ClusteredValueHolder<>(value); } else { holder = new ClusteredValueHolder<>(value, expirationTime); return new ClusteredValueHolder<>(value); } finally { unlock(hash);
protected ValueHolder<V> getInternal(K key) throws StoreAccessException, TimeoutException { ClusteredValueHolder<V> holder = null; try { Chain chain = storeProxy.get(extractLongKey(key)); if(!chain.isEmpty()) { ResolvedChain<K, V> resolvedChain = resolver.resolve(chain, key, timeSource.getTimeMillis()); if (resolvedChain.isCompacted()) { Chain compactedChain = resolvedChain.getCompactedChain(); storeProxy.replaceAtHead(extractLongKey(key), chain, compactedChain); } Result<K, V> resolvedResult = resolvedChain.getResolvedResult(key); if (resolvedResult != null) { V value = resolvedResult.getValue(); long expirationTime = resolvedChain.getExpirationTime(); if (expirationTime == Long.MAX_VALUE) { holder = new ClusteredValueHolder<>(value); } else { holder = new ClusteredValueHolder<>(value, expirationTime); } } } } catch (RuntimeException re) { throw handleException(re); } return holder; }
return new ClusteredValueHolder<>(value); } finally { if (!unlocked) {
/** * The assumption is that this method will be invoked only by cache.putAll and cache.removeAll methods. */ @Override public Map<K, ValueHolder<V>> bulkCompute(final Set<? extends K> keys, final Function<Iterable<? extends Map.Entry<? extends K, ? extends V>>, Iterable<? extends Map.Entry<? extends K, ? extends V>>> remappingFunction) throws StoreAccessException { Map<K, ValueHolder<V>> valueHolderMap = new HashMap<>(); if(remappingFunction instanceof Ehcache.PutAllFunction) { Ehcache.PutAllFunction<K, V> putAllFunction = (Ehcache.PutAllFunction<K, V>)remappingFunction; Map<K, V> entriesToRemap = putAllFunction.getEntriesToRemap(); for(Map.Entry<K, V> entry: entriesToRemap.entrySet()) { PutStatus putStatus = silentPut(entry.getKey(), entry.getValue()); if(putStatus == PutStatus.PUT) { putAllFunction.getActualPutCount().incrementAndGet(); valueHolderMap.put(entry.getKey(), new ClusteredValueHolder<>(entry.getValue())); } } } else if(remappingFunction instanceof Ehcache.RemoveAllFunction) { Ehcache.RemoveAllFunction<K, V> removeAllFunction = (Ehcache.RemoveAllFunction<K, V>)remappingFunction; for (K key : keys) { boolean removed = silentRemove(key); if(removed) { removeAllFunction.getActualRemoveCount().incrementAndGet(); } } } else { throw new UnsupportedOperationException("This compute method is not yet capable of handling generic computation functions"); } return valueHolderMap; }
private ValueHolder<V> getInternal(K key) throws StoreAccessException, TimeoutException { ClusteredValueHolder<V> holder = null; try { Chain chain = storeProxy.get(extractLongKey(key)); if(!chain.isEmpty()) { ResolvedChain<K, V> resolvedChain = resolver.resolve(chain, key, timeSource.getTimeMillis()); if (resolvedChain.isCompacted()) { Chain compactedChain = resolvedChain.getCompactedChain(); storeProxy.replaceAtHead(extractLongKey(key), chain, compactedChain); } Result<K, V> resolvedResult = resolvedChain.getResolvedResult(key); if (resolvedResult != null) { V value = resolvedResult.getValue(); long expirationTime = resolvedChain.getExpirationTime(); if (expirationTime == Long.MAX_VALUE) { holder = new ClusteredValueHolder<>(value); } else { holder = new ClusteredValueHolder<>(value, expirationTime); } } } } catch (RuntimeException re) { throw handleException(re); } return holder; }
@Override public ValueHolder<V> putIfAbsent(final K key, final V value) throws StoreAccessException { putIfAbsentObserver.begin(); try { PutIfAbsentOperation<K, V> operation = new PutIfAbsentOperation<>(key, value, timeSource.getTimeMillis()); ByteBuffer payload = codec.encode(operation); long extractedKey = extractLongKey(key); Chain chain = storeProxy.getAndAppend(extractedKey, payload); ResolvedChain<K, V> resolvedChain = resolver.resolve(chain, key, timeSource.getTimeMillis()); if (resolvedChain.getCompactionCount() > chainCompactionLimit) { Chain compactedChain = resolvedChain.getCompactedChain(); storeProxy.replaceAtHead(extractedKey, chain, compactedChain); } Result<K, V> result = resolvedChain.getResolvedResult(key); if(result == null) { putIfAbsentObserver.end(StoreOperationOutcomes.PutIfAbsentOutcome.PUT); return null; } else { putIfAbsentObserver.end(StoreOperationOutcomes.PutIfAbsentOutcome.HIT); return new ClusteredValueHolder<>(result.getValue()); } } catch (Exception re) { throw handleException(re); } }
@Override public ValueHolder<V> replace(final K key, final V value) throws StoreAccessException { replaceObserver.begin(); try { ReplaceOperation<K, V> operation = new ReplaceOperation<>(key, value, timeSource.getTimeMillis()); ByteBuffer payload = codec.encode(operation); long extractedKey = extractLongKey(key); Chain chain = storeProxy.getAndAppend(extractedKey, payload); ResolvedChain<K, V> resolvedChain = resolver.resolve(chain, key, timeSource.getTimeMillis()); if (resolvedChain.getCompactionCount() > chainCompactionLimit) { Chain compactedChain = resolvedChain.getCompactedChain(); storeProxy.replaceAtHead(extractedKey, chain, compactedChain); } Result<K, V> result = resolvedChain.getResolvedResult(key); if(result == null) { replaceObserver.end(StoreOperationOutcomes.ReplaceOutcome.MISS); return null; } else { replaceObserver.end(StoreOperationOutcomes.ReplaceOutcome.REPLACED); return new ClusteredValueHolder<>(result.getValue()); } } catch (Exception re) { throw handleException(re); } }