You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
98 lines
3.5 KiB
98 lines
3.5 KiB
/*
|
|
* Copyright (c) 2018 Jämes Ménétrey <james@menetrey.me>
|
|
*
|
|
* This file is part of the Keystone Java bindings which is released under MIT.
|
|
* See file LICENSE in the Java bindings folder for full license details.
|
|
*/
|
|
|
|
package keystone.utilities;
|
|
|
|
/**
|
|
* Represents the version number of Keystone. This class cannot be inherited.
|
|
*/
|
|
public final class Version implements Comparable<Version> {
|
|
private final int major;
|
|
private final int minor;
|
|
|
|
/**
|
|
* Initializes a new instance of the {@link Version} class using the specified major and minor values.
|
|
*
|
|
* @param major The major version number.
|
|
* @param minor The minor version number.
|
|
*/
|
|
public Version(int major, int minor) {
|
|
this.major = major;
|
|
this.minor = minor;
|
|
}
|
|
|
|
/**
|
|
* Gets the value of the major component of the version number for the current {@link Version} object.
|
|
*
|
|
* @return The major version number.
|
|
*/
|
|
public int major() {
|
|
return major;
|
|
}
|
|
|
|
/**
|
|
* Gets the value of the minor component of the version number for the current {@link Version} object.
|
|
*
|
|
* @return The minor version number.
|
|
*/
|
|
public int minor() {
|
|
return minor;
|
|
}
|
|
|
|
/**
|
|
* Compares this object with the specified object for order. Returns a
|
|
* negative integer, zero, or a positive integer as this object is less
|
|
* than, equal to, or greater than the specified object.
|
|
*
|
|
* <p>The implementor must ensure <tt>sgn(x.compareTo(y)) ==
|
|
* -sgn(y.compareTo(x))</tt> for all <tt>x</tt> and <tt>y</tt>. (This
|
|
* implies that <tt>x.compareTo(y)</tt> must throw an exception iff
|
|
* <tt>y.compareTo(x)</tt> throws an exception.)
|
|
*
|
|
* <p>The implementor must also ensure that the relation is transitive:
|
|
* <tt>(x.compareTo(y)>0 && y.compareTo(z)>0)</tt> implies
|
|
* <tt>x.compareTo(z)>0</tt>.
|
|
*
|
|
* <p>Finally, the implementor must ensure that <tt>x.compareTo(y)==0</tt>
|
|
* implies that <tt>sgn(x.compareTo(z)) == sgn(y.compareTo(z))</tt>, for
|
|
* all <tt>z</tt>.
|
|
*
|
|
* <p>It is strongly recommended, but <i>not</i> strictly required that
|
|
* <tt>(x.compareTo(y)==0) == (x.equals(y))</tt>. Generally speaking, any
|
|
* class that implements the <tt>Comparable</tt> interface and violates
|
|
* this condition should clearly indicate this fact. The recommended
|
|
* language is "Note: this class has a natural ordering that is
|
|
* inconsistent with equals."
|
|
*
|
|
* <p>In the foregoing description, the notation
|
|
* <tt>sgn(</tt><i>expression</i><tt>)</tt> designates the mathematical
|
|
* <i>signum</i> function, which is defined to return one of <tt>-1</tt>,
|
|
* <tt>0</tt>, or <tt>1</tt> according to whether the value of
|
|
* <i>expression</i> is negative, zero or positive.
|
|
*
|
|
* @param o the object to be compared.
|
|
* @return a negative integer, zero, or a positive integer as this object
|
|
* is less than, equal to, or greater than the specified object.
|
|
* @throws NullPointerException if the specified object is null
|
|
* @throws ClassCastException if the specified object's type prevents it
|
|
* from being compared to this object.
|
|
*/
|
|
@Override
|
|
public int compareTo(Version o) {
|
|
if (o == null) return 1;
|
|
|
|
if (major != o.major) {
|
|
if (major > o.major) {
|
|
return 1;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
return Integer.compare(minor, o.minor);
|
|
}
|
|
}
|