Java Code Examples for org.osgi.framework.Version#getMinor()

@Override
public void update(ILaunchConfigurationWorkingCopy launchConfig,
    IJavaProject javaProject, List<String> programArgs, List<String> vmArgs)
    throws CoreException {

  // As of Eclipse Kepler(4.3), the use of -XStartOnFirstThread is a built-in launch config
  // attribute so it is not necessary to make it an explicit argument. This prevents issues when
  // sharing a launch config file across multiple OS platforms.
  Bundle bundle = Platform.getBundle("org.eclipse.platform");
  if (bundle != null) {
    Version bundleVersion = bundle.getVersion();
    if (bundleVersion.getMajor() == 4 && bundleVersion.getMinor() >= 3) {
      updateEclipse43(launchConfig, javaProject, programArgs, vmArgs);
    } else {
      updateNonEclipse43(launchConfig, javaProject, programArgs, vmArgs);
    }
  }
}
 

protected void openErrorDialog(final Display display, final String javaVersion) {
    final Shell shell = new Shell(display);
    try {
        final Version version = Version.parseVersion(ProductVersion.CURRENT_VERSION);
        final String uriWithProductVersion = ONLINE_DOC_REQUIREMENTS + version.getMajor() + "."
                + version.getMinor();
        final URI uri = new URI(uriWithProductVersion);
        final MessageDialogWithLink messageDialog = new MessageDialogWithLink(shell,
                Messages.incompatibleJavaVersionTitle, null, String.format(
                        Messages.incompatibleJavaVersionMessage,
                        org.bonitasoft.studio.common.Messages.bonitaStudioModuleName, javaVersion,
                        "Java 1.8 and Java 11."),
                MessageDialog.ERROR,
                new String[] { IDialogConstants.OK_LABEL },
                0,
                uri);
        messageDialog.open();
    } catch (final URISyntaxException e) {
        BonitaStudioLog.error(e);
    } finally {
        shell.dispose();
    }
}
 

/** Compute the theoretic version just before the given one.
 *
 * @param vers the version.
 * @return the previous version.
 * @since 0.10
 */
@SuppressWarnings("checkstyle:magicnumber")
public static Version getPreviousOsgiVersion(Version vers) {
	int major = vers.getMajor();
	int minor = vers.getMinor();
	int micro = vers.getMicro();
	if (micro <= 0) {
		micro = MAX_NUMBER;
		--minor;
	}
	if (minor <= 0) {
		micro = MAX_NUMBER;
		minor = MAX_NUMBER;
		--major;
	}
	return new Version(major, minor, micro);
}
 

private static int compareVersionsNoQualifier(Version firstVersion, Version secondVersion) {
	if (firstVersion == secondVersion) {
		return 0;
	}

	int result = firstVersion.getMajor() - secondVersion.getMajor();
	if (result != 0) {
		return result;
	}

	result = firstVersion.getMinor() - secondVersion.getMinor();
	if (result != 0) {
		return result;
	}

	return firstVersion.getMicro() - secondVersion.getMicro();
}
 

/**
 * Get the set of version patterns (partial versions) used in the
 * keys in replacement filters for the given version.
 * @param version The version to create patterns for.
 * @return Set of version patterns.
 */
private static String[] getVersionPatterns(Version version)
{
  if (null==version) {
    return new String[]{"-N.N.N"};
  }

  final String qualifier = version.getQualifier();
  final boolean usesQualifier = null != qualifier && qualifier.length() > 0;
  final String[] res = new String[usesQualifier ? 5 : 4];

  res[0] = "-N.N.N";
  res[1] = "-" +version.getMajor() +".N.N";
  res[2] = "-" +version.getMajor() +"." +version.getMinor() +".N";
  res[3] = "-" +version.getMajor() +"." +version.getMinor()
    +"." +version.getMicro();
  if (usesQualifier) {
    res[4] = "-" +version.getMajor() +"." +version.getMinor()
      +"." +version.getMicro() +"." +version.getQualifier();
  }

  return res;
}
 

/**
 * If we have a bundle version suffix add it to the 
 * <code>Bundle-Version</code> attribute.
 */
private void appendVersionSuffix(Manifest mf)
{
  if (versionSuffix != null && !versionSuffix.equals("")) {
    final Manifest.Attribute bundleVerAttr
      = mf.getMainSection().getAttribute("Bundle-Version");
    if (null!=bundleVerAttr) {
      final Version ver = new Version(bundleVerAttr.getValue());
      String q = ver.getQualifier();
      int major = ver.getMajor();
      int minor = ver.getMinor();
      int micro = ver.getMicro();
      if (q.length() == 0) {
        bundleVerAttr.setValue(new Version(major, minor, micro, versionSuffix).toString());
      } else if (!q.endsWith(versionSuffix)) {
        bundleVerAttr.setValue(new Version(major, minor, micro, q + "-" + versionSuffix).toString());
      }
    }
  }
}
 

