Delete a {@link DataNode} by its identifier
@param edgeId identifier of the {@link FlowEdge} to be deleted.
@return true if {@link FlowEdge} is successfully deleted.
420320
@Override
  public boolean deleteFlowEdge(String edgeId) {
    try {
      rwLock.writeLock().lock();
      return flowEdgeMap.containsKey(edgeId) && deleteFlowEdge(flowEdgeMap.get(edgeId));
    } finally {
      rwLock.writeLock().unlock();
    }
  }
428721
public boolean remove(DATA data) {
		if(root == null) {
			return false;
		}
		
		double distanceToRoot = distanceFunction.calculate(data, root.data);
		try {
			root.removeData(data, distanceToRoot);
		} catch(RootNodeReplacement e) {
			@SuppressWarnings("unchecked")
			Node newRoot = (Node) e.newRoot;
			root = newRoot;
		} catch(DataNotFound e) {
			return false;
		} catch (NodeUnderCapacity e) {
			throw new RuntimeException("Should have never happened", e);
		}
		return true;
	}
425212
@Override
  public boolean isFlowRunning(final int projectId, final String flowId) {
    boolean isRunning = false;
    isRunning =
        isRunning
            || isFlowRunningHelper(projectId, flowId, this.queuedFlows.getAllEntries());
    isRunning =
        isRunning
            || isFlowRunningHelper(projectId, flowId, this.runningExecutions.get().values());
    return isRunning;
  }
1338934
def del_edge(self, u_vertex, v_vertex):
        
        if self.is_edge(u_vertex, v_vertex):
            self.indegrees[v_vertex] -= 1
            self.adj_dict[u_vertex].remove(v_vertex)
            return True

        return False
325093
private void removeFlowEdge(DiffEntry change) {
    if (checkFilePath(change.getOldPath(), EDGE_FILE_DEPTH)) {
      Path edgeFilePath = new Path(this.repositoryDir, change.getOldPath());
      try {
        Config config = getEdgeConfigWithOverrides(ConfigFactory.empty(), edgeFilePath);
        String edgeId = config.getString(FlowGraphConfigurationKeys.FLOW_EDGE_ID_KEY);
        if (!this.flowGraph.deleteFlowEdge(edgeId)) {
          log.warn("Could not remove edge {} from FlowGraph; skipping", edgeId);
        } else {
          log.info("Removed edge {} from FlowGraph", edgeId);
        }
      } catch (Exception e) {
        log.warn("Could not remove edge defined in {} due to exception {}", edgeFilePath, e.getMessage());
      }
    }
  }
542839
public void deleteFlowConfig(FlowId flowId)
      throws RemoteInvocationException {
    LOG.debug("deleteFlowConfig with groupName {}, flowName {}", flowId.getFlowGroup(), flowId.getFlowName());

    DeleteRequest<FlowConfig> deleteRequest = _flowconfigsV2RequestBuilders.delete()
        .id(new ComplexResourceKey<>(flowId, new FlowStatusId())).build();
    ResponseFuture<EmptyRecord> response = _restClient.get().sendRequest(deleteRequest);

    response.getResponse();
  }
1173362
public void delete(String targetId) throws IOException {
        startChangesIfNecessary();
        ResponseWriter writer = getWrapped();
        writer.startElement("delete", null);
        writer.writeAttribute("id", targetId, null);
        writer.endElement("delete");
    }
1295475
public void removeRuleFlow(String id) {
        ProcessPackage rtp = (ProcessPackage) getResourceTypePackages().get(ResourceType.BPMN2);
        if (rtp == null || rtp.lookup(id) == null) {
            throw new IllegalArgumentException("The rule flow with id [" + id + "] is not part of this package.");
        }
        rtp.remove(id);
    }
958916
def purge_node(self, node_id, remove_definition=False, sandbox=None):
        
        for stream_id in list(self.streams):
            stream = self.streams[stream_id]
            if not stream.parent_node:
                # This can happen if streams have been defined outside of nodes - generally nothing to worry about
                logging.debug("cannot purge the stream with id {} because it has no parent node".format(stream_id))
                continue
            if stream.parent_node.node_id == node_id:
                self.purge_stream(stream_id, remove_definition=remove_definition, sandbox=sandbox)
620535
public void streamRemoved(int streamId) {
        Http2PriorityNode node = nodesByID.get(streamId);
        if(node == null) {
            return;
        }
        if(!node.hasDependents()) {
            //add to eviction queue
            int toEvict = evictionQueue[evictionQueuePosition];
            evictionQueue[evictionQueuePosition++] = streamId;
            Http2PriorityNode nodeToEvict = nodesByID.get(toEvict);
            //we don't remove the node if it has since got dependents since it was put into the queue
            //as this is the whole reason we maintain the queue in the first place
            if(nodeToEvict != null && !nodeToEvict.hasDependents()) {
                nodesByID.remove(toEvict);
            }
        }

    }
