Remove the {@link ChannelPool} from this {@link AbstractChannelPoolMap}. Returns {@code true} if removed,
{@code false} otherwise.

Please note that {@code null} keys are not allowed.
550524
public final boolean remove(K key) {
        P pool =  map.remove(checkNotNull(key, "key"));
        if (pool != null) {
            pool.close();
            return true;
        }
        return false;
    }
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);
    }
736460
public boolean remove() {
		if (exists() && !isRemoved()) {
			isRemoved = true;
			node.getParent().removeChild(nodeFqn.getLastElement());
			if (doTraceLogs) {
				logger.trace("removed cache node "+nodeFqn);
			}	
			return true;
		}
		else {
			return false;
		}
	}
25377
public static <K, V, E extends Exception> boolean removeIf(final Map<K, V> map, final Try.Predicate<? super Map.Entry<K, V>, E> filter) throws E {
        List<K> keysToRemove = null;

        for (Map.Entry<K, V> entry : map.entrySet()) {
            if (filter.test(entry)) {
                if (keysToRemove == null) {
                    keysToRemove = new ArrayList<>(7);
                }

                keysToRemove.add(entry.getKey());
            }
        }

        if (N.notNullOrEmpty(keysToRemove)) {
            for (K key : keysToRemove) {
                map.remove(key);
            }

            return true;
        }

        return false;
    }
580633
public void removeConnectionPool(URL url) {
        RequestBuilder req = new RequestBuilder();
        req.host = url.getHost();
        req.port = url.getPort() < 0 ? url.getDefaultPort() : url.getPort();
        removePool(req);
    }
186013
public boolean remove(VMTransitionBuilder b) {
        Map<VMState, VMTransitionBuilder> m = vmAMB2.get(b.getDestinationState());
        for (VMState src : b.getSourceStates()) {
            m.remove(src);
        }
        return true;
    }
1372189
public boolean remove(Object o) {
        boolean removed = false;
        for (Set<T> s : sets)
            if (s.remove(o))
                removed = true;
        return removed;
    }
820498
public boolean remove(K key, V value) {
        Set<V> set = storage.get(key);
        if (set != null) {
            final boolean removed = set.remove(value);
            if (removed && set.isEmpty()) {
                storage.remove(key);
            }
            return removed;
        }
        return false;
    }
578352
public void removeConnectionPool(String url) {
        try {
            removeConnectionPool(new URL(url));
        } catch (MalformedURLException e) {
            log.error("url exception", e);
            throw new IllegalArgumentException(e);
        }
    }
228915
public boolean remove(KType key) {
    if (Intrinsics.isEmpty(key)) {
      boolean hadEmptyKey = hasEmptyKey;
      hasEmptyKey = false;
      return hadEmptyKey;
    } else {
      final KType [] keys = Intrinsics.<KType[]> cast(this.keys);
      final int mask = this.mask;
      int slot = hashKey(key) & mask;
      
      KType existing;
      while (!Intrinsics.isEmpty(existing = keys[slot])) {
        if (Intrinsics.equals(this, key, existing)) {
          shiftConflictingKeys(slot);
          return true;
        }
        slot = (slot + 1) & mask;
      }
      return false;
    }
  }
546308
@Override
    @InterfaceAudience.Private
    public void evictAllConnectionsInPool() {
        if (client != null) {
            ConnectionPool pool = client.connectionPool();
            if (pool != null)
                pool.evictAll();
        }
    }
1187329
public void remove() {
        Thread thread = Thread.currentThread();
        if (thread instanceof ThreadPool.Worker) {
            Object[] wsLocals = getThreadLocals((ThreadPool.Worker) thread);
            wsLocals[index] = null;
        } else {
            super.remove();
        }
    }
146580
public boolean removeReference(ServiceReference<T> reference) {
        synchronized (elementMap) {
            ConcurrentServiceReferenceElement<T> element = elementMap.remove(reference);
            if (element == null) {
                return false;
            }

            elementSet.remove(element);
            return true;
        }
    }
