Returns the key corresponding to the specified Entry.
@throws NoSuchElementException if the Entry is null
17287
static <K> K key(TreeMapEntry<K,?> e) {
        if (e==null)
            throw new NoSuchElementException();
        return e.key;
    }
1060173
public synchronized int getKey(String k) {
        for (int i = nkeys; --i >= 0;)
            if ((keys[i] == k) ||
                (k != null && k.equalsIgnoreCase(keys[i])))
                return i;
        return -1;
    }
268583
public static ChainStartMode getKey(int ordinal) {
        if (ordinal >= 0 && ordinal < _values.length) {
            return _values[ordinal];
        }
        return null;
    }
985313
public K getCurrentKey()
    {
        lock.lock();
        try
        {
            Thread currentThread = Thread.currentThread();
            for (Entry<K,Thread> entry : threadMap.entrySet())
            {
                if (currentThread.equals(entry.getValue()))
                {
                    return entry.getKey();
                }
            }
            return null;
        }
        finally
        {
            lock.unlock();
        }
    }
37783
public Key floor(Key k) {
		if (st.containsKey(k)) return k;

		// does not include key if present (!)
		SortedMap<Key, Value> head = st.headMap(k);
		if (head.isEmpty()) return null;
		else return head.lastKey();
	}
443930
protected function get_key_from_position() {
        $keylist = array_keys($this->userlists);
        if (isset($keylist[$this->iteratorposition])) {
            return $keylist[$this->iteratorposition];
        }

        return null;
    }
360061
public E get (Comparable<?> key)
    {
        // determine where we'll be adding the new element
        int eidx = ArrayUtil.binarySearch(
            _entries, 0, _size, new SimpleEntry<Comparable<?>>(key), ENTRY_COMP);
        return (eidx < 0) ? null : _entries[eidx];
    }
904532
public static Integer getKeyEvent(String key) throws NoSuchElementException
	{
		key = key.toUpperCase();
		Integer _result = theKeyTable.get(key);
		if (null == _result)
		{
			throw new NoSuchElementException(key);
		}
		return (_result);
	}
1137884
@Override
    public Entry<K, V> floorEntry(K key)
    {
        Entry<K, V> entry = entry(key, null);
        return entrySet.floor(entry);
    }
282816
public function getKey($value) {
		foreach ($this->collection as $k => $v) {
			if ($v === $value) {
				return $k;
			}
		}
		
		return null;
	}
1116169
public function key()
    {
        $key = null;
        if (count($this->_names) > 0) {
            $names = array_flip($this->_names);
            $key = $names[$this->_position];
        }
        return $key;

    }
326709
@Override
    public K higherKey(K key)
    {
        Entry<K, V> entry = entry(key, null);
        Entry<K, V> higher = entrySet.higher(entry);
        if (higher != null)
        {
            return higher.getKey();
        }
        return null;
    }
715220
public int getIndex(Object item) {
	  if (!itemIndex.containsKey(item)) {
	    throw new NoSuchElementException("No such item: " + item);
	  }
		return itemIndex.get(item);
	}
293836
public Map.Entry<K, V> ceil(K k) {
        if (contains(k)) {
            return mHashMap.get(k).mPrevious;
        }
        return null;
    }
759068
final TreeMapEntry<K,V> getEntryUsingComparator(Object key) {
        @SuppressWarnings("unchecked")
            K k = (K) key;
        Comparator<? super K> cpr = comparator;
        if (cpr != null) {
            TreeMapEntry<K,V> p = root;
            while (p != null) {
                int cmp = cpr.compare(k, p.key);
                if (cmp < 0)
                    p = p.left;
                else if (cmp > 0)
                    p = p.right;
                else
                    return p;
            }
        }
        return null;
    }
1213144
public int lookupIndex (Object entry)
    {
        if (entry == null)
            throw new IllegalArgumentException ("Can't lookup \"null\" in an Alphabet.");
        int ret = map.get(entry);
        if (ret <= 0 && !growthStopped) {
            numEntries++;
            ret = numEntries;
            map.put(entry, ret);
        }
        return ret;
    }
1114939
public function key()
    {
        // TODO: Track position internally to avoid repeated info() calls
        if ( ! $this->useIdentifierKeys) {
            $info = $this->riakCursor->info();

            return isset($info['at']) ? $info['at'] : null;
        }

        return $this->riakCursor->key();
    }