@Override public void get(K k, Handler<AsyncResult<V>> asyncResultHandler) { delegate.get(k, asyncResultHandler); }
@Override public void put(K k, V v, Handler<AsyncResult<Void>> completionHandler) { checkType(k); checkType(v); delegate.put(k, v, completionHandler); }
@Override public void remove(K k, Handler<AsyncResult<V>> resultHandler) { delegate.remove(k, resultHandler); }
@Test public void testMapPutTtlThenPut() { getVertx().sharedData().getAsyncMap("foo", onSuccess(map -> { map.put("pipo", "molo", 10, onSuccess(vd -> { map.put("pipo", "mili", onSuccess(vd2 -> { vertx.setTimer(20, l -> { getVertx().sharedData().getAsyncMap("foo", onSuccess(map2 -> { map2.get("pipo", onSuccess(res -> { assertEquals("mili", res); testComplete(); })); })); }); })); })); })); await(); }
@Test public void testPutGetAndRemove(TestContext context) { Async async = context.async(); map.size(s -> { context.assertTrue(s.succeeded()); context.assertEquals(s.result(), 0); map.put("key", "value", v -> map.size(s2 -> { context.assertTrue(s2.succeeded()); context.assertEquals(s2.result(), 1); map.get("key", value -> { context.assertTrue(value.succeeded()); context.assertEquals(value.result(), "value"); map.remove("key", old -> { context.assertTrue(old.succeeded()); context.assertEquals(old.result(), "value"); map.size(s3 -> { context.assertTrue(s3.succeeded()); context.assertEquals(s3.result(), 0); async.complete(); }); }); }); })); }); }
private <K, V> void testMapReplace(K k, V v, V other) { getVertx().sharedData().<K, V>getAsyncMap("foo", onSuccess(map -> { map.put(k, v, onSuccess(res -> { assertNull(res); getVertx().sharedData().<K, V>getAsyncMap("foo", onSuccess(map2 -> { map2.replace(k, other, onSuccess(res2 -> { assertEquals(v, res2); map2.get(k, onSuccess(res3 -> { assertEquals(other, res3); map2.remove(k, onSuccess(res4 -> { map2.replace(k, other, onSuccess(res5 -> { assertNull(res5); map2.get(k, onSuccess(res6 -> { assertNull(res6); testComplete(); })); })); })); })); })); })); })); })); await(); }
futures.add(future); String apiIndex = getApiIndex(contract.getApiOrgId(), contract.getApiId(), contract.getApiVersion()); objectMap.get(apiIndex, future.completer()); objectMap.putIfAbsent(client.getApiKey(), client, putNewApiKeyFuture.completer()); objectMap.replace(client.getApiKey(), client, replaceClientFuture.completer()); } else { objectMap.putIfAbsent(clientIndex, client, replaceClientFuture.completer()); Client oldClient = (Client) oldClientRaw; if (oldClientRaw != null && !oldClient.getApiKey().equals(client.getApiKey())) { objectMap.remove(oldClient.getApiKey(), endFuture.completer()); } else { endFuture.complete();
private <K, V> void testMapPutIfAbsentGet(K k, V v) { getVertx().sharedData().<K, V>getAsyncMap("foo", onSuccess(map -> { map.putIfAbsent(k, v, onSuccess(res -> { assertNull(res); getVertx().sharedData().<K, V>getAsyncMap("foo", onSuccess(map2 -> { map2.get(k, onSuccess(res2 -> { assertEquals(v, res2); map.putIfAbsent(k, v, onSuccess(res3 -> { assertEquals(v, res3); testComplete(); })); })); })); })); })); await(); }
@Override public SharedClient<K, V> put(final K key, final V value, final Handler<AsyncResult<KeyPair<K, V>>> handler) { this.ensure(true); this.asyncMap.get(key, res -> { if (res.succeeded()) { final V reference = res.result(); Fn.safeSemi(null == reference, LOGGER, () -> this.asyncMap.put(key, value, added -> { if (added.succeeded()) { handler.handle(Future.succeededFuture(KeyPair.create(key, value))); } }), () -> this.asyncMap.replace(key, value, replaced -> { if (replaced.succeeded()) { handler.handle(Future.succeededFuture(KeyPair.create(key, value))); } })); } }); return this; }
private <K, V> void testMapReplaceIfPresent(K k, V v, V other) { getVertx().sharedData().<K, V>getAsyncMap("foo", onSuccess(map -> { map.put(k, v, onSuccess(res -> { assertNull(res); getVertx().sharedData().<K, V>getAsyncMap("foo", onSuccess(map2 -> { map2.replaceIfPresent(k, v, other, onSuccess(res2 -> { map2.replaceIfPresent(k, v, other, onSuccess(res3 -> { assertFalse(res3); map2.get(k, onSuccess(res4 -> { assertEquals(other, res4); testComplete(); })); })); })); })); })); })); await(); }
@Test public void testClear() { getVertx().sharedData().<String, String>getAsyncMap("foo", onSuccess(map -> { map.put("foo", "bar", onSuccess(v -> { getVertx().sharedData().<String, String>getAsyncMap("foo", onSuccess(map2 -> { map2.clear(onSuccess(v2 -> { map.get("foo", onSuccess(res -> { assertNull(res); testComplete(); })); })); })); })); })); await(); }
private <K, V> void testMapRemove(K k, V v) { getVertx().sharedData().<K, V>getAsyncMap("foo", onSuccess(map -> { map.put(k, v, onSuccess(res -> { assertNull(res); getVertx().sharedData().<K, V>getAsyncMap("foo", onSuccess(map2 -> { map2.remove(k, onSuccess(res2 -> { assertEquals(v, res2); testComplete(); })); })); })); })); await(); }
@Override public void unregisterClient(Client client, IAsyncResultHandler<Void> resultHandler) { String clientIndex = getClientIndex(client); objectMap.get(clientIndex, handleSuccessfulResult(resultHandler, oldClientRaw -> { Client oldClient = (Client) oldClientRaw; if (oldClient == null) { Exception ex = new ClientNotFoundException(Messages.i18n.format("InMemoryRegistry.ClientNotFound")); resultHandler.handle(AsyncResultImpl.create(ex)); } else { Future<Object> future1 = Future.future(); Future<Object> future2 = Future.future(); objectMap.remove(clientIndex, future1.completer()); objectMap.remove(oldClient.getApiKey(), future2.completer()); CompositeFuture.all(future1, future2).setHandler(handleCompositeResult(resultHandler)); } })); }
@Test public void testSize() { getVertx().sharedData().<String, String>getAsyncMap("foo", onSuccess(map -> { map.size(onSuccess(size -> { assertEquals(0, size.intValue()); map.put("foo", "bar", onSuccess(v -> { map.size(onSuccess(size2 -> { assertEquals(1, size2.intValue()); getVertx().sharedData().<String, String>getAsyncMap("foo", onSuccess(map2 -> { map2.size(onSuccess(size3 -> { assertEquals(1, size3.intValue()); testComplete(); })); })); })); })); })); })); await(); }
private <K, V> void testMapRemoveIfPresent(K k, V v, V other) { getVertx().sharedData().<K, V>getAsyncMap("foo", onSuccess(map -> { map.put(k, v, onSuccess(res -> { assertNull(res); getVertx().sharedData().<K, V>getAsyncMap("foo", onSuccess(map2 -> { map2.removeIfPresent(k, other, onSuccess(res2 -> { assertFalse(res2); map2.removeIfPresent(k, v, onSuccess(res3 -> { assertTrue(res3); testComplete(); })); })); })); })); })); await(); }
@Override public void putIfAbsent(K k, V v, Handler<AsyncResult<V>> completionHandler) { checkType(k); checkType(v); delegate.putIfAbsent(k, v, completionHandler); }
@Override public void size(Handler<AsyncResult<Integer>> resultHandler) { delegate.size(resultHandler); }
private void addOrReplace2(boolean allowReplace, String k, String k2, String value, String oldVal, String newVal, Handler<ExtendedAsyncResult<Void>> fut) { if (oldVal == null) { // new entry list.putIfAbsent(k, newVal, resPut -> { if (resPut.succeeded()) { if (resPut.result() == null) { fut.handle(new Success<>()); } else { // Someone messed with it, try again vertx.setTimer(DELAY, res -> addOrReplace(allowReplace, k, k2, value, fut)); } } else { fut.handle(new Failure<>(INTERNAL, resPut.cause())); } }); } else { // existing entry, put and retry if someone else messed with it list.replaceIfPresent(k, oldVal, newVal, resRepl -> { if (resRepl.succeeded()) { if (resRepl.result()) { fut.handle(new Success<>()); } else { vertx.setTimer(DELAY, res -> addOrReplace(allowReplace, k, k2, value, fut)); } } else { fut.handle(new Failure<>(INTERNAL, resRepl.cause())); } }); } }
private void remove2(String k, String k2, StringMap smap, String val, Handler<ExtendedAsyncResult<Boolean>> fut) { if (smap.strings.isEmpty()) { list.removeIfPresent(k, val, resDel -> { if (resDel.succeeded()) { if (resDel.result()) { fut.handle(new Success<>(true)); } else { vertx.setTimer(DELAY, res -> remove(k, k2, fut)); } } else { fut.handle(new Failure<>(INTERNAL, resDel.cause())); } }); } else { // list was not empty, remove value String newVal = Json.encodePrettily(smap); list.replaceIfPresent(k, val, newVal, resPut -> { if (resPut.succeeded()) { if (resPut.result()) { fut.handle(new Success<>(false)); } else { vertx.setTimer(DELAY, res -> remove(k, k2, fut)); } } else { fut.handle(new Failure<>(INTERNAL, resPut.cause())); } }); } }
@Override public void replace(K k, V v, Handler<AsyncResult<V>> resultHandler) { checkType(k); checkType(v); delegate.replace(k, v, resultHandler); }