1 files changed, 321 insertions, 0 deletions
diff --git a/src/main/java/org/openslx/virtualization/Version.java b/src/main/java/org/openslx/virtualization/Version.java
new file mode 100644
index 0000000..c823324
--- /dev/null
+++ b/src/main/java/org/openslx/virtualization/Version.java
@@ -0,0 +1,321 @@
+package org.openslx.virtualization;
+
+import java.util.List;
+import java.util.function.Predicate;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.openslx.util.Util;
+
+/**
+ * Represents a version information.
+ * 
+ * The version information is used in the field of virtualization (for virtualizers, disk images,
+ * virtualization configuration files, ...).
+ * 
+ * @author Manuel Bentele
+ * @version 1.0
+ */
+public class Version implements Comparable<Version>
+{
+	/**
+	 * Regular expression to parse a version from a {@link String}.
+	 * <p>
+	 * The regular expression matches a version if its textual version information is well-formed
+	 * according to the following examples:
+	 * 
+	 * <pre>
+	 *   52
+	 *   4.31
+	 *   5.10.13
+	 * </pre>
+	 */
+	private static final Pattern VERSION_NUMBER_REGEX = Pattern.compile( "^(\\d+)(?:\\.(\\d+)(?:\\.(\\d+))?)?$" );
+
+	/**
+	 * Major number of the version.
+	 */
+	private final short major;
+
+	/**
+	 * Minor number of the version.
+	 */
+	private final short minor;
+
+	/**
+	 * Name or description of the version.
+	 */
+	private final String name;
+
+	/**
+	 * Creates a new version.
+	 * 
+	 * The version consists of a major version, whereas the minor version is set to the value
+	 * <code>0</code> and the version name is undefined.
+	 * 
+	 * @param major major version.
+	 */
+	public Version( short major )
+	{
+		this( major, Short.valueOf( "0" ), null );
+	}
+
+	/**
+	 * Creates a new version.
+	 * 
+	 * The version consists of a major version labeled with a version name, whereas the minor version
+	 * is set to the value <code>0</code>.
+	 * 
+	 * @param major major version.
+	 * @param name version name.
+	 */
+	public Version( short major, String name )
+	{
+		this( major, Short.valueOf( "0" ), name );
+	}
+
+	/**
+	 * Creates a new version.
+	 * 
+	 * The version consists of a major and a minor version, whereas the version name is undefined.
+	 * 
+	 * @param major major version.
+	 * @param minor minor version.
+	 */
+	public Version( short major, short minor )
+	{
+		this( major, minor, null );
+	}
+
+	/**
+	 * Creates a new version.
+	 * 
+	 * The version consists of a major and a minor version labeled with a version name.
+	 * 
+	 * @param major major version.
+	 * @param minor minor version.
+	 * @param name version name.
+	 */
+	public Version( short major, short minor, String name )
+	{
+		this.major = major;
+		this.minor = minor;
+		this.name = name;
+	}
+
+	/**
+	 * Returns the major version.
+	 * 
+	 * @return major version.
+	 */
+	public short getMajor()
+	{
+		return this.major;
+	}
+
+	/**
+	 * Returns the minor version.
+	 * 
+	 * @return minor version.
+	 */
+	public short getMinor()
+	{
+		return this.minor;
+	}
+
+	/**
+	 * Returns the full version as {@link Integer}.
+	 * 
+	 * The full version consists of the major and minor version where both are combined in one
+	 * {@link Integer} value. The upper 16-bits of the value represent the major number, whereas
+	 * the lower 16-bits represent the minor number.
+	 * 
+	 * @return full version as {@link Integer}.
+	 */
+	public int getVersion()
+	{
+		final int major = this.major;
+		final int minor = this.minor;
+
+		return ( major << Short.SIZE ) | minor;
+	}
+
+	/**
+	 * Returns the name of the version.
+	 * 
+	 * @return name of the version.
+	 */
+	public String getName()
+	{
+		return this.name;
+	}
+
+	/**
+	 * Checks if version is supported by a version from a list of supported versions.
+	 * 
+	 * @param supportedVersions list of supported versions.
+	 * @return state whether version is supported by a version from the list of versions or not.
+	 */
+	public boolean isSupported( List<Version> supportedVersions )
+	{
+		return supportedVersions.contains( this );
+	}
+
+	/**
+	 * Returns a version from a list of supported versions filtered by its given filter predicate.
+	 * 
+	 * @param byFilter filter predicate.
+	 * @param supportedVersions list of supported versions.
+	 * @return version from a list of supported versions filtered by its given filter predicate.
+	 */
+	private static Version getInstanceByPredicateFromVersions( Predicate<Version> byFilter,
+			List<Version> supportedVersions )
+	{
+		return supportedVersions.stream().filter( byFilter ).findFirst().orElse( null );
+	}
+
+	/**
+	 * Returns a version from a list of supported versions by its given major version.
+	 * 
+	 * @param major version.
+	 * @param supportedVersions list of supported versions.
+	 * @return version from a list of supported versions by its given major version.
+	 */
+	public static Version getInstanceByMajorFromVersions( short major, List<Version> supportedVersions )
+	{
+		final Predicate<Version> byMajor = version -> major == version.getMajor();
+		return Version.getInstanceByPredicateFromVersions( byMajor, supportedVersions );
+	}
+
+	/**
+	 * Returns a version from a list of supported versions by its given major and minor version.
+	 * 
+	 * @param major version.
+	 * @param minor version.
+	 * @param supportedVersions list of supported versions.
+	 * @return version from a list of supported versions by its given major and minor version.
+	 */
+	public static Version getInstanceByMajorMinorFromVersions( short major, short minor,
+			List<Version> supportedVersions )
+	{
+		final Predicate<Version> byMajorMinor = version -> major == version.getMajor() && minor == version.getMinor();
+		return supportedVersions.stream().filter( byMajorMinor ).findFirst().orElse( null );
+	}
+
+	/**
+	 * Checks if this version is smaller than a specified {@code version}.
+	 * 
+	 * @param version for comparison.
+	 * @return state whether this version is smaller than the specified {@code version} or not.
+	 */
+	public boolean isSmallerThan( Version version )
+	{
+		return ( this.compareTo( version ) < 0 ) ? true : false;
+	}
+
+	/**
+	 * Checks if this version is greater than a specified {@code version}.
+	 * 
+	 * @param version for comparison.
+	 * @return state whether this version is greater than the specified {@code version} or not.
+	 */
+	public boolean isGreaterThan( Version version )
+	{
+		return ( this.compareTo( version ) > 0 ) ? true : false;
+	}
+
+	/**
+	 * Creates a new version parsed from a {@link String}.
+	 * 
+	 * The version consists of a major and a minor version parsed from the specified {@link String}.
+	 * 
+	 * @param version textual information containing a version as {@link String}. The textual
+	 *           version should be well-formed according to the defined regular expression
+	 *           {@link #VERSION_NUMBER_REGEX}.
+	 * @return version instance.
+	 */
+	public static Version valueOf( String version )
+	{
+		final Version parsedVersion;
+
+		if ( Util.isEmptyString( version ) ) {
+			parsedVersion = null;
+		} else {
+			final Matcher versionMatcher = VERSION_NUMBER_REGEX.matcher( version );
+
+			if ( versionMatcher.find() ) {
+				final String majorStr = versionMatcher.group( 1 );
+				final String minorStr = versionMatcher.group( 2 );
+
+				final short major = ( majorStr != null ) ? Short.valueOf( majorStr ) : 0;
+				final short minor = ( minorStr != null ) ? Short.valueOf( minorStr ) : 0;
+
+				parsedVersion = new Version( major, minor );
+
+			} else {
+				parsedVersion = null;
+			}
+		}
+
+		return parsedVersion;
+	}
+
+	@Override
+	public String toString()
+	{
+		if ( Util.isEmptyString( this.getName() ) ) {
+			return String.format( "%d.%d", this.getMajor(), this.getMinor() );
+		} else {
+			return String.format( "%d.%d %s", this.getMajor(), this.getMinor(), this.getName() );
+		}
+	}
+
+	@Override
+	public boolean equals( Object obj )
+	{
+		if ( obj == null ) {
+			return false;
+		} else if ( this.getClass() != obj.getClass() ) {
+			return false;
+		} else if ( this.compareTo( Version.class.cast( obj ) ) == 0 ) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	@Override
+	public int compareTo( Version v )
+	{
+		// compare the current version to the specified version
+		if ( this.getMajor() < v.getMajor() ) {
+			// current major version is smaller than the given major version
+			return -1;
+		} else if ( this.getMajor() > v.getMajor() ) {
+			// current major version is larger than the given major version
+			return 1;
+		} else {
+			// current major version is equal to the given major version
+			// so compare the current minor version to the specified minor version
+			if ( this.getMinor() < v.getMinor() ) {
+				// current minor version is smaller than the given minor version
+				// so the entire version is smaller than the given version
+				return -1;
+			} else if ( this.getMinor() > v.getMinor() ) {
+				// current minor version is larger than the given minor version
+				// so the entire version is larger than the given version
+				return 1;
+			} else {
+				// current minor version is equal to the given minor version
+				// so the entire version is equal to the given version
+				return 0;
+			}
+		}
+	}
+
+	@Override
+	public int hashCode()
+	{
+		return ( Short.valueOf( this.getMajor() ).hashCode() ) ^ ( Short.valueOf( this.getMinor() ).hashCode() );
+	}
+}