123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223 |
- /* *******************************************************************
- * Copyright (c) 1999-2001 Xerox Corporation,
- * 2002 Palo Alto Research Center, Incorporated (PARC).
- * 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:
- * Xerox/PARC initial implementation
- * ******************************************************************/
-
- package org.aspectj.util;
-
- import java.util.ArrayList;
- import java.util.Iterator;
- import java.util.LinkedList;
- import java.util.List;
-
- /**
- * This class implements a partial order
- *
- * It includes routines for doing a topo-sort
- */
-
- public class PartialOrder {
-
- /**
- * All classes that want to be part of a partial order must implement PartialOrder.PartialComparable.
- */
- public static interface PartialComparable {
- /**
- * @returns <ul>
- * <li>+1 if this is greater than other</li>
- * <li>-1 if this is less than other</li>
- * <li>0 if this is not comparable to other</li>
- * </ul>
- *
- * <b> Note: returning 0 from this method doesn't mean the same thing as returning 0 from
- * java.util.Comparable.compareTo()</b>
- */
- public int compareTo(Object other);
-
- /**
- * This method can provide a deterministic ordering for elements that are strictly not comparable. If you have no need for
- * this, this method can just return 0 whenever called.
- */
- public int fallbackCompareTo(Object other);
- }
-
- private static class SortObject<T extends PartialComparable> {
- T object;
- List<SortObject<T>> smallerObjects = new LinkedList<SortObject<T>>();
- List<SortObject<T>> biggerObjects = new LinkedList<SortObject<T>>();
-
- public SortObject(T o) {
- object = o;
- }
-
- boolean hasNoSmallerObjects() {
- return smallerObjects.size() == 0;
- }
-
- boolean removeSmallerObject(SortObject<T> o) {
- smallerObjects.remove(o);
- return hasNoSmallerObjects();
- }
-
- void addDirectedLinks(SortObject<T> other) {
- int cmp = object.compareTo(other.object);
- if (cmp == 0) {
- return;
- }
- if (cmp > 0) {
- this.smallerObjects.add(other);
- other.biggerObjects.add(this);
- } else {
- this.biggerObjects.add(other);
- other.smallerObjects.add(this);
- }
- }
-
- public String toString() {
- return object.toString(); // +smallerObjects+biggerObjects;
- }
- }
-
- private static <T extends PartialComparable> void addNewPartialComparable(List<SortObject<T>> graph, T o) {
- SortObject<T> so = new SortObject<T>(o);
- for (Iterator<SortObject<T>> i = graph.iterator(); i.hasNext();) {
- SortObject<T> other = i.next();
- so.addDirectedLinks(other);
- }
- graph.add(so);
- }
-
- private static <T extends PartialComparable> void removeFromGraph(List<SortObject<T>> graph, SortObject<T> o) {
- for (Iterator<SortObject<T>> i = graph.iterator(); i.hasNext();) {
- SortObject<T> other = i.next();
-
- if (o == other) {
- i.remove();
- }
- // ??? could use this to build up a new queue of objects with no
- // ??? smaller ones
- other.removeSmallerObject(o);
- }
- }
-
- /**
- * @param objects must all implement PartialComparable
- *
- * @returns the same members as objects, but sorted according to their partial order. returns null if the objects are cyclical
- *
- */
- public static <T extends PartialComparable> List<T> sort(List<T> objects) {
- // lists of size 0 or 1 don't need any sorting
- if (objects.size() < 2) {
- return objects;
- }
-
- // ??? we might want to optimize a few other cases of small size
-
- // ??? I don't like creating this data structure, but it does give good
- // ??? separation of concerns.
- List<SortObject<T>> sortList = new LinkedList<SortObject<T>>();
- for (Iterator<T> i = objects.iterator(); i.hasNext();) {
- addNewPartialComparable(sortList, i.next());
- }
-
- // System.out.println(sortList);
-
- // now we have built our directed graph
- // use a simple sort algorithm from here
- // can increase efficiency later
- // List ret = new ArrayList(objects.size());
- final int N = objects.size();
- for (int index = 0; index < N; index++) {
- // System.out.println(sortList);
- // System.out.println("-->" + ret);
-
- SortObject<T> leastWithNoSmallers = null;
-
- for (SortObject<T> so: sortList) {
- if (so.hasNoSmallerObjects()) {
- if (leastWithNoSmallers == null || so.object.fallbackCompareTo(leastWithNoSmallers.object) < 0) {
- leastWithNoSmallers = so;
- }
- }
- }
-
- if (leastWithNoSmallers == null) {
- return null;
- }
-
- removeFromGraph(sortList, leastWithNoSmallers);
- objects.set(index, leastWithNoSmallers.object);
- }
-
- return objects;
- }
-
- /***********************************************************************************
- * /* a minimal testing harness
- ***********************************************************************************/
- static class Token implements PartialComparable {
- private String s;
-
- Token(String s) {
- this.s = s;
- }
-
- public int compareTo(Object other) {
- Token t = (Token) other;
-
- int cmp = s.charAt(0) - t.s.charAt(0);
- if (cmp == 1) {
- return 1;
- }
- if (cmp == -1) {
- return -1;
- }
- return 0;
- }
-
- public int fallbackCompareTo(Object other) {
- return -s.compareTo(((Token) other).s);
- }
-
- public String toString() {
- return s;
- }
- }
-
- public static void main(String[] args) {
- List<Token> l = new ArrayList<Token>();
- l.add(new Token("a1"));
- l.add(new Token("c2"));
- l.add(new Token("b3"));
- l.add(new Token("f4"));
- l.add(new Token("e5"));
- l.add(new Token("d6"));
- l.add(new Token("c7"));
- l.add(new Token("b8"));
-
- l.add(new Token("z"));
- l.add(new Token("x"));
-
- l.add(new Token("f9"));
- l.add(new Token("e10"));
- l.add(new Token("a11"));
- l.add(new Token("d12"));
- l.add(new Token("b13"));
- l.add(new Token("c14"));
-
- System.out.println(l);
-
- sort(l);
-
- System.out.println(l);
- }
- }
|