Non-blocking call

@param key
@param value
@return
13889
public Future<PutObjectResult> putAsync(String key, String value) {
        return Future.of(() -> put(key, value), this.uploadService)
                      .flatMap(t->t.fold(p->Future.ofResult(p),e->Future.ofError(e)));
    }
630515
public synchronized V get(final K key) {
		if (!validState) {
			throw new InvalidStateException();
		}
		if (_isEmpty()) {
			return null;
		}
		if (key == null) {
			return null;
		}
		try {
			final LeafNode<K, V> node = findLeafNode(key, false);
			if (node == null) {
				return null;
			}
			int slot = node.findSlotByKey(key);
			if (slot >= 0) {
				return node.values[slot];
			}
			return null;
		} finally {
			releaseNodes();
		}
	}
1122638
public final Promise set(String key, byte[] value, SetArgs args) {
		byte[] binaryKey = key.getBytes(StandardCharsets.UTF_8);
		if (client != null) {
			if (args == null) {
				return new Promise(client.set(binaryKey, value));
			}
			return new Promise(client.set(binaryKey, value, args));
		}
		if (clusteredClient != null) {
			if (args == null) {
				return new Promise(clusteredClient.set(binaryKey, value));
			}
			return new Promise(clusteredClient.set(binaryKey, value, args));
		}
		return Promise.resolve();
	}
1338864
public static <ReqT, RespT> RespT blockingUnaryCall(ClientCall<ReqT, RespT> call, ReqT req) {
    try {
      return getUnchecked(futureUnaryCall(call, req));
    } catch (RuntimeException e) {
      throw cancelThrow(call, e);
    } catch (Error e) {
      throw cancelThrow(call, e);
    }
  }
897214
public void pushLogging(String key, Object value) {
        assertArgumentNotNull("key", key);
        assertArgumentNotNull("value", value);
        postcard.pushLogging(key, value);
    }
1062867
public V put(K key, V value) {

        if ((key != null) && (value != null)) {
            return m_internalMap.put(key, value);
        }
        Exception e = new Exception();
        try {
            // we want to print a stack trace when null is used as a key/value
            throw e;
        } catch (Exception e2) {
            e = e2;
        }
        if (key == null) {
            LOG.warn("Invalid null key in map", e);
            return null;
        }
        if (value == null) {
            LOG.warn("Invalid null value in map", e);
            return m_internalMap.remove(key);
        }
        return null;
    }
399099
public void await(K k, long timeout, TimeUnit unit) throws InterruptedException, TimeoutException {
        if (!acquireLock(k).await(timeout, unit)) {
            throw new TimeoutException("Wait time for retrieving value for key " + k + " exceeded " + timeout + " " + unit);
        }
    }
565989
private V putInternal(final K key, final V value) {
        final Map<K, V> delegate = new HashMap<>(this.delegate);
        V existing = delegate.put(key, value);
        this.delegate = delegate;
        return existing;
    }
1114121
public S setParameter(String key, String value) {
        if (parameters == null) {
            parameters = new ConcurrentHashMap<String, String>();
        }
        if (value == null) {
            parameters.remove(key);
        } else {
            parameters.put(key, value);
        }
        return castThis();
    }
45218
public T putCache(String key, T value) {
		return cache.put(key, value);
	}
500084
public V put(K key, V value){
		writeLock.lock();
		try {
			cache.put(key, value);
		} finally {
			writeLock.unlock();
		}
		return value;
	}
209859
public String nonPipelineRead(String key) throws Exception {

        String res = jedisClient.get().get(key);

        if (res != null) {
            if (res.isEmpty()) {
                throw new Exception("Data retrieved is not ok ");
            }
        } else {
            return CacheMiss;
        }

        return ResultOK;

    }
225373
public <T> void put(@NonNull String key, @NonNull T value) {
    Preconditions.checkNotNull(value, VALUE_IS_NULL);
    put(key, value, TypeToken.fromValue(value));
  }
1021867
@NonNull
    @Override
    public MutableDictionary setString(@NonNull String key, String value) {
        return setValue(key, value);
    }
1355171
public String put(final String key, final Long value) {
    return this._current.put(key, value.toString());
  }
830765
public Object put(Object key, Object value)
    {
        long objectStamp = System.currentTimeMillis();
        synchronized (objects)
        {
            objectTimeStamps.put(key, objectStamp);
            if (nextTimeSomeExpired == NO_OBJECTS)
            {
                nextTimeSomeExpired = objectStamp;
            }
            return objects.put(key, value);
        }
    }
272615
public Object put(String key, Object value) {
		if (size == keys.length) {
			throw new ArrayIndexOutOfBoundsException(size);
		}
		keys[size] = key;
		values[size] = value;
		size++;
		return value;
	}