Returns an entry of the predicate cache of this formula.
@param key the cache key
@return the cache value (which is {@code UNDEF} if nothing is present)
437459
public Tristate predicateCacheEntry(final CacheEntry key) {
        final Tristate tristate = this.predicateCache.get(key);
        if (tristate == null) {
            return Tristate.UNDEF;
        }
        return tristate;
    }
263687
final Entry<K, V> getEntry(Object key) {
	int hash = (key == null) ? 0 : hash(key);
	for (Entry<K, V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) {
	    if (e.hash == hash && ((e.key) == key || (key != null && key.equals(e.key)))) return e;
	}
	return null;
    }
427738
public V retrieve(K key) {
        Ref<V> ref = map.get(key);
        return ref == null ? null : ref.get();
    }
243315
public <T> T cached(String key) {
        H.Session sess = session();
        if (null != sess) {
            return sess.cached(key);
        } else {
            return app().cache().get(key);
        }
    }
912321
public int get(final int key)
    {
        final int[] entries = this.entries;
        final int initialValue = this.initialValue;
        @DoNotSub final int mask = entries.length - 1;
        @DoNotSub int index = Hashing.evenHash(key, mask);

        int value = initialValue;
        while (entries[index + 1] != initialValue)
        {
            if (entries[index] == key)
            {
                value = entries[index + 1];
                break;
            }

            index = next(index, mask);
        }

        return value;
    }
247888
@SuppressWarnings("unchecked")
    public V get(final int key)
    {
        V value = null;
        @DoNotSub final int setNumber = Hashing.hash(key, mask);
        @DoNotSub final int setBeginIndex = setNumber << setSizeShift;

        for (@DoNotSub int i = setBeginIndex, setEndIndex = setBeginIndex + setSize; i < setEndIndex; i++)
        {
            if (null == values[i])
            {
                break;
            }

            if (key == keys[i])
            {
                value = (V)values[i];
                break;
            }
        }

        if (null == value)
        {
            cacheMisses++;
        }
        else
        {
            cacheHits++;
        }

        return value;
    }
776048
public T get(long key) {
		for (int i = 0; i < this.numTables; i++) {
			Entry<T> entry = this.tables.get(i).get(
					this.hashfunctions.get(i).hash(key));
			if (entry != null && entry.getKey() == key) {
				return entry.getValue();
			}
		}
		for (Entry<T> entry : this.stash) {
			if (entry.getKey() == key) {
				return entry.getValue();
			}
		}
		return null;
	}
737746
public Data get(Key key) {
		synchronized (cache) {
			Pair<Data,Long> p = cache.get(key);
			if (p != null) {
				p.setValue2(Long.valueOf(System.currentTimeMillis()));
				return p.getValue1();
			}
			p = new Pair<>(provider.provide(key), Long.valueOf(System.currentTimeMillis()));
			cache.put(key, p);
			return p.getValue1();
		}
	}
853642
public V retrieve(K key) {
		V retval = null;
		if (isCachingEnabled()) {
			CachedObject<V> co = getCachedObject(key);
			if (co == null || (isCachedObjectExpired(co))) {
				//take pressure off of cleanup
				misses++;
			} else if (co.getObject() == null) {
				unavailable++;
			} else {
				hits++;
				retval = co.getObject();
			}
		}
		return retval;
	}
495500
public void setPredicateCacheEntry(final CacheEntry key, final boolean value) {
        this.predicateCache.put(key, Tristate.fromBool(value));
    }
952596
public Object get(Object key)
    {
        purge();
        Entry entry = getEntry(key);
        if (entry == null) return null;
        return entry.getValue();
    }
433485
@Override
    public boolean containsKey(Object key) {
        if (key == null) {
            throw new NullPointerException();
        }
        
        CachedValue<K, V> entry = map.get(key);
        if (entry == null) {
            return false;
        }
        if (isValueExpired(entry)) {
            if (map.remove(key, entry)) {
                onValueRemove(entry);
                return false;
            }
            return containsKey(key);
        }
        return true;
    }
568903
public boolean hasCachedValue(Key key) {
		try {
			readLock.lock();
			return content.containsKey(key);
		} finally {
			readLock.unlock();
		}
	}
873181
public String get(String key) {
    	if(requestedKeys == null) requestedKeys = new HashSet<String>();
    	String value = map.get(key);
    	requestedKeys.add(key);
    	return value;
    }
1150532
@Override
    public CompletableFuture<V> getAsync(String key) {
        return (CompletableFuture) send("GET", CacheEntryType.OBJECT, (Type) null, key, key.getBytes(UTF8));
    }
985377
public boolean containsKey(Object key)
    {
        purge();
        Entry entry = getEntry(key);
        if (entry == null) return false;
        return entry.getValue() != null;
    }
96053
public final int get(String key)
  {

    for (int i = 0; i < m_firstFree; i++)
    {
      if (m_map[i].equals(key))
        return m_values[i];
    }

    return INVALID_KEY;
  }