@Override public <K, V> RMapAsync<K, V> getMap(String name) { return new RedissonMap<K, V>(executorService, name, null, null); }
@Override public V addAndGet(K key, Number value) { return get(addAndGetAsync(key, value)); }
@Override public RFuture<V> addAndGetAsync(final K key, Number value) { checkKey(key); checkValue(value); final RFuture<V> future = addAndGetOperationAsync(key, value); if (hasNoWriter()) { return future; } MapWriterTask<V> listener = new MapWriterTask<V>() { @Override public void execute() { options.getWriter().write(key, future.getNow()); } }; return mapWriterFuture(future, listener); }
@Override public boolean containsValue(Object value) { return get(containsValueAsync(value)); }
@Override public boolean containsKey(Object key) { return get(containsKeyAsync(key)); }
@Override public RFuture<V> removeAsync(final K key) { checkKey(key); RFuture<V> future = removeOperationAsync(key); if (hasNoWriter()) { return future; } MapWriterTask<V> listener = new MapWriterTask<V>() { @Override public void execute() { options.getWriter().delete(key); } }; return mapWriterFuture(future, listener); }
protected RFuture<Boolean> replaceOperationAsync(K key, V oldValue, V newValue) { return commandExecutor.evalWriteAsync(getName(key), codec, RedisCommands.EVAL_BOOLEAN, "if redis.call('hget', KEYS[1], ARGV[1]) == ARGV[2] then " + "redis.call('hset', KEYS[1], ARGV[1], ARGV[3]); " + "return 1; " + "else " + "return 0; " + "end", Collections.<Object>singletonList(getName(key)), encodeMapKey(key), encodeMapValue(oldValue), encodeMapValue(newValue)); }
protected RFuture<Void> putAllOperationAsync(Map<? extends K, ? extends V> map) { List<Object> params = new ArrayList<Object>(map.size()*2 + 1); params.add(getName()); for (java.util.Map.Entry<? extends K, ? extends V> t : map.entrySet()) { checkKey(t.getKey()); checkValue(t.getValue()); params.add(encodeMapKey(t.getKey())); params.add(encodeMapValue(t.getValue())); } RFuture<Void> future = commandExecutor.writeAsync(getName(), codec, RedisCommands.HMSET, params.toArray()); return future; }
@Override public RFuture<V> putAsync(final K key, final V value) { checkKey(key); checkValue(value); RFuture<V> future = putOperationAsync(key, value); if (hasNoWriter()) { return future; } MapWriterTask<V> listener = new MapWriterTask<V>() { @Override public void execute() { options.getWriter().write(key, value); } }; return mapWriterFuture(future, listener); }
@Override public RFuture<Boolean> fastPutAsync(final K key, final V value) { checkKey(key); checkValue(value); RFuture<Boolean> future = fastPutOperationAsync(key, value); if (hasNoWriter()) { return future; } MapWriterTask<Boolean> listener = new MapWriterTask<Boolean>() { @Override public void execute() { options.getWriter().write(key, value); } }; return mapWriterFuture(future, listener); }
@Override public RFuture<Boolean> fastPutIfAbsentAsync(final K key, final V value) { checkKey(key); checkValue(value); RFuture<Boolean> future = fastPutIfAbsentOperationAsync(key, value); if (hasNoWriter()) { return future; } MapWriterTask<Boolean> listener = new MapWriterTask<Boolean>() { @Override public void execute() { options.getWriter().write(key, value); } @Override protected boolean condition(Future<Boolean> future) { return future.getNow(); } }; return mapWriterFuture(future, listener); }
@Override public RFuture<Boolean> fastReplaceAsync(final K key, final V value) { checkKey(key); checkValue(value); RFuture<Boolean> future = fastReplaceOperationAsync(key, value); if (hasNoWriter()) { return future; } MapWriterTask<Boolean> listener = new MapWriterTask<Boolean>() { @Override public void execute() { options.getWriter().write(key, value); } @Override protected boolean condition(Future<Boolean> future) { return future.getNow(); } }; return mapWriterFuture(future, listener); }
@Override public RFuture<V> replaceAsync(final K key, final V value) { checkKey(key); checkValue(value); RFuture<V> future = replaceOperationAsync(key, value); if (hasNoWriter()) { return future; } MapWriterTask<V> listener = new MapWriterTask<V>() { @Override public void execute() { options.getWriter().write(key, value); } @Override protected boolean condition(Future<V> future) { return future.getNow() != null; } }; return mapWriterFuture(future, listener); }
@Override public RFuture<V> putIfAbsentAsync(final K key, final V value) { checkKey(key); checkValue(key); RFuture<V> future = putIfAbsentOperationAsync(key, value); if (hasNoWriter()) { return future; } MapWriterTask<V> listener = new MapWriterTask<V>() { @Override public void execute() { options.getWriter().write(key, value); } @Override protected boolean condition(Future<V> future) { return future.getNow() == null; } }; return mapWriterFuture(future, listener); }
checkKey(key); K key = iter.next(); if (replaceExistingValues) { loadValue(result, counter, iter, key, loadedEntires); } else { checkAndLoadValue(result, counter, iter, key, loadedEntires); log.error("Unable to load keys for map " + getName(), e); return RedissonPromise.newFailedFuture(e);
@Override public RFuture<Boolean> containsKeyAsync(Object key) { checkKey(key); return commandExecutor.readAsync(getName(key), codec, RedisCommands.HEXISTS, getName(key), encodeMapKey(key)); }
@Override public RFuture<Boolean> containsValueAsync(Object value) { checkValue(value); return commandExecutor.evalReadAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN, "local s = redis.call('hvals', KEYS[1]);" + "for i = 1, #s, 1 do " + "if ARGV[1] == s[i] then " + "return 1 " + "end " + "end;" + "return 0", Collections.<Object>singletonList(getName()), encodeMapValue(value)); }
protected RFuture<V> removeOperationAsync(K key) { return commandExecutor.evalWriteAsync(getName(key), codec, RedisCommands.EVAL_MAP_VALUE, "local v = redis.call('hget', KEYS[1], ARGV[1]); " + "redis.call('hdel', KEYS[1], ARGV[1]); " + "return v", Collections.<Object>singletonList(getName(key)), encodeMapKey(key)); }
public String getLockName(Object key, String suffix) { ByteBuf keyState = encodeMapKey(key); try { return suffixName(getName(key), Hash.hash128toBase64(keyState) + ":" + suffix); } finally { keyState.release(); } }
private void checkAndLoadValue(final RPromise<Void> result, final AtomicInteger counter, final Iterator<? extends K> iter, final K key, final Map<K, V> loadedEntires) { containsKeyAsync(key).addListener(new FutureListener<Boolean>() { @Override public void operationComplete(Future<Boolean> future) throws Exception {