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.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* 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
