[fanfix.git] / Version.java

package be.nikiroo.utils;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * This class describe a program {@link Version}.
 * 
 * @author niki
 */
public class Version implements Comparable<Version> {
	private String version;
	private int major;
	private int minor;
	private int patch;
	private String tag;
	private int tagVersion;

	/**
	 * Create a new, empty {@link Version}.
	 * 
	 */
	public Version() {
	}

	/**
	 * Create a new {@link Version} with the given values.
	 * 
	 * @param major
	 *            the major version
	 * @param minor
	 *            the minor version
	 * @param patch
	 *            the patch version
	 */
	public Version(int major, int minor, int patch) {
		this(major, minor, patch, null, -1);
	}

	/**
	 * Create a new {@link Version} with the given values.
	 * 
	 * @param major
	 *            the major version
	 * @param minor
	 *            the minor version
	 * @param patch
	 *            the patch version
	 * @param tag
	 *            a tag name for this version
	 */
	public Version(int major, int minor, int patch, String tag) {
		this(major, minor, patch, tag, -1);
	}

	/**
	 * Create a new {@link Version} with the given values.
	 * 
	 * @param major
	 *            the major version
	 * @param minor
	 *            the minor version
	 * @param patch
	 *            the patch version the patch version
	 * @param tag
	 *            a tag name for this version
	 * @param tagVersion
	 *            the version of the tagged version
	 */
	public Version(int major, int minor, int patch, String tag, int tagVersion) {
		if (tagVersion >= 0 && tag == null) {
			throw new java.lang.IllegalArgumentException(
					"A tag version cannot be used without a tag");
		}

		this.major = major;
		this.minor = minor;
		this.patch = patch;
		this.tag = tag;
		this.tagVersion = tagVersion;

		this.version = generateVersion();
	}

	/**
	 * Create a new {@link Version} with the given value, which must be in the
	 * form <tt>MAJOR.MINOR.PATCH(-TAG(TAG_VERSION))</tt>.
	 * 
	 * @param version
	 *            the version (<tt>MAJOR.MINOR.PATCH</tt>,
	 *            <tt>MAJOR.MINOR.PATCH-TAG</tt> or
	 *            <tt>MAJOR.MINOR.PATCH-TAGVERSIONTAG</tt>)
	 */
	public Version(String version) {
		try {
			String[] tab = version.split("\\.");
			this.major = Integer.parseInt(tab[0].trim());
			this.minor = Integer.parseInt(tab[1].trim());
			if (tab[2].contains("-")) {
				int posInVersion = version.indexOf('.');
				posInVersion = version.indexOf('.', posInVersion + 1);
				String rest = version.substring(posInVersion + 1);

				int posInRest = rest.indexOf('-');
				this.patch = Integer.parseInt(rest.substring(0, posInRest)
						.trim());

				posInVersion = version.indexOf('-');
				this.tag = version.substring(posInVersion + 1).trim();
				this.tagVersion = -1;

				StringBuilder str = new StringBuilder();
				while (!tag.isEmpty() && tag.charAt(tag.length() - 1) >= '0'
						&& tag.charAt(tag.length() - 1) <= '9') {
					str.insert(0, tag.charAt(tag.length() - 1));
					tag = tag.substring(0, tag.length() - 1);
				}

				if (str.length() > 0) {
					this.tagVersion = Integer.parseInt(str.toString());
				}
			} else {
				this.patch = Integer.parseInt(tab[2].trim());
				this.tag = null;
				this.tagVersion = -1;
			}

			this.version = generateVersion();
		} catch (Exception e) {
			this.major = 0;
			this.minor = 0;
			this.patch = 0;
			this.tag = null;
			this.tagVersion = -1;
			this.version = null;
		}
	}

	/**
	 * The 'major' version.
	 * <p>
	 * This version should only change when API-incompatible changes are made to
	 * the program.
	 * 
	 * @return the major version
	 */
	public int getMajor() {
		return major;
	}

