Signals that an external node with the given key has been removed.

@param externalNodeKey a {@code non-null} String
489368
public void externalNodeRemoved( String externalNodeKey ) {
        if (this.snapshot.get().containsProjectionForExternalNode(externalNodeKey)) {
            // the external node was the root of a projection, so we need to remove that projection
            synchronized (this) {
                Snapshot current = this.snapshot.get();
                Snapshot updated = current.withoutProjection(externalNodeKey);
                if (current != updated) {
                    this.snapshot.compareAndSet(current, updated);
                }
            }
        }
    }
36905
public void remove(int key) {
        int i = binarySearch(mKeys, 0, mSize, key);
        if (i >= 0 && mValues[i] != DELETED) {
            mValues[i] = DELETED;
            mGarbage = true;
        }
    }
1099925
public static KV<String, Forest> remove(String key) {
        KV<String, Forest> kv = AMBIGUITY.get(key);
        if (kv != null && kv.getV() != null) {
            kv.getV().clear();
        }
        MyStaticValue.ENV.remove(key);
        return AMBIGUITY.remove(key);
    }
1058208
@Nullable V removeWithWriter(Object key) {
    @SuppressWarnings("unchecked")
    K castKey = (K) key;
    @SuppressWarnings({"unchecked", "rawtypes"})
    Node<K, V>[] node = new Node[1];
    @SuppressWarnings("unchecked")
    V[] oldValue = (V[]) new Object[1];
    RemovalCause[] cause = new RemovalCause[1];

    data.computeIfPresent(nodeFactory.newLookupKey(key), (k, n) -> {
      synchronized (n) {
        oldValue[0] = n.getValue();
        if (oldValue[0] == null) {
          cause[0] = RemovalCause.COLLECTED;
        } else if (hasExpired(n, expirationTicker().read())) {
          cause[0] = RemovalCause.EXPIRED;
        } else {
          cause[0] = RemovalCause.EXPLICIT;
        }
        writer.delete(castKey, oldValue[0], cause[0]);
        n.retire();
      }
      node[0] = n;
      return null;
    });

    if (cause[0] != null) {
      afterWrite(new RemovalTask(node[0]));
      if (hasRemovalListener()) {
        notifyRemoval(castKey, oldValue[0], cause[0]);
      }
    }
    return (cause[0] == RemovalCause.EXPLICIT) ? oldValue[0] : null;
  }
1128343
public boolean containsExternalValues(
      java.lang.String key) {
    if (key == null) { throw new java.lang.NullPointerException(); }
    return internalGetExternalValues().getMap().containsKey(key);
  }
12743
function removeNode(node, parentNode, skipKeyedNodes) {
            if (onBeforeNodeDiscarded(node) === false) {
                return;
            }

            if (parentNode) {
                parentNode.removeChild(node);
            }

            onNodeDiscarded(node);
            walkDiscardedChildNodes(node, skipKeyedNodes);
        }
1224072
public V remove(long key) {
		if (size == 0) {
			return null;
		}
		if (size == 1) {
			int posDiff = compare(key, rootKey);
			if (posDiff == -1) {
				size--;
				rootKey = 0;
				V prev = rootVal;
				rootVal = null;
				return prev;
			}
			return null;
		}
		Node<V> n = root;
		Node<V> parent = null;
		boolean isParentHigh = false;
		while (true) {
			if (!doesInfixMatch(n, key)) {
				return null;
			}
			
			//infix matches, so now we check sub-nodes and postfixes
			if (getBit(key, n.posDiff)) {
				if (n.hi != null) {
					isParentHigh = true;
					parent = n;
					n = n.hi;
					continue;
				} else {
					int posDiff = compare(key, n.hiPost);
					if (posDiff != -1) {
						return null;
					}
					//match! --> delete node
					//a) first recover other values
					long newPost = 0;
					if (n.lo == null) {
						newPost = n.loPost;
					}
					//b) replace data in parent node
					updateParentAfterRemove(parent, newPost, n.loVal, n.lo, isParentHigh, n);
					return n.hiVal;
				}
			} else {
				if (n.lo != null) {
					isParentHigh = false;
					parent = n;
					n = n.lo;
					continue;
				} else {
					int posDiff = compare(key, n.loPost);
					if (posDiff != -1) {
						return null;
					}
					//match! --> delete node
					//a) first recover other values
					long newPost = 0;
					if (n.hi == null) {
						newPost = n.hiPost;
					}
					//b) replace data in parent node
					//for new infixes...
					updateParentAfterRemove(parent, newPost, n.hiVal, n.hi, isParentHigh, n);
					return n.loVal;
				}
			}
		}
	}