/**
 * TODO (dennis) consider to make it accessible from other (e.g. o.e.x.common.types.tests) bundles.
 * 
 * Checks if JDT's (Major,Minor) Version is higher or equals the given one.<br>
 * Service and qualifier Part will not be checked.
 * @return <code>true</code> if the avaiable JDT's Version (Major,Minor)  is higher or equals the given one.
 * 
 */
private static boolean isJdtGreaterOrEqual(Version version) {
	Version installed = JavaCore.getPlugin().getBundle().getVersion();
	int minMajor = version.getMajor();
	int minMinor = version.getMinor();
	if (installed.getMajor() < minMajor) {
		return false;
	}
	if (installed.getMajor() == minMajor && installed.getMinor() < minMinor) {
		return false;
	}
	return true;
}
 

/**
 * The same as with JdtBasedTypeFactory.isJdtGreaterOrEqual(new Version(3.6.0))
 * 
 */
protected boolean isCoreResources_3_7_orLater() {
	Version installed = org.eclipse.core.resources.ResourcesPlugin.getPlugin().getBundle().getVersion();
	int minMajor = 3;
	int minMinor = 7;
	if (installed.getMajor() < minMajor) {
		return false;
	}
	if (installed.getMajor() == minMajor && installed.getMinor() < minMinor) {
		return false;
	}
	return true;
}
 

/**
 * The same as with JdtBasedTypeFactory.isJdtGreaterOrEqual(new Version(3.6.0))
 * 
 */
protected boolean isJDT_3_6_orLater() {
	Version installed = JavaCore.getPlugin().getBundle().getVersion();
	int minMajor = 3;
	int minMinor = 6;
	if (installed.getMajor() < minMajor) {
		return false;
	}
	if (installed.getMajor() == minMajor && installed.getMinor() < minMinor) {
		return false;
	}
	return true;
}
 

/** Check if a version is compatible with the expected SARL library.
 *
 * @param version - the version to test.
 * @return {@code true} if a compatible SARL library was found.
 *     Otherwise {@code false}.
 */
public static boolean isCompatibleSARLLibraryVersion(String version) {
	if (version != null) {
		final Version currentVersion = Version.parseVersion(SARLVersion.SPECIFICATION_RELEASE_VERSION_STRING);
		final Version paramVersion = Version.parseVersion(version);
		return currentVersion.getMajor() == paramVersion.getMajor()
				&& currentVersion.getMinor() == paramVersion.getMinor();
	}
	return false;
}
 

/** Assert if the two OSGI version are equal.
 *
 * @param expected the expected value.
 * @param actual the actual value.
 */
public static void assertOsgiVersionEquals(Version expected, Version actual) {
	if (Objects.equal(expected, actual)) {
		return;
	}
	if (expected == null) {
		fail("Version not null");
	}
	if (actual == null) {
		fail("Unexpected null value");
	}
	if (expected.getMajor() == actual.getMajor()
			&& expected.getMinor() == actual.getMinor()
			&& expected.getMicro() == actual.getMicro()) {
		if (!Strings.isNullOrEmpty(expected.getQualifier())) {
			final String expectedQualifier = expected.getQualifier();
			if ("qualifier".equals(expectedQualifier)) {
				if (!Strings.isNullOrEmpty(actual.getQualifier())) {
					return;
				}
			}
			if (Objects.equal(expected, actual.getQualifier())) {
				return;
			}
		} else {
			return;
		}
	}
	throw new AssertionFailedError("Not same versions", expected.toString(), actual.toString());
}
 

private static String getPipModuleName(IInterpreterInfo interpreterInfo) {
    String version = interpreterInfo.getVersion();
    Version version2 = new Version(version);
    if (version2.getMajor() <= 2 && version2.getMinor() <= 6) {
        return "pip.__main__";
    }
    return "pip";
}
 

@Override
public VersionRange makeRange ( final Version version )
{
    final Version endVersion = new Version ( version.getMajor (), version.getMinor () + 1, 0 );
    return new VersionRange ( VersionRange.LEFT_CLOSED, version, endVersion, VersionRange.RIGHT_OPEN );
}
 

protected String getCurrentVersion() {
	Version currentVersion = Activator.getDefault().getBundle().getVersion();
	return "" + currentVersion.getMajor() + "." + currentVersion.getMinor() + "." + currentVersion.getMicro();
}
 

/**
 * @return the major and minor parts of the given version
 */
private static Version toMajorMinorVersion(final Version version) {
	return new Version(version.getMajor(), version.getMinor(), 0);
}
 

private static Version extractMetamodelVersion(Version implementationVersion) {
	return new Version(implementationVersion.getMajor(), implementationVersion.getMinor(), 0);
}
 

protected static String getVersionText() {
	Version version = GoCorePlugin.getDefault().getBundle().getVersion();
	
	return version.getMajor() + "." + version.getMinor() + "." + version.getMicro();
}
 

public @Override SpecificationVersion getSpecificationVersion() {
    Version v = b.getVersion();
    return new SpecificationVersion(v.getMajor() % 100 + "." + v.getMinor() + "." + v.getMicro());
}