Find key position in the map.

@param key
Key to look for
@return Key position or -1 if not found
357814
@CheckForSigned
  private int _getReadIndex (final int key)
  {
    int idx = MapHelper.phiMix (key) & m_nMask;
    if (m_aKeys[idx] == key)
    {
      // we check FREE prior to this call
      return idx;
    }
    if (m_aKeys[idx] == FREE_KEY)
    {
      // end of chain already
      return -1;
    }
    final int startIdx = idx;
    while ((idx = _getNextIndex (idx)) != startIdx)
    {
      if (m_aKeys[idx] == FREE_KEY)
        return -1;
      if (m_aKeys[idx] == key)
        return idx;
    }
    return -1;
  }
1030294
long get(final T key) {
    if (key == null) { return 0; }
    final int probe = hashProbe(key);
    if (states[probe] > 0) {
      assert (keys[probe]).equals(key);
      return values[probe];
    }
    return 0;
  }
689481
public int getIndex(Object key) {
    Integer i = (Integer) nset.get(key);
    if (i == null) {
      return -1;
    }
    else {
      return i.intValue();
    }
  }
1124168
private int getDataIndexOfKey(Object key) {
    int dataSize = this.size << 1;
    Object[] data = this.data;
    for (int i = 0; i < dataSize; i += 2) {
      Object k = data[i];
      if (key == null ? k == null : key.equals(k)) {
        return i;
      }
    }
    return -2;
  }
529228
@Override
    public int getInt(@NonNull String key) {
        if (key == null) { throw new IllegalArgumentException("key cannot be null."); }

        final int index = indexForColumnName(key);
        return index >= 0 ? getInt(index) : 0;
    }
1190953
public boolean containsKey(Object key)
    {
        if (key==null)
            return _nullEntry!=null;
        return
            getEntry(key.toString(),0,key==null?0:key.toString().length())!=null;
    }
1169407
public final String getStatus(final String key) {
        final Property prop = find(key);
        if (prop == null) {
            return null;
        }
        return prop.getStatus();
    }
544142
public static int getSlot(ByteBuffer key) {

        int limit = key.limit();
        int position = key.position();

        int start = indexOf(key, SUBKEY_START);
        if (start != -1) {
            int end = indexOf(key, start + 1, SUBKEY_END);
            if (end != -1 && end != start + 1) {
                key.position(start + 1).limit(end);
            }
        }

        try {
            if (key.hasArray()) {
                return CRC16.crc16(key.array(), key.position(), key.limit() - key.position()) % SLOT_COUNT;
            }
            return CRC16.crc16(key) % SLOT_COUNT;
        } finally {
            key.position(position).limit(limit);
        }
    }
394720
public boolean containsKey(String key) {
    key = key.toLowerCase();
    key = key.trim();
    return map.containsKey(key);
  }
1101846
public int getIndex(Object key) {
    int[] nums = (int[]) cset.get(key);
    if (nums == null) {
      return -1;
    }
    else {
      return nums[1];
    }
  }
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;
	}
1053453
private final java.util.Map getSubMap(final Object key)
    {
        // Defend against systematically changing hashcodes, for examples where consecutive
        // Integers are presented as keys. If we dont shuffle the hashcode then we may get a
        // bunch of requests that hit the same submap.
        int index = key.hashCode();
        index += ~(index << 8);
        index ^= (index >>> 9);
        // Index must be positive.
        index &= 0X7FFFFFFF;
        index = index % subMaps.length;
        if (gatherStatistics)
            subMapAccessFrequency[index]++;
        return subMaps[index];
        // return subMaps[new java.util.Random(key.hashCode()).nextInt(subMaps.length)];
    }
429594
public int indexOfKey(Object key) {
        return key == null ? indexOfNull() : indexOf(key, key.hashCode());
    }
1234501
public boolean containsKey(final int key)
    {
        @DoNotSub final int mask = values.length - 1;
        @DoNotSub int index = Hashing.hash(key, mask);

        boolean found = false;
        while (null != values[index])
        {
            if (key == keys[index])
            {
                found = true;
                break;
            }

            index = ++index & mask;
        }

        return found;
    }
65767
public int getValue(final K key)
    {
        @DoNotSub final int mask = values.length - 1;
        @DoNotSub int index = Hashing.hash(key, mask);

        int value;
        while (missingValue != (value = values[index]))
        {
            if (key.equals(keys[index]))
            {
                break;
            }

            index = ++index & mask;
        }

        return value;
    }
402453
public boolean containsKey(int key) {
        Entry tab[] = table;

        int index = (key & 0x7FFFFFFF) % tab.length;
        for (Entry e = tab[index]; e != null; e = e.next) {
            if (e.key == key) {
                return true;
            }
        }
        
        return false;
    }
879606
public boolean matchKey (final String key) {
        if (key == null) return false;
        for (int i = 0; i < values.length; ++i)
            if (values[i].equals(key)) return true;
        return false;
    }