Account for key being fetched.

@param key
326647
protected void accountForFetchedKey(byte[] key) {
        fetched++;
        if (streamStats != null) {
            streamStats.reportStreamingFetch(operation);
        }

        if (recordsPerPartition <= 0) {
            return;
        }

        Integer keyPartitionId = getKeyPartitionId(key);
        Long partitionFetch = partitionFetches.get(keyPartitionId);
        Utils.notNull(partitionFetch);
        partitionFetch++;

        partitionFetches.put(keyPartitionId, partitionFetch);
        if (partitionFetch == recordsPerPartition) {
            if (partitionsToFetch.contains(keyPartitionId)) {
                partitionsToFetch.remove(keyPartitionId);
            } else {
                logger.warn("Partitions to fetch did not contain expected partition ID: "
                        + keyPartitionId);
            }
        } else if (partitionFetch > recordsPerPartition) {
            logger.warn("Partition fetch count larger than expected for partition ID "
                    + keyPartitionId + " : " + partitionFetch);
        }
    }
282019
protected static Object fetchObject(String key) {
        String[] path = key.split("\\.");
        Object currentValue = fakeValuesMap;
        for (String pathSection : path) {
            currentValue = ((Map<String, Object>) currentValue).get(pathSection);
        }
        return currentValue;
    }
1147540
public void pressKey(final String key) {
        if (key == null) return;

        runWithRetries(() -> {
            elementImpl.locateElement().sendKeys(key);
        });
    }
1066749
public String getKey(String key) {
        try {
            String _response = evCache.<String>get(key);
            return _response;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
52919
public void audit(String key, Object... params) {
        Tr.audit(tc, key, params);
    }
335319
@SuppressWarnings("unchecked")
    @Override
    synchronized public V get(Object key) {
        if(!this.containsKey(key)) {
            super.put((K) key, readBack((K) key));
        }

        return super.get(key);
    }
844140
public void containsKey(@NullableDecl Object key) {
    check("keySet()").that(actual().keySet()).contains(key);
  }
681396
public void reload(String key) {
		if (configurationOptionsByKey.containsKey(key)) {
			configurationOptionsByKey.get(key).reload(false);
		}
	}
296257
protected static Object fetch(String key) {
        List valuesArray = (List) fetchObject(key);
        return valuesArray.get(RandomUtils.nextInt(valuesArray.size()));
    }
910898
protected boolean isItemAccepted(byte[] key) {
        boolean entryAccepted = false;
        if (!fetchOrphaned) {
            if (isKeyNeeded(key)) {
                entryAccepted = true;
            }
        } else {
            if (!StoreRoutingPlan.checkKeyBelongsToNode(key, nodeId, initialCluster, storeDef)) {
                entryAccepted = true;
            }
        }
        return entryAccepted;
    }
723118
def _fetch(self, key):
        
        # switch off interpolation before we try and fetch anything !
        save_interp = self.section.main.interpolation
        self.section.main.interpolation = False

        # Start at section that "owns" this InterpolationEngine
        current_section = self.section
        while True:
            # try the current section first
            val = current_section.get(key)
            if val is not None and not isinstance(val, Section):
                break
            # try "DEFAULT" next
            val = current_section.get('DEFAULT', {}).get(key)
            if val is not None and not isinstance(val, Section):
                break
            # move up to parent and try again
            # top-level's parent is itself
            if current_section.parent is current_section:
                # reached top level, time to give up
                break
            current_section = current_section.parent

        # restore interpolation to previous value before returning
        self.section.main.interpolation = save_interp
        if val is None:
            raise MissingInterpolationOption(key)
        return val, current_section
913157
public void remove(String key) {
        int i = indexOfKey(key);
        if (i != NotFound)
            remove(i);
    }
1035790
public boolean containsKey(Object key) {
        if( !cache.containsKey(key) ) {
            return false;
        }
        else {
            SoftReference<T> ref = cache.get(key);
            T ob = ref.get();
            
            if( ob == null ) {
                release(key);
                return false;
            }
            if( ob instanceof CachedItem ) {
                if( !((CachedItem)ob).isValidForCache() ) {
                    release(key);
                    return false;
                }
            }
            return true;
        }
    }
411936
public T getObject(String key) {
        if (this.objects.containsKey(key)) {
            return this.objects.get(key);
        }
        return null;
    }
761802
public String get(String key) {
		addToDefaults(key, null);
		unrequestedParameters.remove(key);
		return data.get(key);
	}
547357
private String getKey(Object key) {
        if (key == null) {
            throw new IllegalArgumentException("Cache key not be null");
        }

        return ObjectUtils.toString(key);
    }
427738
public V retrieve(K key) {
        Ref<V> ref = map.get(key);
        return ref == null ? null : ref.get();
    }