remove the given element from the cache set

@param key    key
@param member the element to remove
@return the removed elements count
487322
public static Single<Long> remove(String key, Object member) {
        return remove(CacheService.CACHE_CONFIG_BEAN, key, member);
    }
819007
protected void removeElement(Ehcache cache, Element element) {
        final Set<CacheEntryTag> tags = this.getTags(element);

        // Check if the key is tagged
        if (tags != null && !tags.isEmpty()) {
            final String cacheName = cache.getName();
            final LoadingCache<CacheEntryTag, Set<Object>> cacheKeys =
                    taggedCacheKeys.getIfPresent(cacheName);

            // If there are tracked tagged keys remove matching tags
            if (cacheKeys != null) {
                final Object key = element.getObjectKey();

                logger.debug(
                        "Tracking removing key cache {} with tag {} : {}", cacheName, tags, key);

                for (final CacheEntryTag tag : tags) {
                    final Set<Object> taggedKeys = cacheKeys.getIfPresent(tag);

                    // Remove the tagged key
                    if (taggedKeys != null) {
                        taggedKeys.remove(key);
                    }
                }
            }
        }
    }
1242659
protected DoubleLinkedElement<T> removeElem(final T key) {
    DoubleLinkedElement<T> found = (DoubleLinkedElement<T>) (super
        .removeElem(key));
    if (found == null) {
      return null;
    }

    // update linked list
    if (found.after != null) {
      found.after.before = found.before;
    }
    if (found.before != null) {
      found.before.after = found.after;
    }
    if (head == found) {
      head = head.after;
    }
    if (tail == found) {
      tail = tail.before;
    }
    return found;
  }
920311
public T remove(final int key) {
		int index = ((key & 0x7FFFFFFF) % elementKeys.length);

		int entry = elementKeys[index];
		if (key == entry) {
			final T oldvalue = elementValues[index];
			elementKeys[index] = Integer.MIN_VALUE;
			elementValues[index] = null;
			elementCount--;
			return oldvalue;
		}
		return null;
	}
857301
public boolean remove(K key) {
        if (null == key)
            return false;
        CacheReference<K> keyRef = lookupFactory.createKey(key, queue);
        return CacheKey.class.cast(keyRef).removeCacheEntry();
    }
989927
public V remove(Object key) {
        final int index = indexOfKey(key);
        if (index >= 0) {
            return removeAt(index);
        }

        return null;
    }
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);
            }
        }
    }
1263869
static void removeFromCache(String key) {
        HashMap<String, MPApiResponse> mapCache = getMapCache();
        mapCache.remove(key);
    }
944590
public synchronized void removeMember(BalancerMember member) {
        if (members.remove(member)) {
            logger.info("Removing balancer member '{}' from balancer '{}'", member.getName(), name);
        }
    }
1239828
public synchronized void remove(final String key) {
		try {
			list.remove(key);
		} catch (Exception e) {
			log.log(Level.SEVERE, "remove", e);
		}
		super.remove(key);
	}
394023
public int removeKey(final K key)
    {
        @DoNotSub final int mask = values.length - 1;
        @DoNotSub int index = Hashing.hash(key, mask);

        int value;
        while (missingValue != (value = values[index]))
        {
            if (key.equals(keys[index]))
            {
                keys[index] = null;
                values[index] = missingValue;
                --size;

                compactChain(index);
                break;
            }

            index = ++index & mask;
        }

        return value;
    }
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);
	}
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);
    }
541213
public V remove(Object key) {
        List<V> res = map.remove(key);
        if (res == null) {
            return null;
        }
        assert (!res.isEmpty());
        return res.iterator().next();
    }
258336
private void remove(K key, boolean withMissCount) {
		writeLock.lock();
		CacheObj<K, V> co;
		try {
			co = cacheMap.remove(key);
			if (withMissCount) {
				this.missCount--;
			}
		} finally {
			writeLock.unlock();
		}
		if (null != co) {
			onRemove(co.key, co.obj);
		}
	}
777562
public function sremove($key, $member)
    {
        try {
            return $this->redis->sremove($key, $member);
        } catch (\RedisException $e) {
            die("Error!: " . $e->getMessage() . "<br/>");
        }
    }
876919
public static Single<Boolean> exists(String key, Object member) {
        return exists(CacheService.CACHE_CONFIG_BEAN, key, member);
    }