Removes the first count occurrences of elements equal to value
from the list stored at key.
180505
function lrem(key, count, value, req) {
  var val = this.getKey(key, req);
  if(val === undefined) return 0;
  var deleted = val.lrem(count, value);
  if(val.llen() === 0) {
    this.delKey(key, req);
  }
  return deleted;
}
639252
public int removeKey(String inputKey) {
        String key = Normalizer.normalize(inputKey, Normalizer.NORMALIZE_LOWER);
        int num_removed = 0;
        List<String> vals = this.values.remove(key);
        if (null != vals) {
            num_removed = vals.size();
        }
        this.num_items -= num_removed;
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "removeKey: key=" + key + " " + num_removed);
        }
        return num_removed;
    }
572612
public synchronized void removeLeastUsedElements()
    {    
        int rows = this.removePercent / 100 *  this.length;
        rows     = rows == 0 ? 1 : rows;
        
        while(rows > 0 && this.length > 0) {
            // remove the last element
            Entry<E, T> entry = this.tail.prev;
            
            this.tail.prev = entry.prev;
            entry.prev.next = this.tail;
            map.remove(entry.key);
            this.length--;
            rows--;
        }
    }
457955
protected synchronized void removeSemiUniqueEntry(SingleEntry key)
    {
        int hash = key.getSemiUniqueHash();
        SemiUniqueEntry[] tab = getNonDatedTable();
        int i = indexFor(hash, tab.length);
        SemiUniqueEntry prev = tab[i];
        SemiUniqueEntry e = prev;

        while (e != null)
        {
            SemiUniqueEntry next = e.getSemiUniqueNext();
            Object oldValue = e.removeEntryUsingIdentity(hash, key);
            if (oldValue != null)
            {
                if (e.isEmptyAfterRemoval())
                {
                    removeFromNonDatedTable(prev, e, next, tab, i);
                }
                return;
            }
            prev = e;
            e = next;
        }
    }
362168
public void removeEntry(Data key, Object value, Index.OperationSource operationSource) {
        InternalIndex[] indexes = getIndexes();
        for (InternalIndex index : indexes) {
            index.removeEntry(key, value, operationSource);
        }
    }
745675
@Override
  public boolean removeIfEquals(K key, V _value) {
    Entry e = lookupEntry(key);
    if (e == null) {
      metrics.peekMiss();
      return false;
    }
    synchronized (e) {
      e.waitForProcessing();
      if (e.isGone()) {
        metrics.peekMiss();
        return false;
      }
      boolean f = e.hasFreshData(clock);
      if (f) {
        if (!e.equalsValue(_value)) {
          return false;
        }
      } else {
        metrics.peekHitNotFresh();
        return false;
      }
      removeEntry(e);
      return f;
    }
  }
272899
function (key) {
      var entry = this._byKey.del(key);
      if (!entry) return;

      delete this._byOrder[entry.index];
      this._len--;

      if (this._len === 0) {
        this._head = this._tail = 0;
      } else {
        // update most index if it was most lecently used entry
        if (entry.index === this._head - 1) this._pop();
        // update least index if it was least lecently used entry
        if (entry.index === this._tail) this._shift();
      }

      return entry.val;
    }
195631
def remove(self, item, count=0):
        
        self._client.lrem(self.key_prefix, count, self._dumps(item))
301528
private boolean removeMapping(Object key, Object value) {
        Object k = maskNull(key);
        Object[] tab = table;
        int len = tab.length;
        int i = hash(k, len);

        while (true) {
            Object item = tab[i];
            if (item == k) {
                if (tab[i + 1] != value)
                    return false;
                modCount++;
                size--;
                tab[i] = null;
                tab[i + 1] = null;
                closeDeletion(i);
                return true;
            }
            if (item == null)
                return false;
            i = nextKeyIndex(i, len);
        }
    }
1268256
def clean(self):
        
        for key, value in self.values.copy().items():
            if value is None:
                del self.values[key]
1143689
public static void raw_remove(Key key) {
    Value v = STORE.remove(key);
    if( v != null ) v.removePersist();
  }
1319181
public static <E> void removeKeys(Counter<E> counter, Collection<E> removeKeysCollection) {

    for (E key : removeKeysCollection)
      counter.remove(key);
  }
375334
public void pruneZeroCounts() {
        int i = 0;
        while (i < rankedItems.size()) {
            if (rankedItems.get(i).getCount() == 0) {
                rankedItems.remove(i);
            } else {
                i++;
            }
        }
    }
346672
def removeLT(self, item):
        """"""
        count = self.getCountLT(item)
        self._list = self._list[count:]
        return count
884741
protected int removeImpl (int key, int defval)
    {
        int index = Math.abs(key)%_buckets.length;
        Record prev = null;

        // go through the chain looking for a match
        for (Record rec = _buckets[index]; rec != null; rec = rec.next) {
            if (rec.key == key) {
                if (prev == null) {
                    _buckets[index] = rec.next;
                } else {
                    prev.next = rec.next;
                }
                _size--;
                return rec.value;
            }
            prev = rec;
        }

        return defval; // not found
    }
934911
def discard(self, value):
        
        _set = self._set
        if value in _set:
            _set.remove(value)
            self._list.discard(value)
56465
def remove_values(self, keys):
        """"""
        data = self.model.get_data()
        for key in sorted(keys, reverse=True):
            data.pop(key)
            self.set_data(data)