Removes a key by adding a remove entry to the row.

The remove is represented as a delta entry so checkpoints can be
written asynchronously.

@return false if the new record cannot fit into the block.
580
boolean remove(RowCursor cursor)
  {
    int rowHead = _rowHead;
    int blobTail = _blobTail;
    
    rowHead -= cursor.removeLength();

    if (rowHead < blobTail) {
      return false;
    }
    
    byte []buffer = _buffer;
    
    // buffer[rowHead] = REMOVE;
    
    cursor.getRemove(buffer, rowHead);
    // cursor.getKey(buffer, rowHead + ColumnState.LENGTH);
    
    rowHead(rowHead);
    
    validateBlock(cursor.row());    
    
    return true;
  }
1098424
public Object remove(Serializable key) {
        if(component.initialStateMarked()) {
            Object retVal = deltaMap.remove(key);

            if(retVal==null) {
                return defaultMap.remove(key);
            }
            else {
                defaultMap.remove(key);
                return retVal;
            }
        }
        else {
            return defaultMap.remove(key);
        }
    }
795663
public boolean remove(final CacheKey key) {
    Preconditions.checkNotNull(key);
    final EncodedImage encodedImage;
    synchronized (this) {
      encodedImage = mMap.remove(key);
    }
    if (encodedImage == null) {
      return false;
    }
    try {
      return encodedImage.isValid();
    } finally {
      encodedImage.close();
    }
  }
395575
Entry remove()
  {
    if (tc.isEntryEnabled())
      SibTr.entry(tc, "remove");

    checkEntryParent();
    
    Entry removedEntry = null;    

    Entry prevEntry = getPrevious();
    if(prevEntry != null)
    {
      //link the previous entry to the next one
      prevEntry.next = next;
    }
    Entry nextEntry = getNext();
    if(nextEntry != null)
    {
      //link the next entry to the previous one
      nextEntry.previous = prevEntry;
    }
    if(isFirst())
    {
      //if this entry was the first in the list,
      //mark the next one as the first entry
      parentList.first = nextEntry;              
    }
    if(isLast())
    {
      //if this entry was the last in the list,
      //mark the previous one as the last entry
      parentList.last = prevEntry;              
    }
    
    //set all of this entry's fields to null to make it absolutely
    //sure that it is no longer in the list
    next = null;
    previous = null;
    parentList = null;
    
    removedEntry = this;
    
    if (tc.isEntryEnabled())
      SibTr.exit(tc, "remove", removedEntry);
      
    return removedEntry;
  }
930182
protected Record<V> removeImpl (int key, boolean checkShrink)
    {
        int index = keyToIndex(key);

        // go through the chain looking for a match
        for (Record<V> prev = null, 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--;
                if (checkShrink) {
                    checkShrink();
                }
                return rec;
            }
            prev = rec;
        }

        return null;
    }
1049420
public boolean remove(final VisitState k) {
		// The starting point.
		int pos = (int)(MurmurHash3.hash(k.schemeAuthority) & mask);
		// There's always an unused entry.
		while (visitState[pos] != null) {
			if (visitState[pos] == k) {
				size--;
				shiftKeys(pos);
				// TODO: implement resize
				return true;
			}
			pos = (pos + 1) & mask;
		}
		return false;
	}
744038
public boolean remove(Object obj) {
        Entry tab[] = mTable;

        if (obj == null) {
            obj = NULL;
        }

        int hash = obj.hashCode();
        int index = (hash & 0x7FFFFFFF) % tab.length;

        for (Entry e = tab[index], prev = null; e != null; e = e.mNext) {
            Object entryValue = e.get();

            if (entryValue == null) {
                // Clean up after a cleared Reference.
                mModCount++;
                if (prev != null) {
                    prev.mNext = e.mNext;
                }
                else {
                    tab[index] = e.mNext;
                }
                mCount--;
            }
            else if (e.mHash == hash) {
                mModCount++;
                if (prev != null) {
                    prev.mNext = e.mNext;
                }
                else {
                    tab[index] = e.mNext;
                }
                mCount--;

                return true;
            }
            else {
                prev = e;
            }
        }

        return false;
    }
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;
    }
426850
public final boolean remove(E entry) {
        TreeEntry<E> e = getEntry(entry);

        if (e == null) {
            return false;
        } else {
            deleteEntry(e);
        }

        return true;
    }
577807
protected boolean removeIterative(final K key) {
		final LeafNode<K, V> nodeLeaf = findLeafNode(key, true);
		//
		// Find in leaf node for key and delete it
		final int slot = nodeLeaf.findSlotByKey(key);
		if (slot >= 0) { // found
			// Remove Key
			nodeLeaf.remove(slot);
			putNode(nodeLeaf);
			// Iterate back over nodes checking underflow
			while (!stackNodes.isEmpty()) {
				final InternalNode<K, V> node = stackNodes.pop();
				final int slotcheck = stackSlots.pop();
				if (!node.checkUnderflow(slotcheck)) {
					return true;
				}
			}
			return true;
		}
		return false;
	}
1339200
public boolean removeImportedKey(ECKey key) {
        checkNotNull(key);
        checkArgument(!(key instanceof DeterministicKey));
        return basic.removeKey(key);
    }
53758
@Deprecated
  @Override
  public boolean remove(@Nullable final Object rowKey, @Nullable final Object columnKey,
      final Object value) {
    throw new UnsupportedOperationException();
  }
578624
def remove(self, key):
        """"""
        if key in self.queue:
            del self.queue[key]
            self.write()
            return True
        return False
985377
public boolean containsKey(Object key)
    {
        purge();
        Entry entry = getEntry(key);
        if (entry == null) return false;
        return entry.getValue() != null;
    }
525679
public boolean removeTable(BaseTable table)
    {
        if (m_mapTable != null)
        {
            for (Object objKey : m_mapTable.keySet())
            {
                if (table == m_mapTable.get(objKey))
                {
                    return (m_mapTable.remove(objKey) != null);
                }                
            }
        }
        else
        {
            if (this.getNextTable() != null)
                return this.getNextTable().removeTable(table);
        }
        return super.removeTable(table);
    }
662639
public boolean containsKey(Object key) {
        if (key == null) {
            return false;
        }

        Entry tab[] = mTable;
        int hash = System.identityHashCode(key);
        int index = (hash & 0x7FFFFFFF) % tab.length;

        for (Entry e = tab[index], prev = null; e != null; e = e.mNext) {
            Object entryKey = e.getKey();

            if (entryKey == null) {
                // Clean up after a cleared Reference.
                mModCount++;
                if (prev != null) {
                    prev.mNext = e.mNext;
                }
                else {
                    tab[index] = e.mNext;
                }
                mCount--;
            }
            else if (e.mHash == hash && key == entryKey) {
                return true;
            }
            else {
                prev = e;
            }
        }

        return false;
    }
541728
boolean remove(BlockInfo blockInfo, RaidCodec codec) {
    if(queues.get(codec).remove(blockInfo)) {
      if (NameNode.stateChangeLog.isDebugEnabled()) {
        NameNode.stateChangeLog.debug(
                                      "BLOCK* NameSystem.RaidMissingBlocks.remove:"
                                      + blockInfo
                                      + " file "+ blockInfo.getINode()
                                      + " codec " + codec.id);
      }
      return true;
    }
    return false;
  }