org.jgroups.Version Maven / Gradle / Ivy
Go to download
This artifact provides a single jar that contains all classes required to use remote EJB and JMS, including
all dependencies. It is intended for use by those not using maven, maven users should just import the EJB and
JMS BOM's instead (shaded JAR's cause lots of problems with maven, as it is very easy to inadvertently end up
with different versions on classes on the class path).
package org.jgroups;
import org.jgroups.annotations.Immutable;
import org.jgroups.util.Util;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.util.Properties;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* We're using the scheme described at http://www.jboss.com/index.html?module=bb&op=viewtopic&t=77231
* for major, minor and micro version numbers. We have 5 bits for major and minor version numbers each and
* 6 bits for the micro version.
* This gives:
* X = 0-31 for major versions
* Y = 0-31 for minor versions
* Z = 0-63 for micro versions
*
* @author Bela Ban
* Holds version information for JGroups.
*/
@Immutable
public class Version {
public static final short major;
public static final short minor;
public static final short micro;
public static final String description;
public static final short version;
public static final String string_version;
private static final int MAJOR_SHIFT = 11;
private static final int MINOR_SHIFT = 6;
private static final int MAJOR_MASK = 0x00f800; // 1111100000000000 bit mask
private static final int MINOR_MASK = 0x0007c0; // 11111000000 bit mask
private static final int MICRO_MASK = 0x00003f; // 111111 bit mask
public static final String VERSION_FILE = "JGROUPS_VERSION.properties";
public static final String VERSION_PROPERTY = "jgroups.version";
public static final String CODENAME = "jgroups.codename";
private static final Pattern VERSION_REGEXP = Pattern.compile("((\\d+)\\.(\\d+)\\.(\\d+).*)");
static {
Properties properties=new Properties();
String ver=null, codename="n/a";
InputStream manifestAsStream=null;
try {
manifestAsStream=Util.getResourceAsStream(VERSION_FILE, Version.class);
if(manifestAsStream == null)
throw new FileNotFoundException(VERSION_FILE);
properties.load(manifestAsStream);
ver=properties.getProperty(VERSION_PROPERTY);
if(ver == null)
throw new Exception("value for " + VERSION_PROPERTY + " not found in " + VERSION_FILE);
codename=properties.getProperty(CODENAME, "n/a");
} catch(Exception e) {
throw new IllegalStateException("Could not initialize version", e);
} finally {
Util.close(manifestAsStream);
}
Matcher versionMatcher = VERSION_REGEXP.matcher(ver);
versionMatcher.find();
description = String.format("%s (%s)", ver, codename);
major = Short.parseShort(versionMatcher.group(2));
minor = Short.parseShort(versionMatcher.group(3));
micro = Short.parseShort(versionMatcher.group(4));
version=encode(major, minor, micro);
string_version=print(version);
}
public static short getMajor() {return major;}
public static short getMinor() {return minor;}
public static short getMicro() {return micro;}
public static short getMajor(short v) {return (short)((v & MAJOR_MASK) >> MAJOR_SHIFT);}
public static short getMinor(short v) {return (short)((v & MINOR_MASK) >> MINOR_SHIFT);}
public static short getMicro(short v) {return (short)(v & MICRO_MASK);}
/**
* Prints the value of the description and cvs fields to System.out.
* @param args
*/
public static void main(String[] args) {
System.out.println("\nVersion: " + description);
}
/**
* Returns the catenation of the description and cvs fields.
* @return String with description
*/
public static String printDescription() {
return "JGroups " + description;
}
/**
* Returns the version field as a String.
* @return String with version
*/
public static String printVersion() {
return string_version;
}
/**
* Compares the specified version number against the current version number.
* @param v short
* @return Result of == operator.
*/
public static boolean isSame(short v) {
return version == v;
}
/** Method copied from http://www.jboss.com/index.html?module=bb&op=viewtopic&t=77231 */
public static short encode(int major, int minor, int micro) {
return (short)((major << MAJOR_SHIFT) + (minor << MINOR_SHIFT) + micro);
}
/** Method copied from http://www.jboss.com/index.html?module=bb&op=viewtopic&t=77231 */
public static String print(short version) {
int major=getMajor(version);
int minor=getMinor(version);
int micro=getMicro(version);
return major + "." + minor + "." + micro;
}
public static short parse(String ver) {
try {
Matcher versionMatcher=VERSION_REGEXP.matcher(ver);
versionMatcher.find();
short maj=Short.parseShort(versionMatcher.group(2));
short min=Short.parseShort(versionMatcher.group(3));
short mic=Short.parseShort(versionMatcher.group(4));
return encode(maj, min, mic);
}
catch(Throwable t) {
throw new IllegalArgumentException(String.format("failed parsing version '%s': %s", ver, t));
}
}
public static short[] decode(short version) {
short major=(short)((version & MAJOR_MASK) >> MAJOR_SHIFT);
short minor=(short)((version & MINOR_MASK) >> MINOR_SHIFT);
short micro=(short)(version & MICRO_MASK);
return new short[]{major, minor, micro};
}
/**
* Checks whether ver is binary compatible with the current version. The rule for binary compatibility is that
* the major and minor versions have to match, whereas micro versions can differ.
* @param ver
* @return
*/
public static boolean isBinaryCompatible(short ver) {
if(version == ver)
return true;
short tmp_major=(short)((ver & MAJOR_MASK) >> MAJOR_SHIFT);
short tmp_minor=(short)((ver & MINOR_MASK) >> MINOR_SHIFT);
return major == tmp_major && minor == tmp_minor;
}
public static boolean isBinaryCompatible(short ver1, short ver2) {
if(ver1 == ver2)
return true;
short[] tmp=decode(ver1);
short tmp_major=tmp[0], tmp_minor=tmp[1];
tmp=decode(ver2);
short tmp_major2=tmp[0], tmp_minor2=tmp[1];
return tmp_major == tmp_major2 && tmp_minor == tmp_minor2;
}
}