Performs the selective clearing for a given key.
@param k The false positive key to remove from <i>this</i> retouched Bloom filter.
@param scheme The selective clearing scheme to apply.
501248
public void selectiveClearing(Key k, short scheme) {
    if (k == null) {
      throw new NullPointerException("Key can not be null");
    }

    if (!membershipTest(k)) {
      throw new IllegalArgumentException("Key is not a member");
    }

    int index = 0;
    int[] h = hash.hash(k);

    switch(scheme) {

    case RANDOM:
      index = randomRemove();
      break;
    
    case MINIMUM_FN:
      index = minimumFnRemove(h);
      break;
    
    case MAXIMUM_FP:
      index = maximumFpRemove(h);
      break;
    
    case RATIO:
      index = ratioRemove(h);
      break;
    
    default:
      throw new AssertionError("Undefined selective clearing scheme");

    }

    clearBit(index);
  }
71134
public void deleteKey(HKey hk, String key) throws RegistryException {
		int rc = -1;
		try {
			rc = ReflectedMethods.deleteKey(hk.root(), hk.hex(), key);
		} catch (Exception e) {
			throw new RegistryException("Cannot delete key " + key, e);
		}
		if (rc != RC.SUCCESS) {
			throw new RegistryException("Cannot delete key " + key + ". Return code is " + rc);
		}
	}
819370
public void clear() {
    mMap.forEach((key, value) -> {
      onCacheUpdate(key, value.mValue);
      onRemove(key);
    });
    mMap.clear();
  }
84575
public void delete(Key key) {
    if(key == null) {
      throw new NullPointerException("Key may not be null");
    }
    if(!membershipTest(key)) {
      throw new IllegalArgumentException("Key is not a member");
    }

    int[] h = hash.hash(key);
    hash.clear();

    for(int i = 0; i < nbHash; i++) {
      // find the bucket
      int wordNum = h[i] >> 4;          // div 16
      int bucketShift = (h[i] & 0x0f) << 2;  // (mod 16) * 4
      
      long bucketMask = 15L << bucketShift;
      long bucketValue = (buckets[wordNum] & bucketMask) >>> bucketShift;
      
      // only decrement if the count in the bucket is between 0 and BUCKET_MAX_VALUE
      if(bucketValue >= 1 && bucketValue < BUCKET_MAX_VALUE) {
        // decrement by 1
        buckets[wordNum] = (buckets[wordNum] & ~bucketMask) | ((bucketValue - 1) << bucketShift);
      }
    }
  }
283153
public static void eraseKey(byte[] keyToErase) {
        if (keyToErase != null) {
            SecureRandom random;
            try {
                random = SecureRandom.getInstance("SHA1PRNG");
                random.nextBytes(keyToErase);
            } catch (NoSuchAlgorithmException e) {
                // never reached
            }
        }
    }
202867
public boolean removeReference(K key, ServiceReference<V> reference) {
        if (key == null || reference == null)
            return false;
        ConcurrentServiceReferenceElement<V> element = new ConcurrentServiceReferenceElement<V>(referenceName, reference);
        return elementMap.remove(key, element);
    }
678735
public void remove(K key) {

        V removedValue = m_forwardMap.remove(key);
        if (removedValue != null) {
            m_reverseMap.remove(removedValue, key);
        }
    }
956802
public boolean removeReference(K key, ServiceReference<V> reference) {
        if (key == null)
            return false;

        ConcurrentServiceReferenceSet<V> csrs = elementMap.get(key);
        if (csrs == null) {
            return false;
        }
        return csrs.removeReference(reference);
    }
50554
public static void remove(String key) {
        if (setContext()) {
            m_context.remove(key);
        } else {
            m_defaultContext.remove(key);
        }
    }
1274117
public void remove(K k) {
        if (cache.containsKey(k)) {
            cache.remove(k);
            locks.remove(k);
        }
    }
161
public void clearKSMap() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            Tr.debug(tc, "Clearing keystore maps");
        synchronized (keyStoreMap) {
            keyStoreMap.clear();
        }
    }
710775
@Override
	public void removeByKey(String key) {
		for (CPDefinitionOptionValueRel cpDefinitionOptionValueRel : findByKey(
				key, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
			remove(cpDefinitionOptionValueRel);
		}
	}
67408
public void clear(String cacheKey) {
        ValueCacheKey key = getRequestCacheKey(cacheKey);
        if (key != null) {
            ConcurrentHashMap<ValueCacheKey, HystrixCachedObservable<?>> cacheInstance = requestVariableForCache.get(concurrencyStrategy);
            if (cacheInstance == null) {
                throw new IllegalStateException("Request caching is not available. Maybe you need to initialize the HystrixRequestContext?");
            }

            /* remove this cache key */
            cacheInstance.remove(key);
        }
    }
857301
public boolean remove(K key) {
        if (null == key)
            return false;
        CacheReference<K> keyRef = lookupFactory.createKey(key, queue);
        return CacheKey.class.cast(keyRef).removeCacheEntry();
    }
846371
public void remove(String key) {
        String processedKey = processKey(key);
        String orderKey = null;

        // removing key set for all positions
        for (int i = 0; i < this.order.size(); i++) {
            orderKey = this.order.get(i);

            if (orderKey != null && orderKey.equals(processedKey) == true) {
                this.order.remove(i);
            }
        }

        this.types.remove(processedKey);
        this.direction.remove(processedKey);
        this.values.remove(processedKey);
    }
1056980
@GuardedBy("evictionLock")
  void drainKeyReferences() {
    if (!collectKeys()) {
      return;
    }
    Reference<? extends K> keyRef;
    while ((keyRef = keyReferenceQueue().poll()) != null) {
      Node<K, V> node = data.get(keyRef);
      if (node != null) {
        evictEntry(node, RemovalCause.COLLECTED, 0L);
      }
    }
  }
238830
public void deleteRow(Mutator<K> mutator, K key) {    
    mutator.addDeletion(key, columnFamily, null, topSerializer);
    executeIfNotBatched(mutator);
  }