|
|
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() );
}
}
|
