[jboss-cvs] jboss-seam/src/main/org/jboss/seam/util ...

[Gavin King]

  User: gavin   
  Date: 07/05/30 17:53:10

  Modified:    src/main/org/jboss/seam/util   Sorter.java
  Removed:     src/main/org/jboss/seam/util   SorterNew.java
  Log:
  remove dupe class
  
  Revision  Changes    Path
  1.2       +74 -71    jboss-seam/src/main/org/jboss/seam/util/Sorter.java
  
  (In the diff below, changes in quantity of whitespace are not shown.)
  
  Index: Sorter.java
  ===================================================================
  RCS file: /cvsroot/jboss/jboss-seam/src/main/org/jboss/seam/util/Sorter.java,v
  retrieving revision 1.1
  retrieving revision 1.2
  diff -u -b -r1.1 -r1.2
  --- Sorter.java	21 Aug 2005 19:29:38 -0000	1.1
  +++ Sorter.java	30 May 2007 21:53:10 -0000	1.2
  @@ -1,71 +1,74 @@
  -//$Id: Sorter.java,v 1.1 2005/08/21 19:29:38 gavin Exp $
   package org.jboss.seam.util;
   
   import java.util.ArrayList;
   import java.util.List;
   
  -/**
  - * Uses a brute force O(n^4) algorithm to discover an acceptable
  - * order for partially ordered elements where the transitivity
  - * of the ordering is not known in advance. Of course, this
  - * should only be used to order small numbers of elements.
  - * 
  - * @author Gavin King
  - */
  -public abstract class Sorter<T>
  +public class Sorter<T> 
   {
  -   public void sort(List<T> originalList)
  +   
  +	private List<SortItem<T>> list = null; //new ArrayList();
  +
  +	public List<SortItem<T>> sort(List<SortItem<T>> lst)
      {
  -      List<T> remaining = new ArrayList(originalList);
  -      originalList.clear();
  -      sortInto(originalList, remaining);
         
  -      if ( !isGoodOrder(originalList) )
  +      this.list = lst;
  +		List<SortItem<T>> res = new ArrayList<SortItem<T>>();
  +		SortItem<T> inmost = null;
  +		
  +      do 
  +      {	
  +			inmost = getInmost();
  +			if (inmost!=null)
         {
  -         throw new IllegalStateException();
  +				res.add(inmost);
  +				remove(inmost);
         }
      }
  +      while ( !list.isEmpty() && inmost!=null );
      
  -   private boolean sortInto(List<T> result, List<T> remaining)
  +      if ( !list.isEmpty() )
      {
  -      if (remaining.size()==0)
  -      {
  -         return true;
  +			throw new IllegalArgumentException("Can not sort list:"+list);
         }
  -      else 
  -      {
  -         int loc = result.size();
  -         result.add(null);
  -         for (int i=0; i<remaining.size(); i++)
  -         {
  -            List<T> nowRemaining = new ArrayList<T>(remaining);
  -            T interceptor = nowRemaining.remove(i);
  -            result.set(loc, interceptor);
  -            if ( isGoodOrder(result) )
  +		
  +      return res;		
  +	}
  +   
  +	private void remove(SortItem<T> item)
               {
  -               if ( sortInto(result, nowRemaining) )
  +		list.remove(item);
  +		for (SortItem<T> o: list)
                  {
  -                  return true;
  +			o.getWithin().remove(item);
                  }
               }
  +   
  +	private SortItem<T> getInmost() 
  +   {
  +		SortItem<T> res=null;
  +		for (SortItem<T> o: list)
  +      {
  +			if ( o.getWithin().isEmpty() && nobodyWantsAround(o) )
  +         {
  +				res = o;
  +				break;
            }
  -         result.remove(loc);
  -         return false;
         }
  +		return res;
      }
      
  -   private boolean isGoodOrder(List<T> list)
  +	private boolean nobodyWantsAround(SortItem<T> item)
      {
  -      for (int i = 0; i < list.size(); i++)
  +		boolean res = true;
  +		for (SortItem<T> o: list)
         {
  -         for (int j=0; j<i; j++)
  +			if ( o.getAround().contains(item) )
            {
  -            if ( isOrderViolated( list.get(j), list.get(i) ) ) return false;
  +				res = false;
  +				break;
            }
         }
  -      return true;
  +		return res;
      }
   
  -   protected abstract boolean isOrderViolated(T outside, T inside);
  -   
   }