import java.util.Iterator;
import java.util.LinkedList;
class Vertex implements EdgeIfc, NeighborIfc {
public String name = null;
public Vertex assignName(String name) {
this.name = name;
return (Vertex) this;
}
public String getName() {
return this.name;
}
public LinkedList<Vertex> adjacentVertices = new LinkedList<Vertex>();
public LinkedList<Neighbor> adjacentNeighbors = new LinkedList<Neighbor>();
public void addAdjacent(Vertex n) {
adjacentVertices.add(n);
}
public void adjustAdorns(Vertex the_vertex, int index) {
int the_weight = the_vertex.weightsList.get(index).intValue();
weightsList.add(new Integer(the_weight));
}
public VertexIter getNeighbors() {
if (true)
return new VertexIter() {
private Iterator<Vertex> iter = adjacentVertices.iterator();
public Vertex next() {
return iter.next();
}
public boolean hasNext() {
return iter.hasNext();
}
};
if (true)
return new VertexIter() {
private Iterator<Neighbor> iter = adjacentNeighbors.iterator();
public Vertex next() {
return (iter.next()).neighbor;
}
public boolean hasNext() {
return iter.hasNext();
}
};
return new VertexIter() {
private Iterator<Neighbor> iter = neighbors.iterator();
public Vertex next() {
return (iter.next()).end;
}
public boolean hasNext() {
return iter.hasNext();
}
};
}
// --------------------
// from EdgeIfc
// --------------------
public Vertex getStart() {
if (true)
return this;
else
return null;
}
public Vertex getEnd() {
return null;
}
public int getWeight() {
return 0;
}
public Vertex getOtherVertex(Vertex vertex) {
return this;
}
public void adjustAdorns(EdgeIfc the_edge) {
}
public void addEdge(Neighbor n) {
adjacentNeighbors.add(n);
}
public void adjustAdorns(Neighbor sourceNeighbor) {
adjacentNeighbors.getLast().weight = sourceNeighbor.weight;
}
public LinkedList<Neighbor> neighbors = new LinkedList<Neighbor>();
public void addNeighbor(Neighbor n) {
neighbors.add(n);
}
public EdgeIter getEdges() {
// G
if (true)
return new EdgeIter() {
private Iterator<Vertex> iter = adjacentVertices.iterator();
public EdgeIfc next() {
return iter.next();
}
public boolean hasNext() {
return iter.hasNext();
}
};
// GN
if (true)
return new EdgeIter() {
private Iterator<Neighbor> iter = adjacentNeighbors.iterator();
public EdgeIfc next() {
return iter.next();
}
public boolean hasNext() {
return iter.hasNext();
}
};
// GEN
return new EdgeIter() {
private Iterator<Neighbor> iter = neighbors.iterator();
public EdgeIfc next() {
return iter.next().edge;
}
public boolean hasNext() {
return iter.hasNext();
}
};
}
public LinkedList getNeighborsObj() {
if (true)
return adjacentNeighbors;
if (true)
return neighbors;
return adjacentVertices;
}
public LinkedList<Integer> weightsList = new LinkedList<Integer>();
public void addWeight(int weight) {
weightsList.add(new Integer(weight));
adjacentNeighbors.getLast().weight = weight;
}
public void setWeight(int weight) {
addWeight(weight);
adjacentVertices.getLast().addWeight(weight);
}
public boolean visited = false;
public void init_vertex(WorkSpace w) {
visited = false;
w.init_vertex((Vertex) this);
}
public void nodeSearch(WorkSpace w) {
int s, c;
Vertex v;
Vertex header;
// Step 1: if preVisitAction is true or if we've already
// visited this node
w.preVisitAction((Vertex) this);
if (visited) {
return;
}
// Step 2: Mark as visited, put the unvisited neighbors in the queue
// and make the recursive call on the first element of the queue
// if there is such if not you are done
visited = true;
for (VertexIter vxiter = getNeighbors(); vxiter.hasNext();) {
v = vxiter.next();
w.checkNeighborAction((Vertex) this, v);
v.nodeSearch(w);
}
// Step 3: do postVisitAction now, you are no longer going through the
// node again, mark it as black
w.postVisitAction((Vertex) this);
// enqueues the vertices not visited
for (VertexIter vxiter = getNeighbors(); vxiter.hasNext();) {
v = vxiter.next();
// if your neighbor has not been visited then enqueue
if (!v.visited) {
GlobalVarsWrapper.queue.add(v);
}
} // end of for
// while there is something in the queue
while (GlobalVarsWrapper.queue.size() != 0) {
header = (Vertex) GlobalVarsWrapper.queue.get(0);
GlobalVarsWrapper.queue.remove(0);
header.nodeSearch(w);
}
}
public int vertexNumber;
public int componentNumber;
public int finishTime;
public int strongComponentNumber;
public int VertexCycle;
public int VertexColor; // white ->0, gray ->1, black->2
public Vertex representative;
public LinkedList members;
public String pred; // the predecessor vertex if any
public int key; // weight so far from s to it
public void display() {
// Weights
System.out.print(" Weights : ");
for (int i = 0; i < weightsList.size(); i++) {
System.out.print(weightsList.get(i).intValue() + ", ");
}
// all
System.out.print("Vertex " + name + " connected to: ");
for (VertexIter vxiter = getNeighbors(); vxiter.hasNext();) {
Vertex v = vxiter.next();
System.out.print(v.getName() + ", ");
}
// searchbase
if (visited)
System.out.print(" visited");
else
System.out.println(" !visited");
System.out.print(" # " + vertexNumber + " ");
System.out.print(" comp# " + componentNumber + " ");
System.out.print(" FinishTime -> " + finishTime + " SCCNo -> "
+ strongComponentNumber);
System.out.print(" VertexCycle# " + VertexCycle + " ");
if (representative == null)
System.out.print("Rep null ");
else
System.out.print(" Rep " + representative.getName() + " ");
System.out.print(" Pred " + pred + " Key " + key + " ");
System.out.println();
}
}