Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*******************************************************************************
* Copyright (c) 2004, 2016 IBM Corporation and others.
*
* This program and the accompanying materials
* are made available under the terms of the Eclipse Public License 2.0
* which accompanies this distribution, and is available at
* https://www.eclipse.org/legal/epl-2.0/
*
* SPDX-License-Identifier: EPL-2.0
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.osgi.internal.container;
import java.util.*;
/**
* Borrowed from org.eclipse.core.internal.resources.ComputeProjectOrder to be
* used when computing the stop order. Implementation of a sort algorithm for
* computing the node order. This algorithm handles cycles in the node reference
* graph in a reasonable way.
*
* @since 3.0
*/
public class ComputeNodeOrder {
/*
* Prevent class from being instantiated.
*/
private ComputeNodeOrder() {
// not allowed
}
/**
* A directed graph. Once the vertexes and edges of the graph have been defined,
* the graph can be queried for the depth-first finish time of each vertex.
*
* Ref: Cormen, Leiserson, and Rivest Introduction to Algorithms,
* McGraw-Hill, 1990. The depth-first search algorithm is in section 23.3.
*
*/
private static class Digraph {
/**
* struct-like object for representing a vertex along with various values
* computed during depth-first search (DFS).
*/
public static class Vertex {
/**
* White is for marking vertexes as unvisited.
*/
public static final String WHITE = "white"; //$NON-NLS-1$
/**
* Grey is for marking vertexes as discovered but visit not yet finished.
*/
public static final String GREY = "grey"; //$NON-NLS-1$
/**
* Black is for marking vertexes as visited.
*/
public static final String BLACK = "black"; //$NON-NLS-1$
/**
* Color of the vertex. One of WHITE (unvisited), GREY
* (visit in progress), or BLACK (visit finished).
* WHITE initially.
*/
public String color = WHITE;
/**
* The DFS predecessor vertex, or null if there is no predecessor.
* null initially.
*/
public Vertex predecessor = null;
/**
* Timestamp indicating when the vertex was finished (became BLACK) in the DFS.
* Finish times are between 1 and the number of vertexes.
*/
public int finishTime;
/**
* The id of this vertex.
*/
public Object id;
/**
* Ordered list of adjacent vertexes. In other words, "this" is the "from"
* vertex and the elements of this list are all "to" vertexes.
*
* Element type: Vertex
*/
public List adjacent = new ArrayList<>(3);
/**
* Creates a new vertex with the given id.
*
* @param id the vertex id
*/
public Vertex(Object id) {
this.id = id;
}
}
/**
* Ordered list of all vertexes in this graph.
*
* Element type: Vertex
*/
private List vertexList = new ArrayList<>(100);
/**
* Map from id to vertex.
*
* Key type: Object; value type: Vertex
*/
private Map vertexMap = new HashMap<>(100);
/**
* DFS visit time. Non-negative.
*/
private int time;
/**
* Indicates whether the graph has been initialized. Initially
* false.
*/
private boolean initialized = false;
/**
* Indicates whether the graph contains cycles. Initially false.
*/
private boolean cycles = false;
/**
* Creates a new empty directed graph object.
*
* After this graph's vertexes and edges are defined with addVertex
* and addEdge, call freeze to indicate that the graph
* is all there, and then call idsByDFSFinishTime to read off the
* vertexes ordered by DFS finish time.
*
*/
public Digraph() {
super();
}
/**
* Freezes this graph. No more vertexes or edges can be added to this graph
* after this method is called. Has no effect if the graph is already frozen.
*/
public void freeze() {
if (!initialized) {
initialized = true;
// only perform depth-first-search once
DFS();
}
}
/**
* Defines a new vertex with the given id. The depth-first search is performed
* in the relative order in which vertexes were added to the graph.
*
* @param id the id of the vertex
* @exception IllegalArgumentException if the vertex id is already defined or if
* the graph is frozen
*/
public void addVertex(Object id) throws IllegalArgumentException {
if (initialized) {
throw new IllegalArgumentException();
}
Vertex vertex = new Vertex(id);
Object existing = vertexMap.put(id, vertex);
// nip problems with duplicate vertexes in the bud
if (existing != null) {
throw new IllegalArgumentException();
}
vertexList.add(vertex);
}
/**
* Adds a new directed edge between the vertexes with the given ids. Vertexes
* for the given ids must be defined beforehand with addVertex. The
* depth-first search is performed in the relative order in which adjacent "to"
* vertexes were added to a given "from" index.
*
* @param fromId the id of the "from" vertex
* @param toId the id of the "to" vertex
* @exception IllegalArgumentException if either vertex is undefined or if the
* graph is frozen
*/
public void addEdge(Object fromId, Object toId) throws IllegalArgumentException {
if (initialized) {
throw new IllegalArgumentException();
}
Vertex fromVertex = vertexMap.get(fromId);
Vertex toVertex = vertexMap.get(toId);
// ignore edges when one of the vertices is unknown
if (fromVertex == null || toVertex == null)
return;
fromVertex.adjacent.add(toVertex);
}
/**
* Returns the ids of the vertexes in this graph ordered by depth-first search
* finish time. The graph must be frozen.
*
* @param increasing true if objects are to be arranged into
* increasing order of depth-first search finish time, and
* false if objects are to be arranged into
* decreasing order of depth-first search finish time
* @return the list of ids ordered by depth-first search finish time (element
* type: Object)
* @exception IllegalArgumentException if the graph is not frozen
*/
public List
