Version.java

/*******************************************************************************
 * Copyright (c) 2001, 2010 Mathew A. Nelson and Robocode contributors
 * 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://robocode.sourceforge.net/license/epl-v10.html
 *
 * Contributors:
 *     Flemming N. Larsen
 *     - Initial implementation
 *******************************************************************************/
package net.sf.robocode.version;


/**
 * @author Flemming N. Larsen (original)
 */
public class Version implements Comparable<Object> {

	private final String version;

	// The allowed format is <major>.<minor>.<revision>.<build> where all of these are ints
	private final int major;
	private final int minor;
	private final int revision;
	private final int build;

	// <maturity> <maturity version>, e.g. in "Beta 3" the maturity is 2, and maturity version is 3 
	public final int maturity; // Alpha is 1, Beta is 2, Final is 3
	public final int maturity_version; // The number following e.g. "Alpha" or "Beta"

	public Version(String version) {
		
		// Validate version format
		if (!version.matches("\\s*[0-9]+\\.[0-9]+(\\.[0-9]+)?(\\.[0-9]+)?(\\s?(([aA]lpha)|([bB]eta))(\\s?[0-9]+)?)?\\s*")) {
			throw new IllegalArgumentException("The format of the version string is not a valid");
		}
		version = version.trim();
		this.version = version;

		// Split the version number into its integer numbers
		final String[] numbers = version.split("\\.");

		// Parse the major version
		int major = 0;

		if (numbers.length >= 1) {
			try {
				major = Integer.parseInt(numbers[0]);
			} catch (NumberFormatException ignore) {}
		}
		this.major = major;

		// Parse the minor version
		int minor = 0;

		if (numbers.length >= 2) {
			try {
				String[] split = numbers[1].split("\\s++|([aA]lpha)|([bB]eta)");
				
				minor = Integer.parseInt(split[0]);
			} catch (NumberFormatException ignore) {}
		}
		this.minor = minor;

		// Parse the revision
		int revision = 0;

		if (numbers.length >= 3) {
			try {
				String[] split = numbers[2].split("\\s++|([aA]lpha)|([bB]eta)");

				revision = Integer.parseInt(split[0]);
			} catch (NumberFormatException ignore) {}
		}
		this.revision = revision;

		// Parse the build number
		int build = 0;

		if (numbers.length >= 4) {
			try {
				String[] split = numbers[3].split("\\s++|([aA]lpha)|([bB]eta)");

				build = Integer.parseInt(split[0]);
			} catch (NumberFormatException ignore) {}
		}
		this.build = build;

		// Parse the maturity version, e.g. "Beta 1"
		int maturity;
		int maturity_version = 1;

		if (isAlpha()) {
			maturity = 1;
			final String[] split = version.split("[aA]lpha");

			if (split.length >= 2) {
				maturity_version = Integer.parseInt(split[1].trim());
			}
		} else if (isBeta()) {
			maturity = 2;
			final String[] split = version.split("[bB]eta");

			if (split.length >= 2) {
				maturity_version = Integer.parseInt(split[1].trim());
			}
		} else {
			maturity = 3;
		}
		this.maturity = maturity;
		this.maturity_version = maturity_version;
	}

	public boolean isAlpha() {
		return (version.matches(".*[aA]lpha.*"));
	}

	public boolean isBeta() {
		return (version.matches(".*[bB]eta.*"));
	}

	public boolean isFinal() {
		return !(isAlpha() || isBeta());
	}

	public int getMajor() {
		return major;
	}

	public int getMinor() {
		return minor;
	}

	public int getRevision() {
		return revision;
	}

	public int getBuild() {
		return build;
	}

	@Override
	public String toString() {
		return version;
	}

	public int compareTo(Object o) {
		if (o == null) {
			throw new IllegalArgumentException("The input object cannot be null");
		}
		if (o instanceof String) {
			return compareTo(new Version((String) o));
		}
		if (o instanceof Version) {
			Version v = (Version) o;

			long delta = getVersionLong() - v.getVersionLong();

			return (delta == 0) ? 0 : (delta < 0) ? -1 : 1;
		}
		throw new IllegalArgumentException("The input object must be a String or Version object");
	}

	private long getVersionLong() {
		return ((long) major << 40) + ((long) minor << 32) + (revision << 24) + (build << 16) + (maturity << 8)
				+ maturity_version;
	}

	public static int compare(String oneVersion, String anotherVersion) {
		return new Version(oneVersion).compareTo(new Version(anotherVersion));
	}

	public static boolean isAlpha(String version) {
		return new Version(version).isAlpha();
	}

	public static boolean isBeta(String version) {
		return new Version(version).isBeta();
	}

	public static boolean isFinal(String version) {
		return new Version(version).isFinal();
	}
}