try (Stream<CacheEntry<Object, Object>> stream = cache.getAdvancedCache().withFlags(Flag.CACHE_MODE_LOCAL) .cacheEntrySet().stream()) { Iterator<CacheEntry<Object, Object>> iterator = stream.filter(CacheFilters.predicate(filter)).iterator(); while (iterator.hasNext()) { CacheEntry<Object, Object> next = iterator.next();
try (Stream<CacheEntry<Object, Object>> stream = unwrappedCache.getAdvancedCache().withFlags(Flag.CACHE_MODE_LOCAL) .cacheEntrySet().stream()) { Iterator<CacheEntry<Object, Object>> iterator = stream.filter(CacheFilters.predicate(filter)).iterator(); while (iterator.hasNext()) { CacheEntry<Object, Object> next = iterator.next();
@Test public void testFilterWithStoreAsBinary() throws InterruptedException, ExecutionException, TimeoutException { Cache<MagicKey, String> cache0 = cache(0, CACHE_NAME); Cache<MagicKey, String> cache1 = cache(1, CACHE_NAME); Cache<MagicKey, String> cache2 = cache(2, CACHE_NAME); Map<MagicKey, String> originalValues = new HashMap<>(); originalValues.put(new MagicKey(cache0), "cache0"); originalValues.put(new MagicKey(cache1), "cache1"); originalValues.put(new MagicKey(cache2), "cache2"); cache0.putAll(originalValues); // Try filter for all values Iterator<CacheEntry<MagicKey, String>> iterator = cache1.getAdvancedCache().cacheEntrySet().stream(). filter(CacheFilters.predicate(new MagicKeyStringFilter(originalValues))).iterator(); // we need this count since the map will replace same key'd value int count = 0; Map<MagicKey, String> results = new HashMap<MagicKey, String>(); while (iterator.hasNext()) { Map.Entry<MagicKey, String> entry = iterator.next(); results.put(entry.getKey(), entry.getValue()); count++; } assertEquals(count, 3); assertEquals(originalValues, results); }
@Test public void simpleTestRemoteFilter() { Map<Object, String> values = putValuesInCache(); Iterator<Map.Entry<Object, String>> iter = values.entrySet().iterator(); Map.Entry<Object, String> excludedEntry = iter.next(); // Remove it so comparison below will be correct iter.remove(); Cache<MagicKey, String> cache = cache(1, CACHE_NAME); Iterator<CacheEntry<MagicKey, String>> iterator = cache.getAdvancedCache().cacheEntrySet().stream().filter( CacheFilters.predicate(new KeyFilterAsKeyValueFilter<>(new CollectionKeyFilter<>( Collections.singleton(excludedEntry.getKey()))))).iterator(); Map<MagicKey, String> results = mapFromIterator(iterator); assertEquals(values, results); } }
@Test public void simpleTestLocalFilter() { Map<Object, String> values = putValuesInCache(); Iterator<Map.Entry<Object, String>> iter = values.entrySet().iterator(); Map.Entry<Object, String> excludedEntry = iter.next(); // Remove it so comparison below will be correct iter.remove(); Cache<MagicKey, String> cache = cache(0, CACHE_NAME); KeyValueFilter<MagicKey, String> filter = new KeyFilterAsKeyValueFilter<>(new CollectionKeyFilter<>( Collections.singleton(excludedEntry.getKey()))); Iterator<CacheEntry<MagicKey, String>> iterator = cache.getAdvancedCache().cacheEntrySet().stream().filter( CacheFilters.predicate(filter)).iterator(); Map<MagicKey, String> results = mapFromIterator(iterator); assertEquals(values, results); }
@Test public void testConverterWithExistingTransaction() throws NotSupportedException, SystemException { Map<Object, String> values = putValuesInCache(); Cache<Object, String> cache = cache(0, CACHE_NAME); TransactionManager tm = tm(cache); tm.begin(); try { Object key = "converted-key"; String value = "converted-value"; values.put(key, value); cache.put(key, "converted-value"); try (CacheStream<CacheEntry<Object, String>> stream = cache.getAdvancedCache().cacheEntrySet().stream(). filter(CacheFilters.predicate(AcceptAllKeyValueFilter.getInstance())). map(CacheFilters.function(new StringTruncator(2, 5)))) { Map<Object, String> results = mapFromStream(stream); assertEquals(values.size(), results.size()); for (Map.Entry<Object, String> entry : values.entrySet()) { assertEquals(entry.getValue().substring(2, 7), results.get(entry.getKey())); } } } finally { tm.rollback(); } }
public static <K, V> MapCollectableCloseableIterable<K, V> entrySet(AdvancedCache<K, V> cache, KeyValueFilter<K, V> filter) { if (cache.getCacheConfiguration().transaction().transactionMode().isTransactional()) { // Dummy read to enlist the LocalTransaction as workaround for ISPN-5676 cache.containsKey(false); } // HHH-10023: we can't use values() CloseableIterator<CacheEntry<K, V>> iterator = Closeables.iterator( cache.cacheEntrySet().stream().filter(CacheFilters.predicate(filter))); return new MapCollectableCloseableIterableImpl<K, V>(iterator); }
@Test public void testFilterWithStoreAsBinaryPartialKeys() throws InterruptedException, ExecutionException, TimeoutException { Cache<MagicKey, String> cache0 = cache(0, CACHE_NAME); Cache<MagicKey, String> cache1 = cache(1, CACHE_NAME); Cache<MagicKey, String> cache2 = cache(2, CACHE_NAME); MagicKey findKey = new MagicKey(cache1); Map<MagicKey, String> originalValues = new HashMap<>(); originalValues.put(new MagicKey(cache0), "cache0"); originalValues.put(findKey, "cache1"); originalValues.put(new MagicKey(cache2), "cache2"); cache0.putAll(originalValues); // Try filter for all values Iterator<CacheEntry<MagicKey, String>> iterator = cache1.getAdvancedCache().cacheEntrySet().stream(). filter(CacheFilters.predicate(new MagicKeyStringFilter(Collections.singletonMap(findKey, "cache1")))).iterator(); CacheEntry<MagicKey, String> entry = iterator.next(); AssertJUnit.assertEquals(findKey, entry.getKey()); AssertJUnit.assertEquals("cache1", entry.getValue()); assertFalse(iterator.hasNext()); }
public static <K, V, T> MapCollectableCloseableIterable<K, T> entrySet(AdvancedCache<K, V> cache, KeyValueFilter<K, V> filter, Converter<K, V, T> converter) { if (cache.getCacheConfiguration().transaction().transactionMode().isTransactional()) { // Dummy read to enlist the LocalTransaction as workaround for ISPN-5676 cache.containsKey(false); } // HHH-10023: we can't use values() CloseableIterator<CacheEntry<K, T>> it = Closeables.iterator(cache.cacheEntrySet().stream() .filter(CacheFilters.predicate(filter)) .map(CacheFilters.function(converter))); return new MapCollectableCloseableIterableImpl<K, T>(it); }
CacheFilters.predicate(new KeyFilterAsKeyValueFilter<>(new CollectionKeyFilter<>(Immutables .immutableSetCopy(originalValues.keySet()), true)))).iterator();
public void testFilterWithExistingTransaction() throws Exception { Map<Object, String> values = putValueInEachCache(3); Cache<Object, String> cache = cache(0, CACHE_NAME); TransactionManager tm = tm(cache); tm.begin(); try { Object key = "filtered-key"; cache.put(key, "filtered-value"); Iterator<CacheEntry<Object, String>> iterator = cache.getAdvancedCache().cacheEntrySet().stream(). filter(CacheFilters.predicate(new KeyFilterAsKeyValueFilter<>(new CollectionKeyFilter<>( Collections.singleton(key))))).iterator(); Map<Object, String> results = mapFromIterator(iterator); assertEquals(values, results); } finally { tm.rollback(); } }
CacheFilters.predicate(new KeyFilterAsKeyValueFilter<>(new CollectionKeyFilter<>(Immutables .immutableSetCopy(originalValues.keySet()), true)))).iterator();