plugins/maven/src/main/java/org/jetbrains/idea/maven/dom/MavenVersionComparable.java - platform/tools/idea - Git at Google

 package org.jetbrains.idea.maven.dom;

 import java.math.BigInteger;
 import java.util.*;

 /**
  * Copy pasted from org.apache.maven.artifact.versioning.ComparableVersion
  *
  * @author Sergey Evdokimov
  */
 public class MavenVersionComparable implements Comparable<MavenVersionComparable> {
   private String value;

   private String canonical;

   private ListItem items;

   private interface Item {
     int INTEGER_ITEM = 0;
     int STRING_ITEM = 1;
     int LIST_ITEM = 2;

     int compareTo(Item item);

     int getType();

     boolean isNull();
   }

   /**
    * Represents a numeric item in the version item list.
    */
   private static class IntegerItem
     implements Item {
     private static final BigInteger BigInteger_ZERO = new BigInteger("0");

     private final BigInteger value;

     public static final IntegerItem ZERO = new IntegerItem();

     private IntegerItem() {
       this.value = BigInteger_ZERO;
     }

     public IntegerItem(String str) {
       this.value = new BigInteger(str);
     }

     public int getType() {
       return INTEGER_ITEM;
     }

     public boolean isNull() {
       return BigInteger_ZERO.equals(value);
     }

     public int compareTo(Item item) {
       if (item == null) {
         return BigInteger_ZERO.equals(value) ? 0 : 1; // 1.0 == 1, 1.1 > 1
       }

       switch (item.getType()) {
         case INTEGER_ITEM:
           return value.compareTo(((IntegerItem)item).value);

         case STRING_ITEM:
           return 1; // 1.1 > 1-sp

         case LIST_ITEM:
           return 1; // 1.1 > 1-1

         default:
           throw new RuntimeException("invalid item: " + item.getClass());
       }
     }

     public String toString() {
       return value.toString();
     }
   }

   /**
    * Represents a string in the version item list, usually a qualifier.
    */
   private static class StringItem
     implements Item {
     private static final String[] QUALIFIERS = {"alpha", "beta", "milestone", "rc", "snapshot", "", "sp"};

     private static final List<String> _QUALIFIERS = Arrays.asList(QUALIFIERS);

     private static final Properties ALIASES = new Properties();

     static {
       ALIASES.setProperty("ga", "");
       ALIASES.setProperty("final", "");
       ALIASES.setProperty("cr", "rc");
     }

     /**
      * A comparable value for the empty-string qualifier. This one is used to determine if a given qualifier makes
      * the version older than one without a qualifier, or more recent.
      */
     private static final String RELEASE_VERSION_INDEX = String.valueOf(_QUALIFIERS.indexOf(""));

     private String value;

     public StringItem(String value, boolean followedByDigit) {
       if (followedByDigit && value.length() == 1) {
         // a1 = alpha-1, b1 = beta-1, m1 = milestone-1
         switch (value.charAt(0)) {
           case 'a':
             value = "alpha";
             break;
           case 'b':
             value = "beta";
             break;
           case 'm':
             value = "milestone";
             break;
         }
       }
       this.value = ALIASES.getProperty(value, value);
     }

     public int getType() {
       return STRING_ITEM;
     }

     public boolean isNull() {
       return (comparableQualifier(value).compareTo(RELEASE_VERSION_INDEX) == 0);
     }

     /**
      * Returns a comparable value for a qualifier.
      * <p/>
      * This method both takes into account the ordering of known qualifiers as well as lexical ordering for unknown
      * qualifiers.
      * <p/>
      * just returning an Integer with the index here is faster, but requires a lot of if/then/else to check for -1
      * or QUALIFIERS.size and then resort to lexical ordering. Most comparisons are decided by the first character,
      * so this is still fast. If more characters are needed then it requires a lexical sort anyway.
      *
      * @param qualifier
      * @return an equivalent value that can be used with lexical comparison
      */
     public static String comparableQualifier(String qualifier) {
       int i = _QUALIFIERS.indexOf(qualifier);

       return i == -1 ? _QUALIFIERS.size() + "-" + qualifier : String.valueOf(i);
     }

     public int compareTo(Item item) {
       if (item == null) {
         // 1-rc < 1, 1-ga > 1
         return comparableQualifier(value).compareTo(RELEASE_VERSION_INDEX);
       }
       switch (item.getType()) {
         case INTEGER_ITEM:
           return -1; // 1.any < 1.1 ?

         case STRING_ITEM:
           return comparableQualifier(value).compareTo(comparableQualifier(((StringItem)item).value));

         case LIST_ITEM:
           return -1; // 1.any < 1-1

         default:
           throw new RuntimeException("invalid item: " + item.getClass());
       }
     }

     public String toString() {
       return value;
     }
   }

   /**
    * Represents a version list item. This class is used both for the global item list and for sub-lists (which start
    * with '-(number)' in the version specification).
    */
   private static class ListItem
     extends ArrayList<Item>
     implements Item {
     public int getType() {
       return LIST_ITEM;
     }

     public boolean isNull() {
       return (size() == 0);
     }

     void normalize() {
       for (ListIterator<Item> iterator = listIterator(size()); iterator.hasPrevious(); ) {
         Item item = iterator.previous();
         if (item.isNull()) {
           iterator.remove(); // remove null trailing items: 0, "", empty list
         }
         else {
           break;
         }
       }
     }

     public int compareTo(Item item) {
       if (item == null) {
         if (size() == 0) {
           return 0; // 1-0 = 1- (normalize) = 1
         }
         Item first = get(0);
         return first.compareTo(null);
       }
       switch (item.getType()) {
         case INTEGER_ITEM:
           return -1; // 1-1 < 1.0.x

         case STRING_ITEM:
           return 1; // 1-1 > 1-sp

         case LIST_ITEM:
           Iterator<Item> left = iterator();
           Iterator<Item> right = ((ListItem)item).iterator();

           while (left.hasNext() || right.hasNext()) {
             Item l = left.hasNext() ? left.next() : null;
             Item r = right.hasNext() ? right.next() : null;

             // if this is shorter, then invert the compare and mul with -1
             int result = l == null ? -1 * r.compareTo(l) : l.compareTo(r);

             if (result != 0) {
               return result;
             }
           }

           return 0;

         default:
           throw new RuntimeException("invalid item: " + item.getClass());
       }
     }

     public String toString() {
       StringBuilder buffer = new StringBuilder("(");
       for (Iterator<Item> iter = iterator(); iter.hasNext(); ) {
         buffer.append(iter.next());
         if (iter.hasNext()) {
           buffer.append(',');
         }
       }
       buffer.append(')');
       return buffer.toString();
     }
   }

   public MavenVersionComparable(String version) {
     parseVersion(version);
   }

   public final void parseVersion(String version) {
     this.value = version;

     items = new ListItem();

     version = version.toLowerCase(Locale.ENGLISH);

     ListItem list = items;

     Stack<Item> stack = new Stack<Item>();
     stack.push(list);

     boolean isDigit = false;

     int startIndex = 0;

     for (int i = 0; i < version.length(); i++) {
       char c = version.charAt(i);

       if (c == '.') {
         if (i == startIndex) {
           list.add(IntegerItem.ZERO);
         }
         else {
           list.add(parseItem(isDigit, version.substring(startIndex, i)));
         }
         startIndex = i + 1;
       }
       else if (c == '-') {
         if (i == startIndex) {
           list.add(IntegerItem.ZERO);
         }
         else {
           list.add(parseItem(isDigit, version.substring(startIndex, i)));
         }
         startIndex = i + 1;

         if (isDigit) {
           list.normalize(); // 1.0-* = 1-*

           if ((i + 1 < version.length()) && Character.isDigit(version.charAt(i + 1))) {
             // new ListItem only if previous were digits and new char is a digit,
             // ie need to differentiate only 1.1 from 1-1
             list.add(list = new ListItem());

             stack.push(list);
           }
         }
       }
       else if (Character.isDigit(c)) {
         if (!isDigit && i > startIndex) {
           list.add(new StringItem(version.substring(startIndex, i), true));
           startIndex = i;
         }

         isDigit = true;
       }
       else {
         if (isDigit && i > startIndex) {
           list.add(parseItem(true, version.substring(startIndex, i)));
           startIndex = i;
         }

         isDigit = false;
       }
     }

     if (version.length() > startIndex) {
       list.add(parseItem(isDigit, version.substring(startIndex)));
     }

     while (!stack.isEmpty()) {
       list = (ListItem)stack.pop();
       list.normalize();
     }

     canonical = items.toString();
   }

   private static Item parseItem(boolean isDigit, String buf) {
     return isDigit ? new IntegerItem(buf) : new StringItem(buf, false);
   }

   public int compareTo(MavenVersionComparable o) {
     return items.compareTo(o.items);
   }

   public String toString() {
     return value;
   }

   public boolean equals(Object o) {
     return (o instanceof MavenVersionComparable) && canonical.equals(((MavenVersionComparable)o).canonical);
   }

   public int hashCode() {
     return canonical.hashCode();
   }
 }
	package org.jetbrains.idea.maven.dom;

	import java.math.BigInteger;
	import java.util.*;

	/**
	* Copy pasted from org.apache.maven.artifact.versioning.ComparableVersion
	*
	* @author Sergey Evdokimov
	*/
	public class MavenVersionComparable implements Comparable<MavenVersionComparable> {
	private String value;

	private String canonical;

	private ListItem items;

	private interface Item {
	int INTEGER_ITEM = 0;
	int STRING_ITEM = 1;
	int LIST_ITEM = 2;

	int compareTo(Item item);

	int getType();

	boolean isNull();
	}

	/**
	* Represents a numeric item in the version item list.
	*/
	private static class IntegerItem
	implements Item {
	private static final BigInteger BigInteger_ZERO = new BigInteger("0");

	private final BigInteger value;

	public static final IntegerItem ZERO = new IntegerItem();

	private IntegerItem() {
	this.value = BigInteger_ZERO;
	}

	public IntegerItem(String str) {
	this.value = new BigInteger(str);
	}

	public int getType() {
	return INTEGER_ITEM;
	}

	public boolean isNull() {
	return BigInteger_ZERO.equals(value);
	}

	public int compareTo(Item item) {
	if (item == null) {
	return BigInteger_ZERO.equals(value) ? 0 : 1; // 1.0 == 1, 1.1 > 1
	}

	switch (item.getType()) {
	case INTEGER_ITEM:
	return value.compareTo(((IntegerItem)item).value);

	case STRING_ITEM:
	return 1; // 1.1 > 1-sp

	case LIST_ITEM:
	return 1; // 1.1 > 1-1

	default:
	throw new RuntimeException("invalid item: " + item.getClass());
	}
	}

	public String toString() {
	return value.toString();
	}
	}

	/**
	* Represents a string in the version item list, usually a qualifier.
	*/
	private static class StringItem
	implements Item {
	private static final String[] QUALIFIERS = {"alpha", "beta", "milestone", "rc", "snapshot", "", "sp"};

	private static final List<String> _QUALIFIERS = Arrays.asList(QUALIFIERS);

	private static final Properties ALIASES = new Properties();

	static {
	ALIASES.setProperty("ga", "");
	ALIASES.setProperty("final", "");
	ALIASES.setProperty("cr", "rc");
	}

	/**
	* A comparable value for the empty-string qualifier. This one is used to determine if a given qualifier makes
	* the version older than one without a qualifier, or more recent.
	*/
	private static final String RELEASE_VERSION_INDEX = String.valueOf(_QUALIFIERS.indexOf(""));

	private String value;

	public StringItem(String value, boolean followedByDigit) {
	if (followedByDigit && value.length() == 1) {
	// a1 = alpha-1, b1 = beta-1, m1 = milestone-1
	switch (value.charAt(0)) {
	case 'a':
	value = "alpha";
	break;
	case 'b':
	value = "beta";
	break;
	case 'm':
	value = "milestone";
	break;
	}
	}
	this.value = ALIASES.getProperty(value, value);
	}

	public int getType() {
	return STRING_ITEM;
	}

	public boolean isNull() {
	return (comparableQualifier(value).compareTo(RELEASE_VERSION_INDEX) == 0);
	}

	/**
	* Returns a comparable value for a qualifier.
	* <p/>
	* This method both takes into account the ordering of known qualifiers as well as lexical ordering for unknown
	* qualifiers.
	* <p/>
	* just returning an Integer with the index here is faster, but requires a lot of if/then/else to check for -1
	* or QUALIFIERS.size and then resort to lexical ordering. Most comparisons are decided by the first character,
	* so this is still fast. If more characters are needed then it requires a lexical sort anyway.
	*
	* @param qualifier
	* @return an equivalent value that can be used with lexical comparison
	*/
	public static String comparableQualifier(String qualifier) {
	int i = _QUALIFIERS.indexOf(qualifier);

	return i == -1 ? _QUALIFIERS.size() + "-" + qualifier : String.valueOf(i);
	}

	public int compareTo(Item item) {
	if (item == null) {
	// 1-rc < 1, 1-ga > 1
	return comparableQualifier(value).compareTo(RELEASE_VERSION_INDEX);
	}
	switch (item.getType()) {
	case INTEGER_ITEM:
	return -1; // 1.any < 1.1 ?

	case STRING_ITEM:
	return comparableQualifier(value).compareTo(comparableQualifier(((StringItem)item).value));

	case LIST_ITEM:
	return -1; // 1.any < 1-1

	default:
	throw new RuntimeException("invalid item: " + item.getClass());
	}
	}

	public String toString() {
	return value;
	}
	}

	/**
	* Represents a version list item. This class is used both for the global item list and for sub-lists (which start
	* with '-(number)' in the version specification).
	*/
	private static class ListItem
	extends ArrayList<Item>
	implements Item {
	public int getType() {
	return LIST_ITEM;
	}

	public boolean isNull() {
	return (size() == 0);
	}

	void normalize() {
	for (ListIterator<Item> iterator = listIterator(size()); iterator.hasPrevious(); ) {
	Item item = iterator.previous();
	if (item.isNull()) {
	iterator.remove(); // remove null trailing items: 0, "", empty list
	}
	else {
	break;
	}
	}
	}

	public int compareTo(Item item) {
	if (item == null) {
	if (size() == 0) {
	return 0; // 1-0 = 1- (normalize) = 1
	}
	Item first = get(0);
	return first.compareTo(null);
	}
	switch (item.getType()) {
	case INTEGER_ITEM:
	return -1; // 1-1 < 1.0.x

	case STRING_ITEM:
	return 1; // 1-1 > 1-sp

	case LIST_ITEM:
	Iterator<Item> left = iterator();
	Iterator<Item> right = ((ListItem)item).iterator();

	while (left.hasNext() \|\| right.hasNext()) {
	Item l = left.hasNext() ? left.next() : null;
	Item r = right.hasNext() ? right.next() : null;

	// if this is shorter, then invert the compare and mul with -1
	int result = l == null ? -1 * r.compareTo(l) : l.compareTo(r);

	if (result != 0) {
	return result;
	}
	}

	return 0;

	default:
	throw new RuntimeException("invalid item: " + item.getClass());
	}
	}

	public String toString() {
	StringBuilder buffer = new StringBuilder("(");
	for (Iterator<Item> iter = iterator(); iter.hasNext(); ) {
	buffer.append(iter.next());
	if (iter.hasNext()) {
	buffer.append(',');
	}
	}
	buffer.append(')');
	return buffer.toString();
	}
	}

	public MavenVersionComparable(String version) {
	parseVersion(version);
	}

	public final void parseVersion(String version) {
	this.value = version;

	items = new ListItem();

	version = version.toLowerCase(Locale.ENGLISH);

	ListItem list = items;

	Stack<Item> stack = new Stack<Item>();
	stack.push(list);

	boolean isDigit = false;

	int startIndex = 0;

	for (int i = 0; i < version.length(); i++) {
	char c = version.charAt(i);

	if (c == '.') {
	if (i == startIndex) {
	list.add(IntegerItem.ZERO);
	}
	else {
	list.add(parseItem(isDigit, version.substring(startIndex, i)));
	}
	startIndex = i + 1;
	}
	else if (c == '-') {
	if (i == startIndex) {
	list.add(IntegerItem.ZERO);
	}
	else {
	list.add(parseItem(isDigit, version.substring(startIndex, i)));
	}
	startIndex = i + 1;

	if (isDigit) {
	list.normalize(); // 1.0-* = 1-*

	if ((i + 1 < version.length()) && Character.isDigit(version.charAt(i + 1))) {
	// new ListItem only if previous were digits and new char is a digit,
	// ie need to differentiate only 1.1 from 1-1
	list.add(list = new ListItem());

	stack.push(list);
	}
	}
	}
	else if (Character.isDigit(c)) {
	if (!isDigit && i > startIndex) {
	list.add(new StringItem(version.substring(startIndex, i), true));
	startIndex = i;
	}

	isDigit = true;
	}
	else {
	if (isDigit && i > startIndex) {
	list.add(parseItem(true, version.substring(startIndex, i)));
	startIndex = i;
	}

	isDigit = false;
	}
	}

	if (version.length() > startIndex) {
	list.add(parseItem(isDigit, version.substring(startIndex)));
	}

	while (!stack.isEmpty()) {
	list = (ListItem)stack.pop();
	list.normalize();
	}

	canonical = items.toString();
	}

	private static Item parseItem(boolean isDigit, String buf) {
	return isDigit ? new IntegerItem(buf) : new StringItem(buf, false);
	}

	public int compareTo(MavenVersionComparable o) {
	return items.compareTo(o.items);
	}

	public String toString() {
	return value;
	}

	public boolean equals(Object o) {
	return (o instanceof MavenVersionComparable) && canonical.equals(((MavenVersionComparable)o).canonical);
	}

	public int hashCode() {
	return canonical.hashCode();
	}
	}