904242
private boolean removeMatchingKeys(NavigableMap<Endpoint, Integer> map, Endpoint endpoint, Map<UUID, TreeMap<Endpoint, Integer>> otherMap, Direction dir) {
        if (map == null) {
            return false;
        }
        
        // Mark this endpoint as a marker, because it is used to do a tailMap traversal to remove matching edges
        endpoint.setMarker();
        
        // Find the first key 
        Endpoint floorKey = map.floorKey(endpoint);
        
        Map<Endpoint, Integer> view;
        if (floorKey == null) {
            // This means that the element being searched is the minimum
            view = map;
        } else {
            view = map.tailMap(floorKey);
        }
        
        Iterator<Map.Entry<Endpoint, Integer>> entryIter = view.entrySet().iterator();

        boolean isFirst = true;
        while (entryIter.hasNext()) {
            Map.Entry<Endpoint, Integer> entry = entryIter.next();
            Endpoint key = entry.getKey();
            
            if (endpoint.isMatch(key)) {
                // Remove it from this index
                entryIter.remove();
                
                // and from the underlying edge map if necessary
                if (dir != null) { // Direction is null if this is a recursive all
                    // Remove the edge if the map is provided for this purpose 
                    UUID edgeId = key.getEdgeId();

                    IEdge edge = edgeRemover.removeEdge(edgeId);
                    
                    assert (edge != null);
                    
                    // Remove the other endpoint of this edge. NOTE: Self loops are not allowed.
                    Endpoint otherEndpoint;
                    UUID otherVertexId;
                    if (dir == Direction.OUT) {
                        otherVertexId = edge.getInVertexId();
                        otherEndpoint = new Endpoint(key.getEdgeLabel(), key.getEdgeId());
                    } else {
                        otherVertexId = edge.getOutVertexId();
                        otherEndpoint = new Endpoint(key.getEdgeLabel(), key.getEdgeId());
                    }

                    if (removeMatchingKeys(otherMap.get(otherVertexId), otherEndpoint, null, null)) {
                        otherMap.remove(otherVertexId);
                    }
                }
            } else {
                // Done with removes -- the tree map is sorted
                if (isFirst) {
                    // continue
                } else {
                    break;
                }
            }
            
            isFirst = false;
        }
        
        return (map.size() == 0);
    }
562288
public synchronized boolean setPools(Collection<HostConnectionPool<CL>> newPools) {
        Set<HostConnectionPool<CL>> toRemove = Sets.newHashSet(this.pools);
        
        // Add new pools not previously seen
        boolean didChange = false;
        for (HostConnectionPool<CL> pool : newPools) {
            if (this.pools.add(pool))   
                didChange = true;
            toRemove.remove(pool);
        }
    
        // Remove pools for hosts that no longer exist
        for (HostConnectionPool<CL> pool : toRemove) {
            if (this.pools.remove(pool))
                didChange = true;
        }
    
        if (didChange)
            refresh();
        return didChange;
    }
907652
synchronized boolean removeMapping(String virtualHost, HttpContext context)
    {
        boolean existing=false;
        if (_virtualHostMap!=null)
        {
            PathMap contextMap=(PathMap)_virtualHostMap.get(virtualHost);
            
            Iterator i2=contextMap.values().iterator();
            while(i2.hasNext())
            {
                List contextList = (List)i2.next();
                if (contextList.remove(context))
                    existing=true;                
                if (contextList.size()==0)
                    i2.remove();
            }
        }
        return existing;
    }
884102
public void destroy() {
        setState(STATE_STOPPED);
        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
            Tr.event(tc, "destroy: " + this);
        }
        this.channelFactory.removeChannel(getName());
        this.channelFactory = null;
        this.myConfig = null;
        this.myObjectFactory = null;
    }