--- ConcatenateOld.java	Sat Jan 13 13:38:36 2001
+++ Concatenate.java	Fri Dec 21 19:30:19 2001
@@ -89,8 +89,24 @@
     private int       verbosity = Project.MSG_VERBOSE;    // Default: Only list files when -verbose is specified.
     private String    separator = null;                   // Separator string (optional).
     private boolean   append    = false;                  // Append to an existing concatenated file.
+	
+	private FileComparator comparator = new FileComparator();
 
-    /** Sets the separator string.
+	public final static String ORDER_NONE = "none";
+	public final static String ORDER_NAME = "name";
+	public final static String ORDER_PATH = "path";
+	public final static String ORDER_DATE = "date";
+	public final static String ORDER_SIZE = "length";
+	
+	/** Enumerates the encoding constants
+	 */	
+	public static class OrderAttribute extends EnumeratedAttribute{
+		public String[] getValues(){
+			return new String[]{ORDER_NONE, ORDER_NAME, ORDER_PATH, ORDER_DATE, ORDER_SIZE};
+		}
+	}
+	
+	/** Sets the separator string.
      * @param sep The separator string.
      */
 public void setSeparator(String sep) { separator = sep; }
@@ -122,6 +138,26 @@
         else
             this.verbosity = Project.MSG_VERBOSE;
     }
+	
+	/**
+	 *
+	 */
+	public void setOrder(OrderAttribute order)
+	{
+		/*
+		String value = order.getValue();
+		if(ORDER_NAME.equals(value))
+			comparator = new FileNameComparator();
+		else if(ORDER_PATH.equals(value))
+			comparator = new FilePathComparator();
+		else if(ORDER_DATE.equals(value))
+			comparator = new FileDateComparator();
+		else if(ORDER_SIZE.equals(value))
+			comparator = new FileSizeComparator();
+		else
+			throw new BuildException("Unsupported ordering",getLocation());
+		 */
+	}
 
     /** Adds a set of files (nested fileset attribute).
      * @param set Adds a fileset element as a set of input files.
@@ -141,7 +177,7 @@
         Vector  inputFiles = new Vector();  // Vector of input files.
 
         // Read the file list, if it was specified.
-        uptodate = readFileList(inputFiles,uptodate);
+        uptodate = false;//readFileList(inputFiles,uptodate);
 
         // deal with the filesets
         for (int i = 0; i < filesets.size(); i++)
@@ -158,13 +194,17 @@
         if (uptodate)
         {
             log("Files are up to date, skipping concatenation.",Project.MSG_VERBOSE);
-            inputFiles.clear();
+            inputFiles.removeAllElements();
         }
-        // do all the copy operations now...
+		
+		//FileNameComparator comparator = new FileNameComparator();
+		mergeSort(inputFiles,comparator);
+		
+		// do all the copy operations now...
         doFileOperations(inputFiles);
 
         // Clean up.
-        inputFiles.clear();
+        inputFiles.removeAllElements();
         destFile = null;
         inputFiles = null;
     }
@@ -313,4 +353,142 @@
             }
         } // if
     } // doFileOperations()
+	
+	public static void mergeSort(Vector fileVector,FileComparator comparator)
+	{
+		String[] files = new String[fileVector.size()];
+		
+		for(int i=0;i<files.length;++i)
+			files[i] = (String)fileVector.elementAt(i);
+		
+		mergeSort(files,comparator);
+		
+		System.out.print("list:");
+		for(int i=0;i<files.length;++i)
+			System.out.print(" " + files[i]);
+		System.out.println(".");
+		
+		fileVector.removeAllElements();
+		for(int i=0;i<files.length;++i)
+			fileVector.addElement(files[i]);
+	}
+	
+	public static void mergeSort(String list[],FileComparator comparator)
+	{
+		mergeSort(list, new String[list.length], 0,list.length-1,comparator);
+	}
+	
+	private static void mergeSort(String list[], String temp[], int left,int right,FileComparator comparator)
+	{
+		if(left<right)
+		{
+			int mid = (left + right) >> 1;
+			mergeSort(list,temp,left,mid,comparator);
+			mergeSort(list,temp,mid+1,right,comparator);
+			merge(list,temp,left,mid,right,comparator);
+		}
+	}
+	
+	private static void merge(String list[], String temp[], int left, int mid, int right,FileComparator comparator)
+	{
+		int t = left;
+		int s1 = left;
+		int s2 = mid+1;
+		
+		System.arraycopy(list,0,temp,0,list.length);
+		
+		while(s1<=mid && s2<=right)
+		{
+			if(comparator.compare(temp[s1],temp[s2])<0)
+				list[t++] = temp[s1++];
+			else
+				list[t++] = temp[s2++];
+		}
+		
+		while(s1<=mid)
+			list[t++] = temp[s1++];
+		
+		while(s2<=right)
+			list[t++] = temp[s2++];
+	}
 }
+
+class FileComparator
+	implements Comparator
+{
+	protected boolean inverted = false;
+	
+	public final int compare(Object o1, Object o2)
+	{
+		return compare((File)o1,(File)o2);
+	}
+
+	public final int compare(String s1,String s2)
+	{
+		return compare(new File(s1),new File(s2));
+	}
+
+	public int compare(File f1, File f2)
+	{
+		return 0;
+	}
+	
+	public void setInverted(boolean b)
+	{
+		inverted = b;
+	}
+}
+
+class FileNameComparator
+	extends FileComparator
+{
+	public int compare(File f1, File f2)
+	{
+		int result = f1.getName().compareTo(f2.getName());
+		if(inverted)
+			return -result;
+		else
+			return result;
+	}
+}
+
+class FilePathComparator
+	extends FileComparator
+{
+	public int compare(File f1, File f2)
+	{
+		int result = f1.getParent().compareTo(f2.getParent());
+		if(inverted)
+			return -result;
+		else
+			return result;
+	}
+}
+
+class FileDateComparator
+	extends FileComparator
+{
+	public int compare(File f1, File f2)
+	{
+		int result = (int)(f1.lastModified() - f2.lastModified());
+		if(inverted)
+			return -result;
+		else
+			return result;
+	}
+}
+
+class FileSizeComparator
+	extends FileComparator
+{
+	public int compare(File f1, File f2)
+	{
+		int result = (int)(f1.length() - f2.length());
+		if(inverted)
+			return -result;
+		else
+			return result;
+	}
+}
+
+