Removes the mapping for a key from this Dictionary

@param key the key.
@return this MutableDocument instance
347473
@NonNull
    @Override
    public MutableDocument remove(@NonNull String key) {
        ((MutableDictionary) internalDict).remove(key);
        return this;
    }
1020577
@Override
    public V remove(Object key) {
        if (fast) {
            synchronized (this) {
                Map<K, V> temp = cloneMap(map);
                V result = temp.remove(key);
                map = temp;
                return (result);
            }
        } else {
            synchronized (map) {
                return (map.remove(key));
            }
        }
    }
1018939
@Override
	public Object remove(java.lang.Object key) {
		return internalMap.remove(key);
	}
347969
public boolean remove(String key) {

	if (pageSources.remove(key.toLowerCase()) != null) return true;

	Set<String> set = pageSources.keySet();
	String[] keys = set.toArray(new String[set.size()]); // done this way to avoid ConcurrentModificationException
	PageSource ps;
	for (String k: keys) {
	    ps = pageSources.get(k);
	    if (key.equalsIgnoreCase(ps.getClassName())) {
		pageSources.remove(k);
		return true;
	    }
	}
	return false;
    }
23113
public Object remove(Object key)
    {
        if (key == null) return null;
        purge();
        int hash = hashCode(key);
        int index = indexFor(hash);
        Entry previous = null;
        Entry entry = table[index];
        while (entry != null)
        {
            if ((hash == entry.hash) && equals(key, entry.getKey()))
            {
                if (previous == null)
                    table[index] = entry.next;
                else
                    previous.next = entry.next;
                this.size--;
                modCount++;
                return entry.getValue();
            }
            previous = entry;
            entry = entry.next;
        }
        return null;
    }
59221
public Object remove(String key)
    {
        if (key==null)
        {
            Object oldValue=_nullValue;
            if (_nullEntry!=null)
            {
                _entrySet.remove(_nullEntry);   
                _nullEntry=null;
                _nullValue=null;
            }
            return oldValue;
        }
        
        Node node = _root;
        int ni=-1;

        // look for best match
    charLoop:
        for (int i=0;i<key.length();i++)
        {
            char c=key.charAt(i);

            // Advance node
            if (ni==-1)
            {
                ni=0;
                node=(node._children==null)?null:node._children[c%_width];
            }
            
            // While we have a node to try
            while (node!=null) 
            {
                // If it is a matching node, goto next char
                if (node._char[ni]==c || _ignoreCase&&node._ochar[ni]==c)
                {
                    ni++;
                    if (ni==node._char.length)
                        ni=-1;
                    continue charLoop;
                }

                // No char match, so if mid node then no match at all.
                if (ni>0) return null;

                // try next in chain
                node=node._next;         
            }
            return null;
        }

        if (ni>0) return null;
        if (node==null || node._key==null)
            return null;
        
        Object old = node._value;
        _entrySet.remove(node);
        node._value=null;
        node._key=null;
        
        return old; 
    }
564234
@NonNull
    @Override
    public MutableDocument setDictionary(@NonNull String key, Dictionary value) {
        return setValue(key, value);
    }
359110
public V remove (Object key)
    {
        V removed = _delegate.remove(key);
        entryRemoved(removed);
        return removed;
    }
704557
public MapUpdate removeSet(String key)
    {
        BinaryValue k = BinaryValue.create(key);
        removes.add(new MapOp.MapField(MapOp.FieldType.SET, k));
        return this;
    }
631130
public LabelService delete(String key)
    {
        HTTP.DELETE(String.format("/v2/labels/%s.json", encode(key)));       
        return this;
    }
490317
public void removeByKey(Object key)
    {
        Object value = keyTable.remove(key);
        if (value != null)
        {
            valueTable.remove(value);
        }
    }
151827
public int remove(Object key)
  {
    if (key == null)
      key = NULL_KEY;

    int hash = key.hashCode() & _mask;

    synchronized (this) {
      Item prev = null;
      for (Item item = _entries[hash]; item != null; item = item._next) {
        Object itemKey = item._key;
      
        if (itemKey == key || itemKey.equals(key)) {
          int oldValue = item._value;

          if (prev != null)
            prev._next = item._next;
          else
            _entries[hash] = item._next;

          _size--;

          return oldValue;
        }

        prev = item;
      }
    }

    return NULL;
  }
21486
def remove(self, key):
        ''''''
        copydict = ImmutableDict()
        copydict.tree = self.tree.remove(hash(key))
        copydict._length = self._length - 1
        return copydict
1102820
@Override
    public GroovyRunner remove(Object key) {
        if (key == null) {
            return null;
        }
        Map<String, GroovyRunner> map = getMap();
        writeLock.lock();
        try {
            cachedValues = null;
            return map.remove(key);
        } finally {
            writeLock.unlock();
        }
    }
447140
public AceComponent remove(String key) throws IOException {
    return this.update(key, "", false, false, true);
  }
259769
@Override
    public V remove(Object key) {
        if (isReadyOnly())
            throw new UnsupportedOperationException("Can't remove property from read-only dictionary");

        return this.localMap.remove(key);
    }
1299122
public final boolean remove(Object key) {
        java.util.Set subSet = getSubSet(key);
        synchronized (subSet) {
            return subSet.remove(key);
        } // synchronized (subSet).
    }