728546
private void removeNode(Node node)
	{
		result.remove(node);

		for (Edge edge : node.getUpstream())
		{
			result.remove(edge);
		}

		for (Edge edge : node.getDownstream())
		{
			result.remove(edge);
		}
	}
179157
public void removeNode(Node n)
  {

    if (!m_mutable)
      throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");

    this.removeElement(n);
  }
50554
public static void remove(String key) {
        if (setContext()) {
            m_context.remove(key);
        } else {
            m_defaultContext.remove(key);
        }
    }
1249349
public V remove (K removeKey) {
        V removedValue = this.store.remove(removeKey);

        if ( removedValue != null ) {
            this.notificationExecutor.fireRemoveNotification(this.listeners.iterator(), removeKey, removedValue);
        }

        return  removedValue;
    }
991585
public boolean hasExternalProjection( String alias,
                                          String externalNodeKey ) {
        return this.snapshot.get().hasExternalProjection(alias, externalNodeKey);
    }
577807
protected boolean removeIterative(final K key) {
		final LeafNode<K, V> nodeLeaf = findLeafNode(key, true);
		//
		// Find in leaf node for key and delete it
		final int slot = nodeLeaf.findSlotByKey(key);
		if (slot >= 0) { // found
			// Remove Key
			nodeLeaf.remove(slot);
			putNode(nodeLeaf);
			// Iterate back over nodes checking underflow
			while (!stackNodes.isEmpty()) {
				final InternalNode<K, V> node = stackNodes.pop();
				final int slotcheck = stackSlots.pop();
				if (!node.checkUnderflow(slotcheck)) {
					return true;
				}
			}
			return true;
		}
		return false;
	}
816266
V removeMapping(final Object o) {
        if (!(o instanceof Map.Entry)) {
            throw new IllegalArgumentException();
        }

        @SuppressWarnings("unchecked") final Entry<? extends CharSequence, V> e = (Map.Entry<? extends CharSequence, V>) o;
        final CharSequence key = keyCheck(e.getKey());
        final V value = e.getValue();
        final TrieNode<V> currentNode = findPreviousNode(key);

        if (currentNode == null) {
			/* Node not found for the given key */
            return null;
        }

        final TrieNode<V> node = currentNode.children.get(key.charAt(key
                .length() - 1));

        if (node == null || !node.inUse) {
			/* Node not found for the given key or is not in use */
            return null;
        }

        final V removed = node.value;

        if (removed != value && (removed == null || !removed.equals(value))) {
			/*
			 * Value in the map differs from the value given in the entry so do
			 * nothing and return null.
			 */
            return null;
        }

        node.unset();
        --size;
        ++modCount;

        if (node.children.isEmpty()) {
			/* Since there are no children left, we can compact the trie */
            compact(key);
        }

        return removed;
    }
490317
public void removeByKey(Object key)
    {
        Object value = keyTable.remove(key);
        if (value != null)
        {
            valueTable.remove(value);
        }
    }
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);
    }
904763
@ManagedOperation
    public void remove(K key, boolean synchronous) {
        try {
            disp.callRemoteMethods(null, new MethodCall(REMOVE, key),
                                   new RequestOptions(synchronous? ResponseMode.GET_ALL : ResponseMode.GET_NONE, call_timeout));
            if(l1_cache != null)
                l1_cache.remove(key);
        }
        catch(Throwable t) {
            if(log.isWarnEnabled())
                log.warn("remove() failed", t);
        }
    }