Removes and returns a key-value mapping associated with the least key in this map, or null if the map
is empty.

@return entry
195194
public synchronized TreeEntry<K, V> pollFirstEntry() {
		final TreeEntry<K, V> entry = firstEntry();
		if (entry != null) {
			remove(entry.getKey());
		}
		return entry;
	}
1168986
public V remove(Object key) {
        clean();

        ValueRef<K, V> valueRef = mValues.remove(key);
        V value;

        if (valueRef != null && (value = valueRef.get()) != null) {
            valueRef.clear();
            return value;
        }

        return null;
    }
1206596
public T remove()
    {
        if ( size == 0 ) {
            return null;
        }
        
        //remove the first element
        Entry<T> o = head.next;
        head.next   = o.next;
        o.next.prev = head;
        
        //bakup the data
        T v         = o.data;
        size--;
        index.remove(v.getValue());
        
        o = null;            //Let gc do its work
        
        return v;
    }
787137
protected function get_key_from_position() {
        $keylist = array_keys($this->contextlists);
        if (isset($keylist[$this->iteratorposition])) {
            return $keylist[$this->iteratorposition];
        }

        return null;
    }
179925
public Record removeNullValueColumns() {
		for (java.util.Iterator<Entry<String, Object>> it = getColumns().entrySet().iterator(); it.hasNext();) {
			Entry<String, Object> e = it.next();
			if (e.getValue() == null) {
				it.remove();
			}
		}
		return this;
	}
287797
public Object remove(String key) {
        if (key != null) {
            return map.remove(key);
        }
        return null;
    }
250235
public function key(): string
    {
        if ($this->cacheEntriesIterator === null) {
            $this->rewind();
        }
        return substr($this->cacheEntriesIterator->key(), strlen($this->identifierPrefix . 'entry_'));
    }
394023
public int removeKey(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]))
            {
                keys[index] = null;
                values[index] = missingValue;
                --size;

                compactChain(index);
                break;
            }

            index = ++index & mask;
        }

        return value;
    }
1001213
public function getEntryMapper()
    {
        if (null === $this->entryMapper) {
            $this->entryMapper = $this->serviceLocator->get('playgroundgame_entry_mapper');
        }

        return $this->entryMapper;
    }
85977
public function trim($key = null)
    {
        if (null === $key) {
            foreach ($this->all() as $key => $value) {
                if (is_scalar($value)) {
                    $this->set($key, trim($value));
                }
            }
        } else {
            $value = $this->get($key);
            if (is_scalar($value)) {
                $this->set($key, trim($value));
            }
        }

        return $this;
    }
422659
public function doGetKey()
    {
        foreach ($this->data as $key => $value) {
            if ($this->value === $value) {
                return $key;
            }
        }

        return $this->default;
    }
1098147
@Override
    public K lowerKey(K key)
    {
        Entry<K, V> entry = entry(key, null);
        Entry<K, V> lower = entrySet.lower(entry);
        if (lower != null)
        {
            return lower.getKey();
        }
        return null;
    }
89398
public V remove(@NonNull K key) {
        Entry<K, V> toRemove = get(key);
        if (toRemove == null) {
            return null;
        }
        mSize--;
        if (!mIterators.isEmpty()) {
            for (SupportRemove<K, V> iter : mIterators.keySet()) {
                iter.supportRemove(toRemove);
            }
        }

        if (toRemove.mPrevious != null) {
            toRemove.mPrevious.mNext = toRemove.mNext;
        } else {
            mStart = toRemove.mNext;
        }

        if (toRemove.mNext != null) {
            toRemove.mNext.mPrevious = toRemove.mPrevious;
        } else {
            mEnd = toRemove.mPrevious;
        }

        toRemove.mNext = null;
        toRemove.mPrevious = null;
        return toRemove.mValue;
    }
344868
public function getEntryId()
    {
        $entryId = $this->get(static::$keyEntryId);
        if (!empty($entryId)) {
            $entryId = (int) $entryId;
        }
        return $entryId;
    }
140778
public OMVRBTreeEntry<K, V> getLowerEntry(final K key) {
    final OMVRBTreeEntry<K, V> p = getEntry(key, true, PartialSearchMode.LOWEST_BOUNDARY);

    if (p == null)
      return null;

    return previous(p);
  }
1265857
public V remove(K key) {
        final int hash = key.hashCode();
        final int row = hash / SIZE_ROW;
        final int column = hash & (SIZE_ROW - 1); // DON'T use the % operator as we
                                                  // need the result to be
                                                  // non-negative (-1%16 is -1 for
                                                  // example)
        final V rc = get(row, column);
        validateKey(hash);
        validateTable(row);
        this.values[row][column] = null;
        this.keys[hash] = null;
        return rc;
    }
1217252
public function remove()
    {
        if (isset($this->properties[$this->primaryKey])) {
            $this->exists = false;
            return static::deleteOne($this->client, $this->{$this->primaryKey});
        }

        throw new IdMissingException();
    }