/*******************************************************************************
* Copyright (c) 2005, 2007 IBM Corporation and others.
* 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:
* IBM Corporation - Initial API and implementation
*******************************************************************************/
package org.eclipse.wst.server.ui.internal.viewers;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerSorter;
import org.eclipse.wst.server.core.IRuntimeType;
import org.eclipse.wst.server.core.IServerType;
/**
* Class used to sort categories, runtime types, and server types in the
* New wizards.
*/
public class DefaultViewerSorter extends ViewerSorter {
public static class Version implements Comparable {
private static final String SEPARATORS = ".,";
private final String[] segments;
private Version(String[] segments) {
this.segments = segments;
}
public static Version parseVersion(String version) {
List<String> list = new ArrayList<String>();
StringTokenizer st = new StringTokenizer(version, SEPARATORS, false);
while (st.hasMoreTokens())
list.add(st.nextToken());
String[] s = new String[list.size()];
list.toArray(s);
return new Version(s);
}
private int compareTo(String s1, String s2) {
try {
int i1 = Integer.parseInt(s1);
int i2 = Integer.parseInt(s2);
if (i1 == i2)
return 0;
if (i1 > i2)
return 1;
return -1;
} catch (Exception e) {
// ignore
}
return s1.compareTo(s2);
}
public int compareTo(Object object) {
if (object == this)
return 0;
Version other = (Version) object;
int i = 0;
while (i < segments.length && i < other.segments.length) {
String s1 = segments[i];
String s2 = other.segments[i];
int c = compareTo(s1, s2);
if (c != 0)
return c;
i++;
}
if (i == segments.length && i == other.segments.length)
return 0;
if (i == segments.length)
return -1;
return 1;
}
}
/**
* @see ViewerSorter#compare(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object)
*/
public int compare(Viewer viewer, Object o1, Object o2) {
if (o1 instanceof AbstractTreeContentProvider.TreeElement)
o1 = ((AbstractTreeContentProvider.TreeElement) o1).text;
if (o2 instanceof AbstractTreeContentProvider.TreeElement)
o2 = ((AbstractTreeContentProvider.TreeElement) o2).text;
// filter out strings
if (o1 instanceof String && o2 instanceof String)
return compareCategories((String) o1, (String) o2);
if (o1 instanceof String)
return -1;
if (o2 instanceof String)
return 1;
if (o1 instanceof IRuntimeType && o2 instanceof IRuntimeType)
return compareRuntimeTypes((IRuntimeType) o1, (IRuntimeType) o2);
if (o1 instanceof IServerType && o2 instanceof IServerType)
return compareServerTypes((IServerType) o1, (IServerType) o2);
return 0;
}
/**
* Sort two category names.
*
* @param s1 the first category
* @param s2 the second category
* @return a negative number if the first element is less than the
* second element; the value <code>0</code> if the first element is
* equal to the second element; and a positive number if the first
* element is greater than the second element
*/
protected static int compareCategories(String s1, String s2) {
try {
Version v1 = Version.parseVersion(s1);
Version v2 = Version.parseVersion(s2);
return v1.compareTo(v2);
} catch (NumberFormatException nfe) {
// ignore
}
return s1.compareTo(s2);
}
/**
* Returns <code>true</code> if the two items are in the same 'family', and
* <code>false</code> otherwise.
*
* @param s1 - first name
* @param v1 - first version
* @param s2 - second name
* @param v2 - second version
* @return <code>true</code> if the two items are in the same 'family', and
* <code>false</code> otherwise
*/
protected static boolean isSameFamily(String s1, String v1, String s2, String v2) {
if (s1 == null || s2 == null)
return false;
if (v1 != null) {
int ind = s1.indexOf(v1);
if (ind >= 0)
s1 = s1.substring(0, ind) + s1.substring(ind+v1.length());
}
if (v2 != null) {
int ind = s2.indexOf(v2);
if (ind >= 0)
s2 = s2.substring(0, ind) + s2.substring(ind+v2.length());
}
return (s1.equals(s2));
}
protected static int compareVersions(String s1, String s2) {
Version v1 = Version.parseVersion(s1);
Version v2 = Version.parseVersion(s2);
return v1.compareTo(v2);
}
/**
* Sort two runtime types.
*
* @param r1 the first runtime type
* @param r2 the second runtime type
* @return a negative number if the first element is less than the
* second element; the value <code>0</code> if the first element is
* equal to the second element; and a positive number if the first
* element is greater than the second element
*/
protected static int compareRuntimeTypes(IRuntimeType r1, IRuntimeType r2) {
if (isSameFamily(r1.getName(), r1.getVersion(), r2.getName(), r2.getVersion()))
return compareVersions(r1.getVersion(), r2.getVersion());
return r1.getName().compareToIgnoreCase(r2.getName());
}
/**
* Sort two server types.
*
* @param s1 the first server type
* @param s2 the second server type
* @return a negative number if the first element is less than the
* second element; the value <code>0</code> if the first element is
* equal to the second element; and a positive number if the first
* element is greater than the second element
*/
protected static int compareServerTypes(IServerType s1, IServerType s2) {
IRuntimeType r1 = s1.getRuntimeType();
IRuntimeType r2 = s2.getRuntimeType();
if (r1 != null && r2 != null) {
if (isSameFamily(s1.getName(), r1.getVersion(), s2.getName(), r2.getVersion()))
return compareVersions(r1.getVersion(), r2.getVersion());
}
return s1.getName().compareToIgnoreCase(s2.getName());
}
}