Removes the given key from this Counter. Its count will now be 0 and it
will no longer be considered previously seen.
436928
public double remove(E key) {
    totalCount -= getCount(key); // subtract removed count from total (may be 0)
    MutableInteger val = map.remove(key);
    if (val == null) {
      return Double.NaN;
    } else {
      return val.doubleValue();
    }
  }
934750
public void removeIgnoreCase(String key) {
        int i = indexOfKeyIgnoreCase(key);
        if (i != NotFound)
            remove(i);
    }
913157
public void remove(String key) {
        int i = indexOfKey(key);
        if (i != NotFound)
            remove(i);
    }
882526
public Object remove(Object key) {
        mCacheMap.remove(key);
        return mBackingMap.remove(key);
    }
1277044
public static final void remove(String key) {
        Map<String, Object> ctx = CTX_HOLDER.get();
        if (ctx != null) {
            ctx.remove(key);
        }
    }
925814
def clear_lock(self, key):
        
        lock_path = self._get_lock_path(key)
        os.remove(lock_path)
920311
public T remove(final int key) {
		int index = ((key & 0x7FFFFFFF) % elementKeys.length);

		int entry = elementKeys[index];
		if (key == entry) {
			final T oldvalue = elementValues[index];
			elementKeys[index] = Integer.MIN_VALUE;
			elementValues[index] = null;
			elementCount--;
			return oldvalue;
		}
		return null;
	}
147782
@SuppressWarnings("unchecked")
    public V remove(final int key)
    {
        V value = null;
        @DoNotSub final int setNumber = Hashing.hash(key, mask);
        @DoNotSub final int setBeginIndex = setNumber << setSizeShift;

        for (@DoNotSub int i = setBeginIndex, nextSetIndex = setBeginIndex + setSize; i < nextSetIndex; i++)
        {
            if (null == values[i])
            {
                break;
            }

            if (key == keys[i])
            {
                value = (V)values[i];
                shuffleUp(i, nextSetIndex - 1);
                --size;

                evictionConsumer.accept(value);
                break;
            }
        }

        return value;
    }
948561
function(key) {
        this._removeAddsOrRemoves(this.counters.increment, key);
        if (this.counters.remove.indexOf(key) === -1) {
            this.counters.remove.push(key);
        }
        return this;
    }
490317
public void removeByKey(Object key)
    {
        Object value = keyTable.remove(key);
        if (value != null)
        {
            valueTable.remove(value);
        }
    }
108613
def pop(self, key):
        
        r = self[key]
        self.remove(key)
        return r
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;
    }
1228774
public void remove(String key) {
        Map<String, String> map = inheritableThreadLocal.get();
        if (map != null) {
            map.remove(key);
        }
    }
17817
async def delete(self, key):
        
        response = await self._discard(key)
        return response.body is True
538434
def remove(self, key):
        

        data = self._load_file()
        del data[key]
        self._save_file(data)
36905
public void remove(int key) {
        int i = binarySearch(mKeys, 0, mSize, key);
        if (i >= 0 && mValues[i] != DELETED) {
            mValues[i] = DELETED;
            mGarbage = true;
        }
    }
356736
public MapUpdate removeCounter(String key)
    {
        BinaryValue k = BinaryValue.create(key);
        removes.add(new MapOp.MapField(MapOp.FieldType.COUNTER, k));
        return this;
    }