Provides a function that returns the value of the entry when invoked.
@param <K> key type of the entry
@param <V> value type of the entry
@return a function that when applied to a given entry will return the value
4299
public static <K, V> Function<Map.Entry<K, V>, V> entryToValueFunction() {
      return EntryToValueFunction.getInstance();
   }
111012
public static QueryRequest query(String key, Object value) {
        return QueryRequest.create().addParameter(key, value);
    }
1213344
private V getValue(InternalCacheEntry<K, V> entry) {
      return isNull(entry) ? null : entry.getValue();
   }
584936
public <V> V putIfAbsent(Key<V> key, V value) {
    requireNonNull(key);
    requireNonNull(value);
    if (canStore(key)) {
      @SuppressWarnings("unchecked")
      V existingValue = (V) entries.get(key);
      if (value == RECURSION_SENTINEL) {
        throw new ConcurrentModificationException(
            "Cannot access scope key " + key + " while computing its value");
      } else if (existingValue == null) {
        entries.put(key, value);
      }
      return existingValue;
    } else if (parent != null) {
      return parent.putIfAbsent(key, value);
    } else {
      throw new IllegalStateException(
          "Not in " + key.level().toString().toLowerCase() + " scope");
    }
  }
1044678
private static <K, V> boolean keyOrValueIsAbsent(Entry<String, KeyValue<K, V>> entry) {
		KeyValue<K, V> kv = entry.getValue();
		return kv.key == null || kv.value == null;
	}
632615
protected final ReferencableValue<K, V> makeValue(K key, V value) {
		return makeValue(key, value, this.queue);
	}
1324537
private static <K, V> Map.Entry<K, V> createEntry(K key, V value) {
		return new Map.Entry<K, V>() {
			@Override
			public K getKey() {
				return key;
			}

			@Override
			public V getValue() {
				return value;
			}

			@Override
			public V setValue(V value) {
				throw new UnsupportedOperationException();
			}
		};
	}
24012
@Override
    public V get(Object key) {
        if (super.containsKey(key)) {
            return super.get(key);    
        } else {
            @SuppressWarnings("unchecked")
            K k = (K) key;
            V v = makeDefault.apply(k);
            put(k, v);
            return v;
        }
    }
221513
@SuppressWarnings("unchecked")
  public <T> T get(String key) {

    T value = (T) map.get(key);
    return value;
  }
526508
public String getValueWithDefault(String keyMsgType, String defaultVal) {
        return keyToValue.getOrDefault(keyMsgType, defaultVal);
    }
9576
public static <K, V> Function<Map.Entry<K, V>, K> entryToKeyFunction() {
      return EntryToKeyFunction.getInstance();
   }
286969
function(key, options={}){
    if(this.returnType === 'value'){ return console.error('Called get on the `'+ this.name +'` computed property which returns a primitive value.'); }
    return this.value().get(key, options);
  }
738406
V getLiveValue(ReferenceEntry<K, V> entry) {
    if (entry.getKey() == null) {
      return null;
    }
    V value = entry.getValueReference().get();
    if (value == null) {
      return null;
    }

    if (expires() && isExpired(entry)) {
      return null;
    }
    return value;
  }
710788
protected <T> T getProperty(String key, Class<T> type) {
        Object returnValue = getProperty(key);
        if (returnValue != null) {
            return (T) returnValue;
        } else {
            return null;
        }
    }
689596
@SuppressWarnings("unchecked")
	public <T> T getSet(Object key, Object value) {
		Jedis jedis = getJedis();
		try {
			return (T)valueFromBytes(jedis.getSet(keyToBytes(key), valueToBytes(value)));
		}
		finally {close(jedis);}
	}
857165
function createKeyVal(key, value) {
    return {
      key,
      val: (typeof value === 'function')
        ? function (bidResponse) {
          return value(bidResponse);
        }
        : function (bidResponse) {
          return getValue(bidResponse, value);
        }
    };
  }
614517
@Deprecated
  public static <K, V> Function<Map.Entry<K, V>, K> getEntryKey() {
    return entryKeyFunction();
  }