remove the given element from the cache set

@param cacheConfigBean datasource configuration
@param key             the key
@param member          element to be removed
@return the removed elements count
15338
public static Single<Long> remove(CacheConfigBean cacheConfigBean, String key, Object member) {
        Set<Object> members = new HashSet<>();
        members.add(member);
        return removes(cacheConfigBean, key, members);
    }
479135
public String remove(final String key) {
        final String result = data.getValue(key);
        data.remove(key);
        return result;
    }
857301
public boolean remove(K key) {
        if (null == key)
            return false;
        CacheReference<K> keyRef = lookupFactory.createKey(key, queue);
        return CacheKey.class.cast(keyRef).removeCacheEntry();
    }
1239254
@Override
    public CompletableFuture<Void> removeAsync(String key) {
        return (CompletableFuture) send("DEL", null, (Type) null, key, key.getBytes(UTF8));
    }
802354
public void removeMember(AsteriskQueueMemberImpl member)
    {
        synchronized (members)
        {
            // Check if member exists
            if (!members.containsValue(member))
            {
                return;
            }
            // If so, remove the member.
            logger.info("Remove member from the queue " + getName() + ": "
                    + member.toString());
            members.remove(member.getLocation());
        }

        fireMemberRemoved(member);
    }
609862
public void removeMember (FormationMember<T> member) {
		// Find the member's slot
		int slot = findMemberSlot(member);

		// Make sure we've found a valid result
		if (slot >= 0) {
			// Remove the slot
			// slotAssignments.removeIndex(slot);
			slotAssignmentStrategy.removeSlotAssignment(slotAssignments, slot);

			// Update the assignments
			updateSlotAssignments();
		}
	}
147782
@SuppressWarnings("unchecked")
    public V remove(final int key)
    {
        V value = null;
        @DoNotSub final int setNumber = Hashing.hash(key, mask);
        @DoNotSub final int setBeginIndex = setNumber << setSizeShift;

        for (@DoNotSub int i = setBeginIndex, nextSetIndex = setBeginIndex + setSize; i < nextSetIndex; i++)
        {
            if (null == values[i])
            {
                break;
            }

            if (key == keys[i])
            {
                value = (V)values[i];
                shuffleUp(i, nextSetIndex - 1);
                --size;

                evictionConsumer.accept(value);
                break;
            }
        }

        return value;
    }
1043876
protected void removeFromCache(String cacheName, String key) {
        try {
            ICache cache = getCache(cacheName);
            if (cache != null) {
                cache.delete(key);
            }
        } catch (CacheException e) {
            LOGGER.warn(e.getMessage(), e);
        }
    }
1156063
public void remove(String key) {
        PER_THREAD_CONTEXTS.getUnchecked(Thread.currentThread()).remove(key);
        mdcBridge.remove(key);
    }
1291792
public synchronized void remove(Object key)
	{
		final Object o = map.remove(key);
		if (o != null)
			tree.remove(o);
	}
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;
    }
9287
public void removeSessionProvider(Object key)
   {
      if (providers.containsKey(key))
      {
         getSessionProvider(key).close();
         providers.remove(key);
      }

      if (systemProviders.containsKey(key))
      {
         systemProviders.get(key).close();
         systemProviders.remove(key);
      }
   }
30390
public synchronized boolean removeConfiguration(String key) {
		try {
			if (catalog==null) {
				throw new FileNotFoundException();
			}
			return sync(()->inventory.remove(key)!=null);
		} catch (IOException e) {
			logger.log(Level.WARNING, "Failed to remove configuration.", e);
			return false;
		}
	}
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);
            }
        }
    }
490317
public void removeByKey(Object key)
    {
        Object value = keyTable.remove(key);
        if (value != null)
        {
            valueTable.remove(value);
        }
    }
824595
public V remove(K key) {
		writeLock.lock();
		try {
			return cache.remove(key);
		} finally {
			writeLock.unlock();
		}
	}
138564
public static void removeCache(Class<? extends BaseEntity> entityClass,String key){
    	if(CacheHandler.cacheProvider == null)return;
    	String entityClassName = entityClass.getSimpleName();
		key = entityClassName + CacheHandler.SPLIT_PONIT + key;
		String cacheGroupKey = entityClassName + CacheHandler.GROUPKEY_SUFFIX;
		
		CacheHandler.cacheProvider.remove(key);
		CacheHandler.cacheProvider.removeFromGroup(cacheGroupKey, key);
		
	}