	/**
	 * The 'minor' version.
	 * <p>
	 * This version should only change when new, backwards-compatible
	 * functionality has been added to the program.
	 * 
	 * @return the minor version
	 */
	public int getMinor() {
		return minor;
	}

	/**
	 * The 'patch' version.
	 * <p>
	 * This version should change when backwards-compatible bugfixes have been
	 * added to the program.
	 * 
	 * @return the patch version
	 */
	public int getPatch() {
		return patch;
	}

	/**
	 * A tag name for this version.
	 * 
	 * @return the tag
	 */
	public String getTag() {
		return tag;
	}

	/**
	 * The version of the tag, or -1 for no version.
	 * 
	 * @return the tag version
	 */
	public int getTagVersion() {
		return tagVersion;
	}

	/**
	 * Check if this {@link Version} is "empty" (i.e., the version was not
	 * parse-able or not given).
	 * 
	 * @return TRUE if it is empty
	 */
	public boolean isEmpty() {
		return version == null;
	}

	/**
	 * Check if we are more recent than the given {@link Version}.
	 * <p>
	 * Note that a tagged version is considered newer than a non-tagged version,
	 * but two tagged versions with different tags are not comparable.
	 * <p>
	 * Also, an empty version is always considered older.
	 * 
	 * @param o
	 *            the other {@link Version}
	 * @return TRUE if this {@link Version} is more recent than the given one
	 */
	public boolean isNewerThan(Version o) {
		if (isEmpty()) {
			return false;
		} else if (o.isEmpty()) {
			return true;
		}

		if (major > o.major) {
			return true;
		}

		if (major == o.major && minor > o.minor) {
			return true;
		}

		if (major == o.major && minor == o.minor && patch > o.patch) {
			return true;
		}

		// a tagged version is considered newer than a non-tagged one
		if (major == o.major && minor == o.minor && patch == o.patch
				&& tag != null && o.tag == null) {
			return true;
		}

		// 2 <> tagged versions are not comparable
		boolean sameTag = (tag == null && o.tag == null)
				|| (tag != null && tag.equals(o.tag));
		if (major == o.major && minor == o.minor && patch == o.patch && sameTag
				&& tagVersion > o.tagVersion) {
			return true;
		}

		return false;
	}

	/**
	 * Check if we are older than the given {@link Version}.
	 * <p>
	 * Note that a tagged version is considered newer than a non-tagged version,
	 * but two tagged versions with different tags are not comparable.
	 * <p>
	 * Also, an empty version is always considered older.
	 * 
	 * @param o
	 *            the other {@link Version}
	 * @return TRUE if this {@link Version} is older than the given one
	 */
	public boolean isOlderThan(Version o) {
		if (o.isEmpty()) {
			return false;
		} else if (isEmpty()) {
			return true;
		}

		// 2 <> tagged versions are not comparable
		boolean sameTag = (tag == null && o.tag == null)
				|| (tag != null && tag.equals(o.tag));
		if (major == o.major && minor == o.minor && patch == o.patch
				&& !sameTag) {
			return false;
		}

		return !equals(o) && !isNewerThan(o);
	}

	/**
	 * Return the version of the running program if it follows the VERSION
	 * convention (i.e., if it has a file called VERSION containing the version
	 * as a {@link String} in its binary root, and if this {@link String}
	 * follows the Major/Minor/Patch convention).
	 * <p>
	 * If it does not, return an empty {@link Version} object.
	 * 
	 * @return the {@link Version} of the program, or an empty {@link Version}
	 *         (does not return NULL)
	 */
	public static Version getCurrentVersion() {
		String version = null;

		InputStream in = IOUtils.openResource("VERSION");
		if (in != null) {
			try {
				ByteArrayOutputStream ba = new ByteArrayOutputStream();
				IOUtils.write(in, ba);
				in.close();

				version = ba.toString("UTF-8").trim();
			} catch (IOException e) {
			}
		}

		return new Version(version);
	}

	@Override
	public int compareTo(Version o) {
		if (equals(o)) {
			return 0;
		} else if (isNewerThan(o)) {
			return 1;
		} else {
			return -1;
		}
	}