570752
@Override
	public boolean containsNode(long id) {
		return nodeIdMapping.containsKey(id) && !isRemoved(nodes.get(nodeIdMapping.get(id)));
	}
666911
public static void deleteNode(DbConn cnx, int id)
    {
        int countRunning = cnx.runSelectSingle("ji_select_count_by_node", Integer.class, id);
        if (countRunning > 0)
        {
            cnx.setRollbackOnly();
            throw new JqmAdminApiUserException(
                    "cannot delete a node with running instances. Disable it, wait for the end of all running instances, then retry.");
        }

        try
        {
            Node n = Node.select_single(cnx, "node_select_by_id", id);
            Calendar limit = Calendar.getInstance();
            limit.add(Calendar.MINUTE, -10);
            if (n.getLastSeenAlive() != null && n.getLastSeenAlive().after(limit))
            {
                cnx.setRollbackOnly();
                throw new JqmAdminApiUserException(
                        "Can only remove a node either properly shut down or that has crashed more than 10 minutes ago.");
            }
        }
        catch (NoResultException e)
        {
            throw new JqmAdminApiUserException("no item with ID " + id);
        }

        cnx.runUpdate("dp_delete_for_node", id);
        QueryResult qr = cnx.runUpdate("node_delete_by_id", id);
        if (qr.nbUpdated != 1)
        {
            cnx.setRollbackOnly();
            throw new JqmAdminApiUserException("no item with ID " + id);
        }
    }
523803
void deleteEdgesBreakFaces_(AttributeStreamOfInt32 edgesToDelete) {
		for (int i = 0, n = edgesToDelete.size(); i < n; i++) {
			int half_edge = edgesToDelete.get(i);
			int chain = getHalfEdgeChain(half_edge);
			int halfEdgeTwin = getHalfEdgeTwin(half_edge);
			int chainTwin = getHalfEdgeChain(halfEdgeTwin);
			setChainHalfEdge_(chain, -1);
			setChainHalfEdge_(chainTwin, -1);
			updateVertexToHalfEdgeConnection_(half_edge, true);
			deleteEdgeImpl_(half_edge);
		}
	}
896886
@Transactional
  @DeleteMapping("/{entityTypeId}/{id}")
  @ResponseStatus(NO_CONTENT)
  public void deleteDelete(
      @PathVariable("entityTypeId") String entityTypeId, @PathVariable("id") String untypedId) {
    delete(entityTypeId, untypedId);
  }
1172665
@Override
    @GraphTransaction
    public void deleteTrait(String guid, String traitNameToBeDeleted) throws TraitNotFoundException, EntityNotFoundException, RepositoryException {
        LOG.debug("Deleting trait={} from entity={}", traitNameToBeDeleted, guid);
        GraphTransactionInterceptor.lockObjectAndReleasePostCommit(guid);

        AtlasVertex instanceVertex = graphHelper.getVertexForGUID(guid);

        List<String> traitNames = GraphHelper.getTraitNames(instanceVertex);
        if (!traitNames.contains(traitNameToBeDeleted)) {
                throw new TraitNotFoundException(
                        "Could not find trait=" + traitNameToBeDeleted + " in the repository for entity: " + guid);
        }

        try {
            final String entityTypeName = GraphHelper.getTypeName(instanceVertex);
            String relationshipLabel = GraphHelper.getTraitLabel(entityTypeName, traitNameToBeDeleted);
            AtlasEdge edge = graphHelper.getEdgeForLabel(instanceVertex, relationshipLabel);
            if(edge != null) {
                deleteHandler.deleteEdgeReference(edge, DataTypes.TypeCategory.TRAIT, false, true);
            }

            // update the traits in entity once trait removal is successful
            traitNames.remove(traitNameToBeDeleted);
            updateTraits(instanceVertex, traitNames);
        } catch (Exception e) {
            throw new RepositoryException(e);
        }
    }
1245590
protected void storeOsmWayID(int edgeId, long osmWayId) {
        if (getOsmWayIdSet().contains(osmWayId)) {
            getEdgeIdToOsmWayIdMap().put(edgeId, osmWayId);
        }
    }
363112
protected void processEdge(int edgeId, int adjNode, int prevEdgeId) {
        EdgeIteratorState iter = graph.getEdgeIteratorState(edgeId, adjNode);
        distance += iter.getDistance();
        time += weighting.calcMillis(iter, false, prevEdgeId);
        addEdge(edgeId);
    }