Removes the specified {@link Endpoint} from current {@link Endpoint} list.
546054
protected final void removeEndpoint(Endpoint e) {
        final List<Endpoint> newEndpoints;
        endpointsLock.lock();
        try {
            endpoints = newEndpoints = endpoints.stream()
                                                .filter(endpoint -> !endpoint.equals(e))
                                                .collect(toImmutableList());
        } finally {
            endpointsLock.unlock();
        }
        notifyListeners(newEndpoints);
    }
737686
@Override
	public void prune() {
		Iterator<PointIndex<Point>> iter = allPoints.iterator();
		int index = 0;
		while( iter.hasNext() ) {
			iter.next();
			if (origErrors[index++] >= pruneVal) {
				iter.remove();
			}
		}
	}
319257
public Set<Integer> removeConnections(String endpointId) {
        Set<Integer> removed = this.entries.removeAll(endpointId);
        if (!removed.isEmpty() && log.isDebugEnabled()) {
            log.debug("Call " + getCallIdHex() + " unregistered connections " + Arrays.toString(convertToHex(removed)) + " from endpoint " + endpointId);
        }
        return removed;
    }
1228695
def delete(self):
        
        return self._delete_request(endpoint=self.ENDPOINT + '/' + str(self.id))
822763
public void removeFromMoving(InetAddress endpoint)
    {
        assert endpoint != null;

        lock.writeLock().lock();
        try
        {
            for (Pair<Token, InetAddress> pair : movingEndpoints)
            {
                if (pair.right.equals(endpoint))
                {
                    movingEndpoints.remove(pair);
                    break;
                }
            }

            invalidateCachedRings();
        }
        finally
        {
            lock.writeLock().unlock();
        }
    }
1248633
public Point removePoint(String id) {
        Point removePoint = null;
        for (Point point : points)
            if (id.equals(point.getId()))
                removePoint = point;
        if (removePoint != null)
            points.remove(removePoint);
        return removePoint;
    }
1227849
private void cleanupEndpointActivationServiceInfo(EndpointActivationServiceInfo easInfo) {
        if (easInfo.serviceRef == null && easInfo.endpointFactories.isEmpty()) {
            endpointActivationServices.remove(easInfo.id);
        }
    }
1014855
def remove(self):
        
        LOGGER.debug("Endpoint.remove - " + self.id + " - " + self.url)
        if self.id is None:
            return None
        else:
            if self.id in EndpointService.local_cache_by_id:
                for search_params in EndpointService.local_cache_by_id[self.id]:
                    if search_params in EndpointService.local_cache_by_params.keys():
                        EndpointService.local_cache_by_params.pop(search_params)
                EndpointService.local_cache_by_id.pop(self.id)

            params = SessionService.complete_transactional_req({
                'ID': self.id
            })

            if MappingService.driver_type != DriverFactory.DRIVER_REST:
                params['OPERATION'] = 'deleteEndpoint'
                args = {'properties': params}
            else:
                args = {'http_operation': 'GET', 'operation_path': 'delete', 'parameters': params}

            response = EndpointService.requester.call(args)

            if MappingService.driver_type != DriverFactory.DRIVER_REST:
                response = response.get()

            if response.rc != 0:
                LOGGER.warning(
                    'Endpoint.remove - Problem while deleting endpoint ' + str(self.id) +
                    'Reason: ' + str(response.response_content) + ' - ' + str(response.error_message) +
                    " (" + str(response.rc) + ")"
                )
                if response.rc == 500 and ArianeMappingOverloadError.ERROR_MSG in response.error_message:
                    raise ArianeMappingOverloadError("Endpoint.remove",
                                                     ArianeMappingOverloadError.ERROR_MSG)
                # traceback.print_stack()
                return self
            else:
                if self.parent_node is not None:
                    self.parent_node.sync()
                return None
1147899
public void remove() {
        if (polyline != null) {
            polyline.remove();
            polyline = null;
        }
        for (Marker marker : markers) {
            marker.remove();
        }
    }
914684
public static void delete(final String domainId, final String endpointId) throws AppPlatformException, IOException {
        assert(endpointId != null);
        final BandwidthClient client = BandwidthClient.getInstance();
        client.delete(String.format(client.getUserResourceUri(BandwidthConstants.ENDPOINTS_URI_PATH), domainId)+ "/"+endpointId);
    }
934031
public Response delete(String endpoint) {
        return call(Method.DELETE, endpoint, null, null);
    }
1325640
public synchronized void close() throws IOException, InterruptedException {
		if (isClosed){
			return;
		}

		logger.info("closing server endpoint");
		idPriv.destroyId();
		group.unregisterServerEp(this);
		isClosed = true;
	}
23677
def endpoint_delete(auth=None, **kwargs):
    '''
    
    '''
    cloud = get_operator_cloud(auth)
    kwargs = _clean_kwargs(**kwargs)
    return cloud.delete_endpoint(**kwargs)
1161602
public void removeAll() {
        for(Iterator<Map.Entry<MetricName, Metric>> it = metrics.entrySet().iterator(); it.hasNext();) {
            Map.Entry<MetricName, Metric> entry = it.next();
            Metric metric = entry.getValue();
            if(metric != null) {
                onMetricRemoved(entry.getKey(), metric);
            }
            it.remove();
        }
    }
511054
def delete_endpoint(endpoint_id)
      endpoint = EndPoint.new({:id => endpoint_id}, @client)
      endpoint.domain_id = id
      endpoint.delete()
    end
1238566
def unbind(endpoint)
      rc = ffi_delegate.unbind("%s", :string, endpoint)
      raise ArgumentError, "incorrect endpoint: %p" % endpoint if rc == -1
    end
168638
public final void removeServlet(String mountPoint) {
        mountPoint = GenericContext.normalizeMountPoint(mountPoint);
        synchronized (servlets) {
            ServletDescriptor remove = servlets.remove(mountPoint);
            if (remove != null) {
                unregisterServletDescriptor(remove);
            }
        }

    }