Get the named binary store that contains the key

@param key the key to the binary content; never null
@return the BinaryStore that contains the given key
505419
public BinaryStore findBinaryStoreContainingKey( BinaryKey key ) {
        Iterator<Map.Entry<String, BinaryStore>> binaryStoreIterator = getNamedStoreIterator();

        while (binaryStoreIterator.hasNext()) {
            BinaryStore bs = binaryStoreIterator.next().getValue();
            if (bs.hasBinary(key)) {
                return bs;
            }
        }

        return null;
    }
461466
@Override
    public byte[] get(byte[] key) {
        if (key == null) {
            return null;
        }
        byte[] value = null;
        Jedis jedis = getJedis();
        try {
            value = jedis.get(key);
        } finally {
            jedis.close();
        }
        return value;
    }
742188
public synchronized XAttribute get(Object key) {
		if(backingStore != null) {
			return backingStore.get(key);
		} else {
			return null;
		}
	}
229396
public byte[] getAsByteArray(String key) {
        Object value = mValues.get(key);
        if (value instanceof byte[]) {
            return (byte[]) value;
        } else {
            return null;
        }
    }

    /**
     * Returns a set of all of the keys and values
     *
     * @return a set of all of the keys and values
     */
    public Set<Map.Entry<String, Object>> valueSet() {
        return mValues.entrySet();
    }

    /**
     * Returns a set of all of the keys
     *
     * @return a set of all of the keys
     */
    public Set<String> keySet() {
        return mValues.keySet();
    }

    /**
     * Unsupported, here until we get proper bulk insert APIs.
     * {@hide}
     */
    @Deprecated
    public void putStringArrayList(String key, ArrayList<String> value) {
        mValues.put(key, value);
    }

    /**
     * Unsupported, here until we get proper bulk insert APIs.
     * {@hide}
     */
    @SuppressWarnings("unchecked")
    @Deprecated
    public ArrayList<String> getStringArrayList(String key) {
        return (ArrayList<String>) mValues.get(key);
    }

    /**
     * Returns a string containing a concise, human-readable description of this object.
     * @return a printable representation of this object.
     */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (String name : mValues.keySet()) {
            String value = getAsString(name);
            if (sb.length() > 0) sb.append(" ");
            sb.append(name + "=" + value);
        }
        return sb.toString();
    }
867309
public T get(Object key) {
        SoftReference<T> ref = cache.get(key);
        T ob;
        
        if( ref == null ) {
            return null;
        }
        ob = ref.get();
        if( ob == null ) {
            release(key);
        }
        if( ob instanceof CachedItem ) {
            if( !((CachedItem)ob).isValidForCache() ) {
                release(key);
                return null;
            }
        }
        return ob;
    }
394716
protected final Bucket<K, V> getBucketForKey(K key) {
        int bucket_index = (key.hashCode() & 0x7FFFFFFF) % buckets.length;
        Bucket<K, V> thebucket = buckets[bucket_index];
        if (thebucket == null) {
            synchronized (this) {
                thebucket = buckets[bucket_index];
                if (thebucket == null) {
                    thebucket = new Bucket<K, V>();
                    buckets[bucket_index] = thebucket;
                } // if
            } // sync
        } // if
        return thebucket;
    }
1369296
public boolean containsUsedBytesOnTiers(
      java.lang.String key) {
    if (key == null) { throw new java.lang.NullPointerException(); }
    return internalGetUsedBytesOnTiers().getMap().containsKey(key);
  }
985872
public V get(K key) {
        return get(key.hashCode() / SIZE_ROW, key.hashCode() % SIZE_ROW);
    }
657732
public LocalFsBlobStoreFile read(String key) throws IOException {
        return new LocalFsBlobStoreFile(getKeyDir(key), BlobStoreFile.BLOBSTORE_DATA_FILE);
    }
849904
public Tag get(String key) {
    int idx = binarySearch(tagArray, key);
    if (idx < 0) {
      return null;
    } else {
      return tagArray[idx];
    }
  }
716397
public static KeyStore keyStore(AbstractConfig config, String key) {
    final String keyStoreType = config.getString(key);
    try {
      return KeyStore.getInstance(keyStoreType);
    } catch (KeyStoreException e) {
      ConfigException exception = new ConfigException(
          key,
          keyStoreType,
          "Invalid KeyStore type."
      );
      exception.initCause(e);
      throw exception;
    }
  }
149677
public V get(K key) {
    if (root == null) {
      return null;
    }
    return root.get(key, key.hashCode(), 0);
  }
314234
private Node<K, V> getNodeFromStore(final int nodeid) {
		final int index = nodeid < 0 ? -nodeid : nodeid;
		final ByteBuffer buf = storage.get(index);
		final Node<K, V> node = Node.deserialize(buf, this);
		if (rootIdx == node.id) {
			log.warn(this.getClass().getName() + "::getNodeFromStore(" + nodeid + ") WARN LOADED ROOT NODE");
		}
		storage.release(buf);
		if (enableIOStats) {
			getIOStat(nodeid).incPhysRead();
		}
		return node;
	}
730560
public int binarySearch(RowPosition key)
    {
        int low = 0, mid = offsetCount, high = mid - 1, result = -1;
        while (low <= high)
        {
            mid = (low + high) >> 1;
            result = -DecoratedKey.compareTo(partitioner, ByteBuffer.wrap(getKey(mid)), key);
            if (result > 0)
            {
                low = mid + 1;
            }
            else if (result == 0)
            {
                return mid;
            }
            else
            {
                high = mid - 1;
            }
        }

        return -mid - (result < 0 ? 1 : 2);
    }
48979
@Override
    public V get(Object key)
    {
        BinarySet<Entry<K,V>> es = (BinarySet<Entry<K,V>>) entrySet;
        Entry<K, V> entry = entry((K) key, null);
        Entry<K, V> res = es.get(entry);
        if (res != null)
        {
            return res.getValue();
        }
        return null;
    }
402223
public byte getByte(String key) {
		addToDefaults(key, null);
		String value = getRequired(key);
		return Byte.valueOf(value);
	}
546528
final public Vector vector(K key)
    {
        Vector vector = storage.get(key);
        if (vector == null) return null;
        return vector;
    }