/*
(non-Javadoc)

@see java.util.Hashtable#remove(java.lang.Object)
977094
@Override
	public Object remove(final Object key) {
		lock.writeLock().lock();
		try {
			final boolean useLocalPrefixes = !mixDefaultAndLocalPrefixes && hasLocalPrefixConfigurations();
			final Object someKey = getPrefixedKey(key, useLocalPrefixes);
			Object result = properties.remove(someKey);
			if (result == null) {
				result = properties.remove(key);
			}
			return result;
		} finally {
			lock.writeLock().unlock();
		}
	}
654528
public final V remove(Object key) {
	
	if(key == null) return null;

	int key_hash_code = key.hashCode();
	BinTreeNode<K,V> prev = null;
	int son = 0;
	BinTreeNode<K,V> node = root;

	while(node != null) {
	    if(key_hash_code < node.keyHashCode) {
		prev = node;
		node = node.left;
		son  = 0;
	    }
	    else {
		if((key_hash_code > node.keyHashCode) || !node.key.equals(key)) {
		    prev = node;
		    node = node.right;
		    son  = 1;
		}
		else {
		    size--;
		    cachedHashCode -= node.hashCode();
		    return remove_node(node, prev, son);
		}
	    }
	}
	return null;
    }
604019
@Override
  public boolean remove(Object object) {
    if (object == null) {
      return false;
    }
    // Locking this object protects against removing the exact object that might be in the
    // process of being added, but does not protect against removing a distinct, but equivalent
    // object.
    synchronized (object) {
      if (mPrimaryIndex.containsObject((T) object)) {
        // This isn't technically typesafe. However, given that success is true, it's very unlikely
        // that the object passed to remove is not of type <T>.
        @SuppressWarnings("unchecked")
        T tObj = (T) object;
        removeFromIndices(tObj);
        return true;
      } else {
        return false;
      }
    }
  }
153949
public Object remove(int index) {
    Object o = opt(index);
    this.myArrayList.remove(index);
    return o;
  }
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;
    }
482900
public void removeFromInUse(Object o) {
        if (null == o) {
            throw new NullPointerException();
        }

        if (inUseTracking) {
            inUseTable.remove(o);
        }
    }
1290309
@Override
	public void remove(final Object key, final Class<?> clas) {
		this.logger.debug("@remove :".concat(key.toString()).concat(" with class : ".concat(clas.getName())));
		getCachableMap(clas).remove(key);
	}
1269632
@Override
    public Object remove(K key) {
        for (Map<K, V> bucket : buckets) {
            Object value = bucket.remove(key);
            if (value != null) {
                return value;
            }
        }
        return null;
    }
1279411
public final Object remove(Object key)
    {
        java.util.Map subMap = getSubMap(key);
        synchronized (subMap) {
            return subMap.remove(key);
        } // synchronized (subMap).
    }
587429
private void remove(Class<?> type, Object object)
    {
        final Set<?> set = items.get(type);
        if (set != null)
        {
            set.remove(object);
        }
    }
787655
public boolean removeObject (Object object)
    {
        for (int i = 0; i < _size; i++) {
            if (_records[i].object == object) {
                // shift everything down
                System.arraycopy(_records, i+1, _records, i, _size-(i+1));
                // clear out the trailing reference
                _records[--_size] = null;
                return true;
            }
        }

        return false;
    }
944906
public void clear(Object key) {
		Object removed;
		if (isCachingEnabled()) {
			synchronized (mirror) {
				synchronized (data) {
					removed = data.remove(key);
					mirror.remove(key);
				}
			}
			System.out.println(new LogEntry("object with key " + key + (removed == null ? " NOT" : "") + " removed from cache"));
		}
	}
465623
public synchronized void remove(Object key) {
        Object victim = null;
        if (cacheEvictionListenerSet.isEmpty() == false) {
            victim = get(key);
        }

        primaryTable.remove(key);
        secondaryTable.remove(key);
        tertiaryTable.remove(key);

        if (victim != null) {
            ArrayList<Object> evictedValues = new ArrayList<Object>();
            evictedValues.add(victim);
            for (CacheEvictionListener evictionCallback : cacheEvictionListenerSet) {
                evictionCallback.evicted(evictedValues);
            }
        }
    }
1155193
@SuppressWarnings("unchecked")
    public static <OBJ> OBJ removeObject(String key) {
        if (!exists()) {
            throwThreadCacheNotInitializedException(key);
        }
        return (OBJ) threadLocal.get().remove(key);
    }
440521
@Override
    public String remove(Object key) {

        String result = m_configurationStrings.remove(key);
        m_configurationObjects.remove(key);
        return result;
    }
287797
public Object remove(String key) {
        if (key != null) {
            return map.remove(key);
        }
        return null;
    }
737251
public void remove(Object key) {
		for (Scope cur=this; cur!=null; cur=cur.parent) {
			if (cur.data != null && cur.data.containsKey(key)) {
				cur.data.remove(key);
				return ;
			}
		}
	}