	@Override
	public boolean equals(Object obj) {
		if (obj instanceof Version) {
			Version o = (Version) obj;
			if (isEmpty()) {
				return o.isEmpty();
			}

			boolean sameTag = (tag == null && o.tag == null)
					|| (tag != null && tag.equals(o.tag));
			return o.major == major && o.minor == minor && o.patch == patch
					&& sameTag && o.tagVersion == tagVersion;
		}

		return false;
	}

	@Override
	public int hashCode() {
		return version == null ? 0 : version.hashCode();
	}

	/**
	 * Return a user-readable form of this {@link Version}.
	 */
	@Override
	public String toString() {
		return version == null ? "[unknown]" : version;
	}

	/**
	 * Generate the clean version {@link String} from the current values.
	 * 
	 * @return the clean version string
	 */
	private String generateVersion() {
		String tagSuffix = "";
		if (tag != null) {
			tagSuffix = "-" + tag
					+ (tagVersion >= 0 ? Integer.toString(tagVersion) : "");
		}

		return String.format("%d.%d.%d%s", major, minor, patch, tagSuffix);
	}
}
Commit	Line	Data
	1	package be.nikiroo.utils;
	2
	3	import java.io.ByteArrayOutputStream;
	4	import java.io.IOException;
	5	import java.io.InputStream;
	6
	7	/**
	8	* This class describe a program {@link Version}.
	9	*
	10	* @author niki
	11	*/
	12	public class Version implements Comparable<Version> {
	13	private String version;
	14	private int major;
	15	private int minor;
	16	private int patch;
	17	private String tag;
	18	private int tagVersion;
	19
	20	/**
	21	* Create a new, empty {@link Version}.
	22	*
	23	*/
	24	public Version() {
	25	}
	26
	27	/**
	28	* Create a new {@link Version} with the given values.
	29	*
	30	* @param major
	31	* the major version
	32	* @param minor
	33	* the minor version
	34	* @param patch
	35	* the patch version
	36	*/
	37	public Version(int major, int minor, int patch) {
	38	this(major, minor, patch, null, -1);
	39	}
	40
	41	/**
	42	* Create a new {@link Version} with the given values.
	43	*
	44	* @param major
	45	* the major version
	46	* @param minor
	47	* the minor version
	48	* @param patch
	49	* the patch version
	50	* @param tag
	51	* a tag name for this version
	52	*/
	53	public Version(int major, int minor, int patch, String tag) {
	54	this(major, minor, patch, tag, -1);
	55	}
	56
	57	/**
	58	* Create a new {@link Version} with the given values.
	59	*
	60	* @param major
	61	* the major version
	62	* @param minor
	63	* the minor version
	64	* @param patch
	65	* the patch version the patch version
	66	* @param tag
	67	* a tag name for this version
	68	* @param tagVersion
	69	* the version of the tagged version
	70	*/
	71	public Version(int major, int minor, int patch, String tag, int tagVersion) {
	72	if (tagVersion >= 0 && tag == null) {
	73	throw new java.lang.IllegalArgumentException(
	74	"A tag version cannot be used without a tag");
	75	}
	76
	77	this.major = major;
	78	this.minor = minor;
	79	this.patch = patch;
	80	this.tag = tag;
	81	this.tagVersion = tagVersion;
	82
	83	this.version = generateVersion();
	84	}
	85
	86	/**
	87	* Create a new {@link Version} with the given value, which must be in the
	88	* form <tt>MAJOR.MINOR.PATCH(-TAG(TAG_VERSION))</tt>.
	89	*
	90	* @param version
	91	* the version (<tt>MAJOR.MINOR.PATCH</tt>,
	92	* <tt>MAJOR.MINOR.PATCH-TAG</tt> or
	93	* <tt>MAJOR.MINOR.PATCH-TAGVERSIONTAG</tt>)
	94	*/
	95	public Version(String version) {
	96	try {
	97	String[] tab = version.split("\\.");
	98	this.major = Integer.parseInt(tab[0].trim());
	99	this.minor = Integer.parseInt(tab[1].trim());
	100	if (tab[2].contains("-")) {
	101	int posInVersion = version.indexOf('.');
	102	posInVersion = version.indexOf('.', posInVersion + 1);
	103	String rest = version.substring(posInVersion + 1);
	104
	105	int posInRest = rest.indexOf('-');
	106	this.patch = Integer.parseInt(rest.substring(0, posInRest)
	107	.trim());
	108
	109	posInVersion = version.indexOf('-');
	110	this.tag = version.substring(posInVersion + 1).trim();
	111	this.tagVersion = -1;
	112
	113	StringBuilder str = new StringBuilder();
	114	while (!tag.isEmpty() && tag.charAt(tag.length() - 1) >= '0'
	115	&& tag.charAt(tag.length() - 1) <= '9') {
	116	str.insert(0, tag.charAt(tag.length() - 1));
	117	tag = tag.substring(0, tag.length() - 1);
	118	}
	119
	120	if (str.length() > 0) {
	121	this.tagVersion = Integer.parseInt(str.toString());
	122	}
	123	} else {
	124	this.patch = Integer.parseInt(tab[2].trim());
	125	this.tag = null;
	126	this.tagVersion = -1;
	127	}
	128
	129	this.version = generateVersion();
	130	} catch (Exception e) {
	131	this.major = 0;
	132	this.minor = 0;
	133	this.patch = 0;
	134	this.tag = null;
	135	this.tagVersion = -1;
	136	this.version = null;
	137	}
	138	}
	139
	140	/**
	141	* The 'major' version.
	142	* <p>
	143	* This version should only change when API-incompatible changes are made to
	144	* the program.
	145	*
	146	* @return the major version
	147	*/
	148	public int getMajor() {
	149	return major;
	150	}
	151
	152	/**
	153	* The 'minor' version.
	154	* <p>
	155	* This version should only change when new, backwards-compatible
	156	* functionality has been added to the program.
	157	*
	158	* @return the minor version
	159	*/
	160	public int getMinor() {
	161	return minor;
	162	}
	163
	164	/**
	165	* The 'patch' version.
	166	* <p>
	167	* This version should change when backwards-compatible bugfixes have been
	168	* added to the program.
	169	*
	170	* @return the patch version
	171	*/
	172	public int getPatch() {
	173	return patch;
	174	}
	175
	176	/**
	177	* A tag name for this version.
	178	*
	179	* @return the tag
	180	*/
	181	public String getTag() {
	182	return tag;
	183	}
	184
	185	/**
	186	* The version of the tag, or -1 for no version.
	187	*
	188	* @return the tag version
	189	*/
	190	public int getTagVersion() {
	191	return tagVersion;
	192	}
	193
	194	/**
	195	* Check if this {@link Version} is "empty" (i.e., the version was not
	196	* parse-able or not given).
	197	*
	198	* @return TRUE if it is empty
	199	*/
	200	public boolean isEmpty() {
	201	return version == null;
	202	}
	203
	204	/**
	205	* Check if we are more recent than the given {@link Version}.
	206	* <p>
	207	* Note that a tagged version is considered newer than a non-tagged version,
	208	* but two tagged versions with different tags are not comparable.
	209	* <p>
	210	* Also, an empty version is always considered older.
	211	*
	212	* @param o
	213	* the other {@link Version}
	214	* @return TRUE if this {@link Version} is more recent than the given one
	215	*/
	216	public boolean isNewerThan(Version o) {
	217	if (isEmpty()) {
	218	return false;
	219	} else if (o.isEmpty()) {
	220	return true;
	221	}
	222
	223	if (major > o.major) {
	224	return true;
	225	}
	226
	227	if (major == o.major && minor > o.minor) {
	228	return true;
	229	}
	230
	231	if (major == o.major && minor == o.minor && patch > o.patch) {
	232	return true;
	233	}
	234
	235	// a tagged version is considered newer than a non-tagged one
	236	if (major == o.major && minor == o.minor && patch == o.patch
	237	&& tag != null && o.tag == null) {
	238	return true;
	239	}
	240
	241	// 2 <> tagged versions are not comparable
	242	boolean sameTag = (tag == null && o.tag == null)
	243	\|\| (tag != null && tag.equals(o.tag));
	244	if (major == o.major && minor == o.minor && patch == o.patch && sameTag
	245	&& tagVersion > o.tagVersion) {
	246	return true;
	247	}
	248
	249	return false;
	250	}
	251
	252	/**
	253	* Check if we are older than the given {@link Version}.
	254	* <p>
	255	* Note that a tagged version is considered newer than a non-tagged version,
	256	* but two tagged versions with different tags are not comparable.
	257	* <p>
	258	* Also, an empty version is always considered older.
	259	*
	260	* @param o
	261	* the other {@link Version}
	262	* @return TRUE if this {@link Version} is older than the given one
	263	*/
	264	public boolean isOlderThan(Version o) {
	265	if (o.isEmpty()) {
	266	return false;
	267	} else if (isEmpty()) {
	268	return true;
	269	}
	270
	271	// 2 <> tagged versions are not comparable
	272	boolean sameTag = (tag == null && o.tag == null)
	273	\|\| (tag != null && tag.equals(o.tag));
	274	if (major == o.major && minor == o.minor && patch == o.patch
	275	&& !sameTag) {
	276	return false;
	277	}
	278
	279	return !equals(o) && !isNewerThan(o);
	280	}
	281
	282	/**
	283	* Return the version of the running program if it follows the VERSION
	284	* convention (i.e., if it has a file called VERSION containing the version
	285	* as a {@link String} in its binary root, and if this {@link String}
	286	* follows the Major/Minor/Patch convention).
	287	* <p>
	288	* If it does not, return an empty {@link Version} object.
	289	*
	290	* @return the {@link Version} of the program, or an empty {@link Version}
	291	* (does not return NULL)
	292	*/
	293	public static Version getCurrentVersion() {
	294	String version = null;
	295
	296	InputStream in = IOUtils.openResource("VERSION");
	297	if (in != null) {
	298	try {
	299	ByteArrayOutputStream ba = new ByteArrayOutputStream();
	300	IOUtils.write(in, ba);
	301	in.close();
	302
	303	version = ba.toString("UTF-8").trim();
	304	} catch (IOException e) {
	305	}
	306	}
	307
	308	return new Version(version);
	309	}
	310
	311	@Override
	312	public int compareTo(Version o) {
	313	if (equals(o)) {
	314	return 0;
	315	} else if (isNewerThan(o)) {
	316	return 1;
	317	} else {
	318	return -1;
	319	}
	320	}
	321
	322	@Override
	323	public boolean equals(Object obj) {
	324	if (obj instanceof Version) {
	325	Version o = (Version) obj;
	326	if (isEmpty()) {
	327	return o.isEmpty();
	328	}
	329
	330	boolean sameTag = (tag == null && o.tag == null)
	331	\|\| (tag != null && tag.equals(o.tag));
	332	return o.major == major && o.minor == minor && o.patch == patch
	333	&& sameTag && o.tagVersion == tagVersion;
	334	}
	335
	336	return false;
	337	}
	338
	339	@Override
	340	public int hashCode() {
	341	return version == null ? 0 : version.hashCode();
	342	}
	343
	344	/**
	345	* Return a user-readable form of this {@link Version}.
	346	*/
	347	@Override
	348	public String toString() {
	349	return version == null ? "[unknown]" : version;
	350	}
	351
	352	/**
	353	* Generate the clean version {@link String} from the current values.
	354	*
	355	* @return the clean version string
	356	*/
	357	private String generateVersion() {
	358	String tagSuffix = "";
	359	if (tag != null) {
	360	tagSuffix = "-" + tag
	361	+ (tagVersion >= 0 ? Integer.toString(tagVersion) : "");
	362	}
	363
	364	return String.format("%d.%d.%d%s", major, minor, patch, tagSuffix);
	365	}
	366	}