Refine search
private <K, V> V loadValue(Cache<K, V> cache, K key, Supplier<V> valueSupplier) { if (replay) { return Optional.ofNullable(cache.getIfPresent(key)) .orElseThrow(() -> new PrestoException(NOT_FOUND, "Missing entry found for key: " + key)); } V value = valueSupplier.get(); cache.put(key, value); return value; }
@Override public V get(K key, Callable<? extends V> valueLoader) throws ExecutionException { return cache.get(key, valueLoader); }
@Override public V remove(K key) throws CacheException { final V old = cache.getIfPresent(key); cache.invalidate(key); return old; }
@Override public void invalidateAll() { cache.invalidateAll(); cache.cleanUp(); }
@Override public synchronized void close() { volatileVertices.clear(); cache.invalidateAll(); cache.cleanUp(); }
@Override public InternalVertex get(final long id, final Retriever<Long, InternalVertex> retriever) { final Long vertexId = id; InternalVertex vertex = cache.getIfPresent(vertexId); if (vertex == null) { InternalVertex newVertex = volatileVertices.get(vertexId); if (newVertex == null) { newVertex = retriever.get(vertexId); } assert newVertex!=null; try { vertex = cache.get(vertexId, new NewVertexCallable(newVertex)); } catch (Exception e) { throw new AssertionError("Should not happen: "+e.getMessage()); } assert vertex!=null; } return vertex; }
public void testAsMapValues_iteratorRemove() { Cache<Integer, Integer> cache = CacheBuilder.newBuilder() .expireAfterWrite(1000, TimeUnit.MILLISECONDS) .ticker(fakeTicker) .build(); cache.put(10, 20); Iterator<Integer> iterator = cache.asMap().values().iterator(); iterator.next(); iterator.remove(); assertEquals(0, cache.size()); } }
public void testInvalidate() { Cache<Integer, Integer> cache = CacheBuilder.newBuilder().build(); cache.put(654, 2675); cache.put(2456, 56); cache.put(2, 15); cache.invalidate(654); assertFalse(cache.asMap().containsKey(654)); assertTrue(cache.asMap().containsKey(2456)); assertTrue(cache.asMap().containsKey(2)); }
public void testAsMapKeySet() { Cache<Integer, Integer> cache = CacheBuilder.newBuilder() .expireAfterWrite(1000, TimeUnit.MILLISECONDS) .ticker(fakeTicker) .build(); cache.put(10, 20); fakeTicker.advance(500, TimeUnit.MILLISECONDS); cache.put(20, 22); cache.put(5, 10); fakeTicker.advance(501, TimeUnit.MILLISECONDS); Set<Integer> foundKeys = new HashSet<>(cache.asMap().keySet()); assertEquals(ImmutableSet.of(20, 5), foundKeys); }
public void testInvalidateAll() { Cache<Integer, Integer> cache = CacheBuilder.newBuilder().build(); cache.put(654, 2675); cache.put(2456, 56); cache.put(2, 15); cache.invalidateAll(); assertFalse(cache.asMap().containsKey(654)); assertFalse(cache.asMap().containsKey(2456)); assertFalse(cache.asMap().containsKey(2)); cache.put(654, 2675); cache.put(2456, 56); cache.put(2, 15); cache.put(1, 3); cache.invalidateAll(ImmutableSet.of(1, 2)); assertFalse(cache.asMap().containsKey(1)); assertFalse(cache.asMap().containsKey(2)); assertTrue(cache.asMap().containsKey(654)); assertTrue(cache.asMap().containsKey(2456)); }
public void testAsMapValues_contains() { Cache<Integer, Integer> cache = CacheBuilder.newBuilder() .expireAfterWrite(1000, TimeUnit.MILLISECONDS) .ticker(fakeTicker) .build(); cache.put(10, 20); fakeTicker.advance(500, TimeUnit.MILLISECONDS); cache.put(20, 22); cache.put(5, 10); fakeTicker.advance(501, TimeUnit.MILLISECONDS); assertTrue(cache.asMap().values().contains(22)); assertTrue(cache.asMap().values().contains(10)); assertFalse(cache.asMap().values().contains(20)); }
static void checkEmpty(Cache<?, ?> cache) { assertEquals(0, cache.size()); assertFalse(cache.asMap().containsKey(null)); assertFalse(cache.asMap().containsKey(6)); assertFalse(cache.asMap().containsValue(null)); assertFalse(cache.asMap().containsValue(6)); checkEmpty(cache.asMap()); }
@Override public void purge(LookupCacheKey purgeKey) { if (purgeKey.isPrefixOnly()) { // If the key to purge only contains a prefix, invalidate all keys with that prefix cache.invalidateAll( cache.asMap().keySet().stream() .filter(lookupCacheKey -> purgeKey.prefix().equals(lookupCacheKey.prefix())) .collect(Collectors.toSet()) ); } else { cache.invalidate(purgeKey); } }
public void testAsMap_containsKey() { Cache<Integer, Integer> cache = CacheBuilder.newBuilder() .expireAfterWrite(20000, TimeUnit.MILLISECONDS) .ticker(fakeTicker) .build(); cache.put(654, 2675); fakeTicker.advance(10000, TimeUnit.MILLISECONDS); cache.put(2456, 56); cache.put(2, 15); fakeTicker.advance(10001, TimeUnit.MILLISECONDS); assertTrue(cache.asMap().containsKey(2)); assertTrue(cache.asMap().containsKey(2456)); assertFalse(cache.asMap().containsKey(654)); }
public void testComputeIfPresent() { cache.put(key, "1"); // simultaneous update for same key, expect count successful updates doParallelCacheOp( count, n -> { cache.asMap().computeIfPresent(key, (k, v) -> v + delimiter + n); }); assertEquals(1, cache.size()); assertThat(cache.getIfPresent(key).split(delimiter)).hasLength(count + 1); }
public void testLoader() throws ExecutionException { final Cache<Integer, Integer> cache = CacheBuilder.newBuilder().build(); Callable<Integer> loader = new Callable<Integer>() { private int i = 0; @Override public Integer call() throws Exception { return ++i; } }; cache.put(0, 10); assertEquals(Integer.valueOf(10), cache.get(0, loader)); assertEquals(Integer.valueOf(1), cache.get(20, loader)); assertEquals(Integer.valueOf(2), cache.get(34, loader)); cache.invalidate(0); assertEquals(Integer.valueOf(3), cache.get(0, loader)); cache.put(0, 10); cache.invalidateAll(); assertEquals(Integer.valueOf(4), cache.get(0, loader)); }
public void testAsMapEntrySet() { Cache<Integer, Integer> cache = CacheBuilder.newBuilder() .expireAfterWrite(1000, TimeUnit.MILLISECONDS) .ticker(fakeTicker) .build(); cache.put(10, 20); fakeTicker.advance(500, TimeUnit.MILLISECONDS); cache.put(20, 22); cache.put(5, 10); fakeTicker.advance(501, TimeUnit.MILLISECONDS); int sum = 0; for (Entry<Integer, Integer> current : cache.asMap().entrySet()) { sum += current.getKey() + current.getValue(); } assertEquals(57, sum); }
@Override public V getIfPresent(K key) { return cache.getIfPresent(key); }