Remove a node.

@param jvmRoute the jvmRoute
@return the removed node
556662
public synchronized Node removeNode(final String jvmRoute) {
        final Node node = nodes.get(jvmRoute);
        if (node != null) {
            removeNode(node);
        }
        return node;
    }
848138
def delete(self, path, recursive=False):
        
        _log.debug("ZK: Deleting node " + path)
        return self.zk.delete(path, recursive=recursive)
539592
public synchronized boolean disableNode(final String jvmRoute) {
        final Node node = nodes.get(jvmRoute);
        if (node != null) {
            for (final Context context : node.getContexts()) {
                context.disable();
            }
            return true;
        }
        return false;
    }
1146112
public RequestBuilder delete(final String url) {

    checkNotNull(url, "url may not be null");
    final AsyncHttpClient.BoundRequestBuilder ningRequestBuilder = asyncHttpClient.prepareDelete(url);
    return createNewRequestBuilder(url, ningRequestBuilder);
  }
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;
		}
	}
259708
function removeNode(context, node) {
  var removedNodes = context.removedNodes;
  var length = removedNodes.length;
  var index = length;

  // Check for line's leading and trailing space to be removed.
  var spaceNode = context.pretty ? getLeadingSpaceNode(context, node) : null;
  var lineNode = context.pretty ? getTrailingLineNode(context, node) : null;

  while (index > 0 && endOf(removedNodes[index - 1]) > startOf(node)) {
    index--;
  }

  if (index === length) {
    if (spaceNode) {
      removedNodes.push(spaceNode);
    }
    removedNodes.push(node);
    if (lineNode) {
      removedNodes.push(lineNode);
    }
  } else {
    if (lineNode) {
      if (spaceNode) {
        removedNodes.splice(index, 0, spaceNode, node, lineNode);
      } else {
        removedNodes.splice(index, 0, node, lineNode);
      }
    } else if (spaceNode) {
      removedNodes.splice(index, 0, spaceNode, node);
    } else {
      removedNodes.splice(index, 0, node);
    }
  }

  return false;
}
949637
public void removeDatanode(DatanodeID nodeID)
    throws IOException {
    writeLock();
    try {
      DatanodeDescriptor nodeInfo = getDatanode(nodeID);
      if (nodeInfo != null) {
        removeDatanode(nodeInfo);
      } else {
        NameNode.stateChangeLog.warn("BLOCK* NameSystem.removeDatanode: "
          + nodeID.getName() + " does not exist");
      }
    } finally {
      writeUnlock();
    }
  }
399276
def delNode(self, address):
        
        LOGGER.info('Removing node {}'.format(address))
        message = {
            'removenode': {
                'address': address
            }
        }
        self.send(message)
173385
public void doDelete(@Param("nodeId") Long nodeId, @Param("pageIndex") int pageIndex,
                         @Param("searchKey") String searchKey, Navigator nav) throws WebxException {

        if (pipelineService.hasRelation(nodeId) || nodeService.findById(nodeId).getStatus().isStart()) {
            nav.redirectTo(WebConstant.ERROR_FORBIDDEN_Link);
            return;
        } else {
            nodeService.remove(nodeId);
        }

        nav.redirectToLocation("nodeList.htm?pageIndex=" + pageIndex + "&searchKey=" + urlEncode(searchKey));
    }
1092823
public boolean removeRoadSegment(int segmentIndex) {
		if (segmentIndex >= 0 && segmentIndex < this.roadSegments.getRoadSegmentCount()) {
			final RoadSegment segment = this.roadSegments.getRoadSegmentAt(segmentIndex);
			if (segment != null) {
				//
				// Invalidate the bus halts on the segment
				//
				final Map<BusItineraryHalt, RoadSegment> segmentMap = new TreeMap<>(
						(obj1, obj2) -> Integer.compare(System.identityHashCode(obj1), System.identityHashCode(obj2)));
				final Iterator<BusItineraryHalt> haltIterator = this.validHalts.iterator();
				while (haltIterator.hasNext()) {
					final BusItineraryHalt halt = haltIterator.next();
					final int sgmtIndex = halt.getRoadSegmentIndex();
					if (sgmtIndex == segmentIndex) {
						segmentMap.put(halt, null);
					} else {
						final RoadSegment sgmt = this.roadSegments.getRoadSegmentAt(sgmtIndex);
						segmentMap.put(halt, sgmt);
					}
				}

				//
				// Remove the road segment itself on the segment
				//
				this.roadSegments.removeRoadSegmentAt(segmentIndex);

				//
				// Force the road segment indexes
				//
				for (final Entry<BusItineraryHalt, RoadSegment> entry : segmentMap.entrySet()) {
					final BusItineraryHalt halt = entry.getKey();
					final RoadSegment sgmt = entry.getValue();
					if (sgmt == null) {
						halt.setRoadSegmentIndex(-1);
						halt.setPositionOnSegment(Float.NaN);
						halt.checkPrimitiveValidity();
					} else {
						final int sgmtIndex = halt.getRoadSegmentIndex();
						final int idx = this.roadSegments.indexOf(sgmt);
						if (idx != sgmtIndex) {
							halt.setRoadSegmentIndex(idx);
							halt.checkPrimitiveValidity();
						}
					}
				}

				//
				// Change the road network reference
				//
				if (this.roadSegments.isEmpty() && this.roadNetwork != null) {
					final RoadNetwork network = this.roadNetwork.get();
					if (network != null) {
						network.removeRoadNetworkListener(this);
					}
					this.roadNetwork = null;
				}

				fireShapeChanged(new BusChangeEvent(this,
						BusChangeEventType.SEGMENT_REMOVED,
						segment,
						segmentIndex,
						"shape", //$NON-NLS-1$
						null,
						null));
				checkPrimitiveValidity();
				return true;
			}
		}
		return false;
	}
204248
public boolean removeNode(RiakNode node)
    {
        stateCheck(State.CREATED, State.RUNNING, State.QUEUING);
        boolean removed = false;
        try
        {
            nodeListLock.writeLock().lock();
            removed = nodeList.remove(node);
            for (NodeStateListener listener : stateListeners)
            {
                node.removeStateListener(listener);
            }
        }
        finally
        {
            nodeListLock.writeLock().unlock();
        }
        nodeManager.removeNode(node);
        return removed;
    }
1168121
@CheckForNull
    public String extractJvmRoute( @Nonnull final String sessionId ) {
        final int idxDot = sessionId.indexOf( '.' );
        return idxDot < 0 ? null : sessionId.substring( idxDot + 1 );
    }
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;
    }
813582
public boolean remove(Tree<T> node) {
    return getChild(node)
        .map(function(n -> n.parent = null))
        .map(children::remove)
        .orElse(false);
  }
1318275
public void remove(T node) {
		for (int i = 0; i < numberOfReplicas; i++) {
			circle.remove(hashFunc.hash(node.toString() + i));
		}
	}
1128876
public static ns_clusternode[] remove_node(nitro_service client, ns_clusternode[] resources) throws Exception
	{
		if(resources == null)
			throw new Exception("Null resource array");
		
		
		if(resources.length == 1)
			return ((ns_clusternode[]) resources[0].perform_operation(client, "remove_node"));
		
		return ((ns_clusternode[]) perform_operation_bulk_request(client, resources, "remove_node"));
	}
102537
public void remove() {

    BasicDoubleLinkedNode<V> next = getNext();
    if (next != null) {
      next.previous = this.previous;
    }
    if (this.previous != null) {
      this.previous.setNext(next);
    }
  }