import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Vector;

public class SortGraph<Knotenname extends SortableNodeName, Kantenname>
		extends GenGraph<Knotenname, Kantenname> {

	public SortGraph() {
		super();
	}

	@Override
	public Iterator<Knotenname> getNodenames() {
		return this.sortIterator(super.getNodenames());
	}

	protected Iterator<Knotenname> sortIterator(Iterator<Knotenname> nodeiter) {
		Collection<Knotenname> colNodenames = new Vector<Knotenname>();

		while (nodeiter.hasNext())
			colNodenames.add(nodeiter.next());

		SortableNodeName[] nodenames = new SortableNodeName[colNodenames.size()];

		colNodenames.toArray(nodenames);

		boolean sortiert = true;
		do {
			sortiert = true;
			for (int i = 1; i < nodenames.length; i++) {
				try {
					if (nodenames[i].kleiner(nodenames[i - 1])) {
						SortableNodeName tmp = nodenames[i - 1];
						nodenames[i - 1] = nodenames[i];
						nodenames[i] = tmp;
						sortiert = false;
					}
				} catch (NotCompareableException e) {
					e.printStackTrace();
				}
			}
		} while (!sortiert);

		colNodenames = new Vector<Knotenname>();
		for (int i = 0; i < nodenames.length; i++) {
			colNodenames.add((Knotenname) nodenames[i]);
		}
		return colNodenames.iterator();
	}

	public Collection<Knotenname> deleteNodesSmaller(SortableNodeName compare) {
		Collection<Kante<Kantenname>> deletedEdges = new HashSet<Kante<Kantenname>>();
		Collection<Knotenname> deletedNodes = new HashSet<Knotenname>();
		Iterator<Knotenname> nodenameIter = super.getNodenames();
		while(nodenameIter.hasNext())
		{
			Knotenname nodename = nodenameIter.next();
			try {
				if (nodename.kleiner(compare))
				{
					Knoten<Knotenname> node;
					try {
						node = this.getNode(nodename);
						deletedEdges.addAll(this.getOutboundEdges(node));
						deletedEdges.addAll(this.getInboundEdges(node));
						Iterator<Kante<Kantenname>> edgeiter = deletedEdges.iterator();										
						while (edgeiter.hasNext())
						{
							this.getEdgeslist().remove((edgeiter.next()));
						}
						this.deleteNode(nodename);
						deletedNodes.add(nodename);
					} catch (NodeNotFoundException e) {
					}
				}
			} catch (NotCompareableException e) {
				e.printStackTrace();
			}
		}
		return deletedNodes;
	}
}