private Boolean removeKey(EntryView.ReadWriteEntryView<K, Collection<V>> entryView) { return entryView.find().map(values -> { entryView.remove(); return Boolean.TRUE; }).orElse(Boolean.FALSE); }
@Override public Void apply(EntryView.ReadWriteEntryView<Object, Object> view) { Object storedValue = view.find().orElse(null); MetaParam.MetaLifespan expiringMetaParam = region.getExpiringMetaParam(); if (storedValue instanceof Tombstone) { view.set(((Tombstone) storedValue).merge(this), expiringMetaParam); } else { view.set(this, expiringMetaParam); } return null; }
private static Map<?, ?> readWriteMany(Cache<Object, Object> cache, Collection<?> keys) { ReadWriteMap<Object, Object> ro = ReadWriteMapImpl.create(FunctionalMapImpl.create(cache.getAdvancedCache())); return ro.evalMany(new HashSet<>(keys), MarshallableFunctions.identity()) .filter(view -> view.find().isPresent()) .collect(Collectors.toMap(ReadWriteEntryView::key, ReadWriteEntryView::get)); }
private Object readWriteKeyValue(MagicKey key, int index) { FunctionalMap.ReadWriteMap<Object, Object> rwMap = ReadWriteMapImpl.create(FunctionalMapImpl.create(cache(0).getAdvancedCache())); CompletableFuture cfa = rwMap.eval(key, "v" + index, (value, view) -> { assertFalse(view.find().isPresent()); view.set(value); return "r" + index; }); return cfa.join(); }
private Object readWriteMany(MagicKey key, int index) { // make sure the other key is stable MagicKey otherKey = new MagicKey("other", cache(0), cache(2)); FunctionalMap.ReadWriteMap<Object, Object> rwMap = ReadWriteMapImpl.create(FunctionalMapImpl.create(cache(0).getAdvancedCache())); HashSet<MagicKey> keys = new HashSet<>(Arrays.asList(key, otherKey)); Traversable<Object> traversable = rwMap.evalMany(keys, view -> { assertFalse(view.find().isPresent()); view.set("v" + index); return "r" + index; }); return traversable.findAny().orElseThrow(IllegalStateException::new); }
private static Integer increment(EntryView.ReadWriteEntryView<String, Integer> view) { int value = view.find().orElse(0); view.set(value + 1); return value; }
public static SerializableFunction<EntryView.ReadWriteEntryView<Object, String>, String> append(String str) { return ev -> { Optional<String> prev = ev.find(); if (prev.isPresent()) { ev.set(prev.get() + str); return prev.get(); } else { ev.set(str); return null; } }; }
public static <K, V> void assertReadWriteViewEquals(K k, V expected, ReadWriteEntryView<K, V> rw) { assertEquals(k, rw.key()); assertTrue(rw.find().isPresent()); assertEquals(expected, rw.find().get()); assertEquals(expected, rw.get()); try { rw.set(null); fail("Expected IllegalStateException since entry view cannot be modified outside lambda"); } catch (IllegalStateException e) { // Expected } }
private static Integer add(Integer param, EntryView.ReadWriteEntryView<String, Integer> view) { int value = view.find().orElse(0); view.set(value + param); return value; }
private static Map<?, ?> readWrite(Cache<Object, Object> cache, Collection<?> keys) { ReadWriteMap<Object, Object> rw = ReadWriteMapImpl.create(FunctionalMapImpl.create(cache.getAdvancedCache())); Map<Object, Object> map = new HashMap<>(); for (Object key : keys) { rw.eval(key, MarshallableFunctions.identity()).join().find().ifPresent(value -> map.put(key, value)); } return map; }
@Test(dataProvider = "ownerAndExistence", enabled = false, description = "ISPN-8676") public void testReadWriteManyEntriesCommand(boolean onOwner, boolean withExisting) { ReadWriteMap<Object, Object> rw = onOwner ? rw0 : rw1; testMany(() -> rw.evalMany(Collections.singletonMap(key, "bar"), (bar, view) -> view.find().orElse(null)), onOwner, withExisting); }
@Test(dataProvider = "ownerAndExistence") public void testReadWriteKeyValueCommand(boolean onOwner, boolean withExisting) { ReadWriteMap<Object, Object> rw = onOwner ? rw0 : rw1; test(() -> rw.eval(key, "bar", (bar, view) -> view.find().orElse(null)), onOwner, withExisting); }
@Test(dataProvider = "ownerAndExistence") public void testReadWriteKeyCommand(boolean onOwner, boolean withExisting) { ReadWriteMap<Object, Object> rw = onOwner ? rw0 : rw1; test(() -> rw.eval(key, view -> view.find().orElse(null)), onOwner, withExisting); }
@Override public V getValue() { return rw.find().orElse(null); }
public static <K> void assertReadWriteViewEmpty(K k, ReadWriteEntryView<K, ?> rw) { assertEquals(k, rw.key()); assertFalse(rw.find().isPresent()); }
@Override public Optional<String> apply(ReadWriteEntryView<K, String> rw) { Optional<String> prev = rw.find(); rw.set("one"); return prev; }
private Object readWriteKey(MagicKey key, int index) { FunctionalMap.ReadWriteMap<Object, Object> rwMap = ReadWriteMapImpl.create(FunctionalMapImpl.create(cache(0).getAdvancedCache())); CompletableFuture cf = rwMap.eval(key, view -> { assertFalse(view.find().isPresent()); view.set("v" + index); return "r" + index; }); return cf.join(); }
@Test(dataProvider = "ownerAndExistence", enabled = false, description = "ISPN-8676") public void testReadWriteManyCommand(boolean onOwner, boolean withExisting) { ReadWriteMap<Object, Object> rw = onOwner ? rw0 : rw1; testMany(() -> rw.evalMany(Collections.singleton(key), view -> view.find().orElse(null)), onOwner, withExisting); }