Package org.eclipse.jdt.launching

Class JavaRuntime

java.lang.Object
org.eclipse.jdt.launching.JavaRuntime
public final class JavaRuntime extends Object
The central access point for launching support. This class manages the registered VM types contributed through the "org.eclipse.jdt.launching.vmType" extension point. As well, this class provides VM install change notification, and computes class paths and source lookup paths for launch configurations.

This class provides static methods only.

Restriction:
This class is not intended to be instantiated by clients.

  • Field Details

    • JRELIB_VARIABLE

      public static final String JRELIB_VARIABLE
      Classpath variable name used for the default JRE's library (value "JRE_LIB").
      See Also:

    • JRESRC_VARIABLE

      public static final String JRESRC_VARIABLE
      Classpath variable name used for the default JRE's library source (value "JRE_SRC").
      See Also:

    • JRESRCROOT_VARIABLE

      public static final String JRESRCROOT_VARIABLE
      Classpath variable name used for the default JRE's library source root (value "JRE_SRCROOT").
      See Also:

    • EXTENSION_POINT_RUNTIME_CLASSPATH_ENTRY_RESOLVERS

      public static final String EXTENSION_POINT_RUNTIME_CLASSPATH_ENTRY_RESOLVERS
      Simple identifier constant (value "runtimeClasspathEntryResolvers") for the runtime classpath entry resolvers extension point.
      Since:
      2.0
      See Also:

    • EXTENSION_POINT_RUNTIME_CLASSPATH_PROVIDERS

      public static final String EXTENSION_POINT_RUNTIME_CLASSPATH_PROVIDERS
      Simple identifier constant (value "classpathProviders") for the runtime classpath providers extension point.
      Since:
      2.0
      See Also:

    • EXTENSION_POINT_EXECUTION_ENVIRONMENTS

      public static final String EXTENSION_POINT_EXECUTION_ENVIRONMENTS
      Simple identifier constant (value "executionEnvironments") for the execution environments extension point.
      Since:
      3.2
      See Also:

    • EXTENSION_POINT_VM_INSTALLS

      public static final String EXTENSION_POINT_VM_INSTALLS
      Simple identifier constant (value "vmInstalls") for the VM installs extension point.
      Since:
      3.2
      See Also:

    • EXTENSION_POINT_LIBRARY_LOCATION_RESOLVERS

      public static final String EXTENSION_POINT_LIBRARY_LOCATION_RESOLVERS
      Simple identifier constant (value "libraryLocationResolvers") for the Library Resolvers extension point
      Since:
      3.7
      See Also:

    • JRE_CONTAINER

      public static final String JRE_CONTAINER
      Classpath container used for a project's JRE (value "org.eclipse.jdt.launching.JRE_CONTAINER"). A container is resolved in the context of a specific Java project, to one or more system libraries contained in a JRE. The container can have zero or two path segments following the container name. When no segments follow the container name, the workspace default JRE is used to build a project. Otherwise the segments identify a specific JRE used to build a project:
      1. VM Install Type Identifier - identifies the type of JRE used to build the project. For example, the standard VM.
      2. VM Install Name - a user defined name that identifies that a specific VM of the above kind. For example, IBM 1.3.1. This information is shared in a projects classpath file, so teams must agree on JRE naming conventions.

      Since 3.2, the path may also identify an execution environment as follows:

      1. Execution environment extension point name (value executionEnvironments)
      2. Identifier of a contributed execution environment
      Since:
      2.0

    • JRE_CONTAINER_MARKER

      public static final String JRE_CONTAINER_MARKER
      Marker type identifier for JRE container problems.
      Since:
      3.6

    • JRE_COMPILER_COMPLIANCE_MARKER

      public static final String JRE_COMPILER_COMPLIANCE_MARKER
      Marker type identifier for JRE compiler compliance problems.
      Since:
      3.11

    • ERR_UNABLE_TO_RESOLVE_JRE

      public static final int ERR_UNABLE_TO_RESOLVE_JRE
      A status code indicating that a JRE could not be resolved for a project. When a JRE cannot be resolved for a project by this plug-in's container initializer, an exception is thrown with this status code. A status handler may be registered for this status code. The source object provided to the status handler is the Java project for which the path could not be resolved. The status handler must return an IVMInstall or null. The container resolver will re-set the project's classpath if required.
      Since:
      2.0
      See Also:

    • PREF_CONNECT_TIMEOUT

      public static final String PREF_CONNECT_TIMEOUT
      Preference key for launch/connect timeout. VM Runners should honor this timeout value when attempting to launch and connect to a debuggable VM. The value is an int, indicating a number of milliseconds.
      Since:
      2.0

    • PREF_VM_XML

      public static final String PREF_VM_XML
      Preference key for the String of XML that defines all installed VMs.
      Since:
      2.1

    • PREF_STRICTLY_COMPATIBLE_JRE_NOT_AVAILABLE

      public static final String PREF_STRICTLY_COMPATIBLE_JRE_NOT_AVAILABLE
      Preference key for the problem severity when an execution environment is bound to a project's build path for which there is no strictly compatible JRE available in the workspace. Value is one of JavaCore.ERROR, JavaCore.WARNING, JavaCore.INFO, or JavaCore.IGNORE
      Since:
      3.5

    • PREF_COMPILER_COMPLIANCE_DOES_NOT_MATCH_JRE

      public static final String PREF_COMPILER_COMPLIANCE_DOES_NOT_MATCH_JRE
      Preference key for the problem severity when an compiler compliance that is set does not match the used JRE. Value is one of JavaCore.ERROR, JavaCore.WARNING, JavaCore.INFO, or JavaCore.IGNORE

      This preference will not be applicable if the JRE used is 9 or above and JavaCore.COMPILER_RELEASE option is enabled.

      Since:
      3.10

    • ID_PLUGIN

      public static final String ID_PLUGIN
      Unique identifier constant (value "org.eclipse.jdt.launching") for the Java launching plug-in. This preference will not be applicable if the JRE used is 9 or above and JavaCore.COMPILER_RELEASE option is enabled.
      Since:
      3.5
      See Also:

    • DEF_CONNECT_TIMEOUT

      public static final int DEF_CONNECT_TIMEOUT
      Default launch/connect timeout (milliseconds).
      Since:
      2.0
      See Also:

    • ATTR_CMDLINE

      @Deprecated public static final String ATTR_CMDLINE
      Deprecated.
      - use IProcess.ATTR_CMDLINE
      Attribute key for a process property. The class org.eclipse.debug.core.model.IProcess allows attaching String properties to processes. The value of this attribute is the command line a process was launched with. Implementers of IVMRunner should use this attribute key to attach the command lines to the processes they create.

    • PREF_ONLY_INCLUDE_EXPORTED_CLASSPATH_ENTRIES

      public static final String PREF_ONLY_INCLUDE_EXPORTED_CLASSPATH_ENTRIES
      Boolean preference controlling whether only exported entries should even be included when the runtime classpath is computed
      Since:
      3.7
      See Also:

    • CLASSPATH_ATTR_LIBRARY_PATH_ENTRY

      public static final String CLASSPATH_ATTR_LIBRARY_PATH_ENTRY
      Attribute key for a classpath attribute referencing a list of shared libraries that should appear on the -Djava.library.path system property.

      The factory methods newLibraryPathsAttribute(String[]) and getLibraryPaths(IClasspathAttribute) should be used to encode and decode the attribute value.

      Each string is used to create an IPath using the constructor Path(String), and may contain IStringVariable's. Variable substitution is performed on the string prior to constructing a path from the string. If the resulting IPath is a relative path, it is interpreted as relative to the workspace location. If the path is absolute, it is interpreted as an absolute path in the local file system.

      Since:
      3.1
      See Also:

  • Method Details

    • getVMInstall

      public static IVMInstall getVMInstall(IJavaProject project) throws org.eclipse.core.runtime.CoreException
      Returns the VM assigned to build the given Java project. The project must exist. The VM assigned to a project is determined from its build path.
      Parameters:
      project - the project to retrieve the VM from
      Returns:
      the VM instance that is assigned to build the given Java project Returns null if no VM is referenced on the project's build path.
      Throws:
      org.eclipse.core.runtime.CoreException - if unable to determine the project's VM install

    • getVMInstallType

      public static IVMInstallType getVMInstallType(String id)
      Returns the VM install type with the given unique id.
      Parameters:
      id - the VM install type unique id
      Returns:
      The VM install type for the given id, or null if no VM install type with the given id is registered.

    • setDefaultVMInstall

      public static void setDefaultVMInstall(IVMInstall vm, org.eclipse.core.runtime.IProgressMonitor monitor) throws org.eclipse.core.runtime.CoreException
      Sets a VM as the system-wide default VM, and notifies registered VM install change listeners of the change.
      Parameters:
      vm - The VM to make the default. May be null to clear the default.
      monitor - progress monitor or null
      Throws:
      org.eclipse.core.runtime.CoreException - if trying to set the default VM install encounters problems

    • setDefaultVMInstall

      public static void setDefaultVMInstall(IVMInstall vm, org.eclipse.core.runtime.IProgressMonitor monitor, boolean savePreference) throws org.eclipse.core.runtime.CoreException
      Sets a VM as the system-wide default VM, and notifies registered VM install change listeners of the change.
      Parameters:
      vm - The VM to make the default. May be null to clear the default.
      monitor - progress monitor or null
      savePreference - If true, update workbench preferences to reflect the new default VM.
      Throws:
      org.eclipse.core.runtime.CoreException - if trying to set the default VM install encounters problems
      Since:
      2.1

    • setDefaultVMConnector

      public static void setDefaultVMConnector(IVMConnector connector, org.eclipse.core.runtime.IProgressMonitor monitor) throws org.eclipse.core.runtime.CoreException
      Sets a VM connector as the system-wide default VM. This setting is persisted when saveVMConfiguration is called.
      Parameters:
      connector - The connector to make the default. May be null to clear the default.
      monitor - The progress monitor to use
      Throws:
      org.eclipse.core.runtime.CoreException - Thrown if saving the new default setting fails
      Since:
      2.0

    • getDefaultVMInstall

      public static IVMInstall getDefaultVMInstall()
      Return the default VM set with setDefaultVM().
      Returns:
      Returns the default VM. May return null when no default VM was set or when the default VM has been disposed.

    • getDefaultVMConnector

      public static IVMConnector getDefaultVMConnector()
      Return the default VM connector.
      Returns:
      Returns the default VM connector.
      Since:
      2.0

    • getVMInstallTypes

      public static IVMInstallType[] getVMInstallTypes()
      Returns the list of registered VM types. VM types are registered via "org.eclipse.jdt.launching.vmTypes" extension point. Returns an empty list if there are no registered VM types.
      Returns:
      the list of registered VM types

    • getCompositeIdFromVM

      public static String getCompositeIdFromVM(IVMInstall vm)
      Returns a String that uniquely identifies the specified VM across all VM types.
      Parameters:
      vm - the instance of IVMInstallType to be identified
      Returns:
      the unique identifier for the specified VM
      Since:
      2.1

    • getVMFromCompositeId

      public static IVMInstall getVMFromCompositeId(String idString)
      Return the VM corresponding to the specified composite Id. The id uniquely identifies a VM across all VM types.
      Parameters:
      idString - the composite id that specifies an instance of IVMInstall
      Returns:
      the VM corresponding to the specified composite Id.
      Since:
      2.1

    • newStringVariableClasspathEntry

      public static IRuntimeClasspathEntry newStringVariableClasspathEntry(String expression)
      Returns a new runtime classpath entry for the given expression that may contain string substitution variable references. The resulting expression refers to an archive (jar or directory) containing class files.
      Parameters:
      expression - an expression that resolves to the location of an archive
      Returns:
      runtime classpath entry
      Since:
      3.0

    • newDefaultProjectClasspathEntry

      public static IRuntimeClasspathEntry newDefaultProjectClasspathEntry(IJavaProject project)
      Returns a new runtime classpath entry containing the default classpath for the specified Java project.
      Parameters:
      project - Java project
      Returns:
      runtime classpath entry
      Since:
      3.0

    • newProjectRuntimeClasspathEntry

      public static IRuntimeClasspathEntry newProjectRuntimeClasspathEntry(IJavaProject project)
      Returns a new runtime classpath entry for the given project.
      Parameters:
      project - Java project
      Returns:
      runtime classpath entry
      Since:
      2.0

    • newProjectRuntimeClasspathEntry

      public static IRuntimeClasspathEntry newProjectRuntimeClasspathEntry(IJavaProject project, int classpathProperty)
      Returns a new runtime classpath entry for the given project.
      Parameters:
      project - Java project
      classpathProperty - the type of entry - one of USER_CLASSES, BOOTSTRAP_CLASSES,STANDARD_CLASSES, MODULE_PATH or CLASS_PATH
      Returns:
      runtime classpath entry
      Since:
      3.10

    • newArchiveRuntimeClasspathEntry

      public static IRuntimeClasspathEntry newArchiveRuntimeClasspathEntry(org.eclipse.core.resources.IResource resource)
      Returns a new runtime classpath entry for the given archive.
      Parameters:
      resource - archive resource
      Returns:
      runtime classpath entry
      Since:
      2.0

    • newArchiveRuntimeClasspathEntry

      public static IRuntimeClasspathEntry newArchiveRuntimeClasspathEntry(org.eclipse.core.runtime.IPath path, int classpathProperty)
      Returns a new runtime classpath entry for the given archive(possibly external).
      Parameters:
      path - absolute path to an archive
      classpathProperty - the type of entry - one of USER_CLASSES, BOOTSTRAP_CLASSES,STANDARD_CLASSES, MODULE_PATH or CLASS_PATH
      Returns:
      runtime classpath entry
      Since:
      3.10

    • newArchiveRuntimeClasspathEntry

      public static IRuntimeClasspathEntry newArchiveRuntimeClasspathEntry(org.eclipse.core.runtime.IPath path, int classpathProperty, IJavaProject javaProject)
      Returns a new runtime classpath entry for the given archive(possibly external).
      Parameters:
      path - absolute path to an archive
      classpathProperty - the type of entry - one of USER_CLASSES, BOOTSTRAP_CLASSES,STANDARD_CLASSES, MODULE_PATH, CLASS_PATH or PATCH_MODULE
      javaProject - the javaProject to be returned by IRuntimeClasspathEntry.getJavaProject(), required for PATCH_MODULE
      Returns:
      runtime classpath entry
      Since:
      3.10

    • newArchiveRuntimeClasspathEntry

      public static IRuntimeClasspathEntry newArchiveRuntimeClasspathEntry(org.eclipse.core.runtime.IPath path)
      Returns a new runtime classpath entry for the given archive (possibly external).
      Parameters:
      path - absolute path to an archive
      Returns:
      runtime classpath entry
      Since:
      2.0

    • newArchiveRuntimeClasspathEntry

      public static IRuntimeClasspathEntry newArchiveRuntimeClasspathEntry(org.eclipse.core.runtime.IPath path, org.eclipse.core.runtime.IPath sourceAttachmentPath, org.eclipse.core.runtime.IPath sourceAttachmentRootPath, IAccessRule[] accessRules, IClasspathAttribute[] extraAttributes, boolean isExported)
      Returns a new runtime classpath entry for the given archive (possibly external).
      Parameters:
      path - absolute path to an archive
      sourceAttachmentPath - the absolute path of the corresponding source archive or folder, or null if none. Note, since 3.0, an empty path is allowed to denote no source attachment. and will be automatically converted to null. Since 3.4, this path can also denote a path external to the workspace.
      sourceAttachmentRootPath - the location of the root of the source files within the source archive or folder or null if this location should be automatically detected.
      accessRules - the possibly empty list of access rules for this entry
      extraAttributes - the possibly empty list of extra attributes to persist with this entry
      isExported - indicates whether this entry is contributed to dependent projects in addition to the output location
      Returns:
      runtime classpath entry
      Since:
      3.10

    • newVariableRuntimeClasspathEntry

      public static IRuntimeClasspathEntry newVariableRuntimeClasspathEntry(org.eclipse.core.runtime.IPath path)
      Returns a new runtime classpath entry for the classpath variable with the given path.
      Parameters:
      path - variable path; first segment is the name of the variable; trailing segments are appended to the resolved variable value
      Returns:
      runtime classpath entry
      Since:
      2.0

    • newRuntimeContainerClasspathEntry

      public static IRuntimeClasspathEntry newRuntimeContainerClasspathEntry(org.eclipse.core.runtime.IPath path, int classpathProperty) throws org.eclipse.core.runtime.CoreException
      Returns a runtime classpath entry for the given container path with the given classpath property.
      Parameters:
      path - container path
      classpathProperty - the type of entry - one of USER_CLASSES, BOOTSTRAP_CLASSES,STANDARD_CLASSES, MODULE_PATH or CLASS_PATH
      Returns:
      runtime classpath entry
      Throws:
      org.eclipse.core.runtime.CoreException - if unable to construct a runtime classpath entry
      Since:
      2.0

    • newRuntimeContainerClasspathEntry

      public static IRuntimeClasspathEntry newRuntimeContainerClasspathEntry(org.eclipse.core.runtime.IPath path, int classpathProperty, IJavaProject project) throws org.eclipse.core.runtime.CoreException
      Returns a runtime classpath entry for the given container path with the given classpath property to be resolved in the context of the given Java project.
      Parameters:
      path - container path
      classpathProperty - the type of entry - one of USER_CLASSES, BOOTSTRAP_CLASSES, or STANDARD_CLASSES
      project - Java project context used for resolution, or null if to be resolved in the context of the launch configuration this entry is referenced in
      Returns:
      runtime classpath entry
      Throws:
      org.eclipse.core.runtime.CoreException - if unable to construct a runtime classpath entry
      Since:
      3.0

    • newRuntimeClasspathEntry

      public static IRuntimeClasspathEntry newRuntimeClasspathEntry(String memento) throws org.eclipse.core.runtime.CoreException
      Returns a runtime classpath entry constructed from the given memento.
      Parameters:
      memento - a memento for a runtime classpath entry
      Returns:
      runtime classpath entry
      Throws:
      org.eclipse.core.runtime.CoreException - if unable to construct a runtime classpath entry
      Since:
      2.0

    • computeUnresolvedRuntimeClasspath

      public static IRuntimeClasspathEntry[] computeUnresolvedRuntimeClasspath(IJavaProject project) throws org.eclipse.core.runtime.CoreException
      Computes and returns the default unresolved runtime classpath for the given project.
      Parameters:
      project - the IJavaProject to compute the unresolved runtime classpath for
      Returns:
      runtime classpath entries
      Throws:
      org.eclipse.core.runtime.CoreException - if unable to compute the runtime classpath
      Since:
      2.0
      See Also:

    • computeUnresolvedRuntimeClasspath

      public static IRuntimeClasspathEntry[] computeUnresolvedRuntimeClasspath(IJavaProject project, boolean excludeTestCode) throws org.eclipse.core.runtime.CoreException
      Computes and returns the default unresolved runtime classpath for the given project.
      Parameters:
      project - the IJavaProject to compute the unresolved runtime classpath for
      excludeTestCode - if true, output folders corresponding to test sources and test dependencies are excluded
      Returns:
      runtime classpath entries
      Throws:
      org.eclipse.core.runtime.CoreException - if unable to compute the runtime classpath
      Since:
      3.10
      See Also:

    • computeUnresolvedRuntimeDependencies

      public static IRuntimeClasspathEntry[] computeUnresolvedRuntimeDependencies(IJavaProject project) throws org.eclipse.core.runtime.CoreException
      Computes and returns the default unresolved runtime classpath and modulepath for the given project.
      Parameters:
      project - the IJavaProject to compute the unresolved runtime classpath and modulepath for
      Returns:
      runtime classpath and modulepath entries
      Throws:
      org.eclipse.core.runtime.CoreException - if unable to compute the runtime classpath and/or modulepath
      Since:
      3.10
      See Also:

    • computeUnresolvedRuntimeDependencies

      public static IRuntimeClasspathEntry[] computeUnresolvedRuntimeDependencies(IJavaProject project, boolean excludeTestCode) throws org.eclipse.core.runtime.CoreException
      Computes and returns the default unresolved runtime classpath and modulepath for the given project.
      Parameters:
      project - the IJavaProject to compute the unresolved runtime classpath and modulepath for
      excludeTestCode - if true, output folders corresponding to test sources and test dependencies are excluded
      Returns:
      runtime classpath and modulepath entries
      Throws:
      org.eclipse.core.runtime.CoreException - if unable to compute the runtime classpath and/or modulepath
      Since:
      3.10
      See Also:

    • isModule

      public static boolean isModule(IClasspathEntry entry, IJavaProject proj)
      Checks if classpath entry is modular and project is modular .
      Parameters:
      entry - the classpath entry
      Returns:
      boolean true if entry is module else false
      Since:
      3.10

    • isModularConfiguration

      public static boolean isModularConfiguration(org.eclipse.debug.core.ILaunchConfiguration configuration)
      Checks if configuration JRE is greater than 8.
      Parameters:
      configuration - the launch configuration
      Returns:
      boolean true if jre used in configuration is greater than 8 else false
      Since:
      3.10

    • isModularJava

      public static boolean isModularJava(IVMInstall vm)
      Checks if vm install is modular( version greater than 8).
      Parameters:
      vm - the vm install
      Returns:
      boolean true if vm install is modular else false
      Since:
      3.10

    • compareJavaVersions

      public static int compareJavaVersions(IVMInstall vm, String ver)
      Compares the version of vm and a version of the Java platform.
      Parameters:
      vm - IVMInstall to be compared
      ver - version to be compared
      Returns:
      the value 0 if both versions are the same; a value less than 0 if vm is smaller than ver; and a value greater than 0 if vm is higher than ver; a value -1 in case of any exceptions;
      Since:
      3.10

    • isModularProject

      public static boolean isModularProject(IJavaProject proj)
      Checks if project entry is modular
      Parameters:
      proj - the project
      Returns:
      boolean true if project is modular else false
      Since:
      3.10

    • computeUnresolvedSourceLookupPath

      public static IRuntimeClasspathEntry[] computeUnresolvedSourceLookupPath(org.eclipse.debug.core.ILaunchConfiguration configuration) throws org.eclipse.core.runtime.CoreException
      Computes and returns the unresolved source lookup path for the given launch configuration.
      Parameters:
      configuration - launch configuration
      Returns:
      runtime classpath entries
      Throws:
      org.eclipse.core.runtime.CoreException - if unable to compute the source lookup path
      Since:
      2.0

    • resolveSourceLookupPath

      public static IRuntimeClasspathEntry[] resolveSourceLookupPath(IRuntimeClasspathEntry[] entries, org.eclipse.debug.core.ILaunchConfiguration configuration) throws org.eclipse.core.runtime.CoreException
      Resolves the given source lookup path, returning the resolved source lookup path in the context of the given launch configuration.
      Parameters:
      entries - unresolved entries
      configuration - launch configuration
      Returns:
      resolved entries
      Throws:
      org.eclipse.core.runtime.CoreException - if unable to resolve the source lookup path
      Since:
      2.0

    • getClasspathProvider

      public static IRuntimeClasspathProvider getClasspathProvider(org.eclipse.debug.core.ILaunchConfiguration configuration) throws org.eclipse.core.runtime.CoreException
      Returns the classpath provider for the given launch configuration.
      Parameters:
      configuration - launch configuration
      Returns:
      classpath provider
      Throws:
      org.eclipse.core.runtime.CoreException - if unable to resolve the path provider
      Since:
      2.0

    • getSourceLookupPathProvider

      public static IRuntimeClasspathProvider getSourceLookupPathProvider(org.eclipse.debug.core.ILaunchConfiguration configuration) throws org.eclipse.core.runtime.CoreException
      Returns the source lookup path provider for the given launch configuration.
      Parameters:
      configuration - launch configuration
      Returns:
      source lookup path provider
      Throws:
      org.eclipse.core.runtime.CoreException - if unable to resolve the path provider
      Since:
      2.0

    • resolveRuntimeClasspathEntry

      public static IRuntimeClasspathEntry[] resolveRuntimeClasspathEntry(IRuntimeClasspathEntry entry, org.eclipse.debug.core.ILaunchConfiguration configuration) throws org.eclipse.core.runtime.CoreException
      Returns resolved entries for the given entry in the context of the given launch configuration. If the entry is of kind VARIABLE or CONTAINER, variable and container resolvers are consulted. If the entry is of kind PROJECT, and the associated Java project specifies non-default output locations, the corresponding output locations are returned. Otherwise, the given entry is returned.

      If the given entry is a variable entry, and a resolver is not registered, the entry itself is returned. If the given entry is a container, and a resolver is not registered, resolved runtime classpath entries are calculated from the associated container classpath entries, in the context of the project associated with the given launch configuration.

      Parameters:
      entry - runtime classpath entry
      configuration - launch configuration
      Returns:
      resolved runtime classpath entry
      Throws:
      org.eclipse.core.runtime.CoreException - if unable to resolve
      Since:
      2.0
      See Also:

    • resolveRuntimeClasspathEntry

      public static IRuntimeClasspathEntry[] resolveRuntimeClasspathEntry(IRuntimeClasspathEntry entry, IJavaProject project) throws org.eclipse.core.runtime.CoreException
      Returns resolved entries for the given entry in the context of the given Java project. If the entry is of kind VARIABLE or CONTAINER, variable and container resolvers are consulted. If the entry is of kind PROJECT, and the associated Java project specifies non-default output locations, the corresponding output locations are returned. Otherwise, the given entry is returned.

      If the given entry is a variable entry, and a resolver is not registered, the entry itself is returned. If the given entry is a container, and a resolver is not registered, resolved runtime classpath entries are calculated from the associated container classpath entries, in the context of the given project.

      Parameters:
      entry - runtime classpath entry
      project - Java project context
      Returns:
      resolved runtime classpath entry
      Throws:
      org.eclipse.core.runtime.CoreException - if unable to resolve
      Since:
      2.0
      See Also:

    • resolveRuntimeClasspathEntry

      public static IRuntimeClasspathEntry[] resolveRuntimeClasspathEntry(IRuntimeClasspathEntry entry, IJavaProject project, boolean excludeTestCode) throws org.eclipse.core.runtime.CoreException
      Returns resolved entries for the given entry in the context of the given Java project. If the entry is of kind VARIABLE or CONTAINER, variable and container resolvers are consulted. If the entry is of kind PROJECT, and the associated Java project specifies non-default output locations, the corresponding output locations are returned. Otherwise, the given entry is returned.

      If the given entry is a variable entry, and a resolver is not registered, the entry itself is returned. If the given entry is a container, and a resolver is not registered, resolved runtime classpath entries are calculated from the associated container classpath entries, in the context of the given project.

      Parameters:
      entry - runtime classpath entry
      project - Java project context
      excludeTestCode - if true, output folders corresponding to test sources and test dependencies are excluded
      Returns:
      resolved runtime classpath entry
      Throws:
      org.eclipse.core.runtime.CoreException - if unable to resolve
      Since:
      3.10
      See Also:

    • computeUnresolvedRuntimeClasspath

      public static IRuntimeClasspathEntry[] computeUnresolvedRuntimeClasspath(org.eclipse.debug.core.ILaunchConfiguration configuration) throws org.eclipse.core.runtime.CoreException
      Computes and returns the unresolved class path for the given launch configuration. Variable and container entries are unresolved.
      Parameters:
      configuration - launch configuration
      Returns:
      unresolved runtime classpath entries
      Throws:
      org.eclipse.core.runtime.CoreException - if unable to compute the classpath
      Since:
      2.0

    • resolveRuntimeClasspath

      public static IRuntimeClasspathEntry[] resolveRuntimeClasspath(IRuntimeClasspathEntry[] entries, org.eclipse.debug.core.ILaunchConfiguration configuration) throws org.eclipse.core.runtime.CoreException
      Resolves the given classpath, returning the resolved classpath in the context of the given launch configuration.
      Parameters:
      entries - unresolved classpath
      configuration - launch configuration
      Returns:
      resolved runtime classpath entries
      Throws:
      org.eclipse.core.runtime.CoreException - if unable to compute the classpath
      Since:
      2.0

    • getJavaProject

      public static IJavaProject getJavaProject(org.eclipse.debug.core.ILaunchConfiguration configuration) throws org.eclipse.core.runtime.CoreException
      Return the IJavaProject referenced in the specified configuration or null if none. This method looks for the existence of the IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME attribute in the given configuration.
      Parameters:
      configuration - the ILaunchConfiguration to try and compute the IJavaProject from
      Returns:
      the referenced IJavaProject or null
      Throws:
      org.eclipse.core.runtime.CoreException - if the referenced Java project does not exist
      Since:
      2.0

    • computeVMInstall

      public static IVMInstall computeVMInstall(org.eclipse.debug.core.ILaunchConfiguration configuration) throws org.eclipse.core.runtime.CoreException
      Returns the VM install for the given launch configuration. The VM install is determined in the following prioritized way:
      1. The VM install is explicitly specified on the launch configuration via the ATTR_JRE_CONTAINER_PATH attribute (since 3.2).
      2. The VM install is explicitly specified on the launch configuration via the ATTR_VM_INSTALL_TYPE and ATTR_VM_INSTALL_ID attributes.
      3. If no explicit VM install is specified, the VM install associated with the launch configuration's project is returned.
      4. If no project is specified, or the project does not specify a custom VM install, the workspace default VM install is returned.
      Parameters:
      configuration - launch configuration
      Returns:
      VM install
      Throws:
      org.eclipse.core.runtime.CoreException - if unable to compute a VM install
      Since:
      2.0

    • computeDefaultRuntimeClassPath

      public static String[] computeDefaultRuntimeClassPath(IJavaProject jproject) throws org.eclipse.core.runtime.CoreException
      Computes the default application classpath entries for the given project.
      Parameters:
      jproject - The project to compute the classpath for
      Returns:
      The computed classpath. May be empty, but not null.
      Throws:
      org.eclipse.core.runtime.CoreException - if unable to compute the default classpath

    • saveVMConfiguration

      public static void saveVMConfiguration() throws org.eclipse.core.runtime.CoreException
      Saves the VM configuration information to the preferences. This includes the following information:
      • The list of all defined IVMInstall instances.
      • The default VM
      This state will be read again upon first access to VM configuration information.
      Throws:
      org.eclipse.core.runtime.CoreException - if trying to save the current state of VMs encounters a problem

    • isContributedVMInstall

      public static boolean isContributedVMInstall(String id)
      Returns whether the VM install with the specified id was contributed via the vmInstalls extension point.
      Parameters:
      id - VM id
      Returns:
      whether the VM install was contributed via extension point
      Since:
      3.2

    • getLibraryLocations

      public static LibraryLocation[] getLibraryLocations(IVMInstall vm)
      Evaluates library locations for a IVMInstall. If no library locations are set on the install, a default location is evaluated and checked if it exists.
      Parameters:
      vm - the IVMInstall to compute locations for
      Returns:
      library locations with paths that exist or are empty
      Since:
      2.0

    • getJREVariableEntry

      public static IClasspathEntry getJREVariableEntry()
      Creates and returns a classpath entry describing the JRE_LIB classpath variable.
      Returns:
      a new IClasspathEntry that describes the JRE_LIB classpath variable

    • getDefaultJREContainerEntry

      public static IClasspathEntry getDefaultJREContainerEntry()
      Creates and returns a classpath entry describing the default JRE container entry.
      Returns:
      a new IClasspathEntry that describes the default JRE container entry
      Since:
      2.0

    • newDefaultJREContainerPath

      public static org.eclipse.core.runtime.IPath newDefaultJREContainerPath()
      Returns a path for the JRE classpath container identifying the default VM install.
      Returns:
      classpath container path
      Since:
      3.2

    • newJREContainerPath

      public static org.eclipse.core.runtime.IPath newJREContainerPath(IVMInstall vm)
      Returns a path for the JRE classpath container identifying the specified VM install by type and name.
      Parameters:
      vm - VM install
      Returns:
      classpath container path
      Since:
      3.2

    • newJREContainerPath

      public static org.eclipse.core.runtime.IPath newJREContainerPath(String typeId, String name)
      Returns a path for the JRE classpath container identifying the specified VM install by type and name.
      Parameters:
      typeId - VM install type identifier
      name - VM install name
      Returns:
      classpath container path
      Since:
      3.2

    • newJREContainerPath

      public static org.eclipse.core.runtime.IPath newJREContainerPath(IExecutionEnvironment environment)
      Returns a path for the JRE classpath container identifying the specified execution environment.
      Parameters:
      environment - execution environment
      Returns:
      classpath container path
      Since:
      3.2

    • getVMInstall

      public static IVMInstall getVMInstall(org.eclipse.core.runtime.IPath jreContainerPath)
      Returns the JRE referenced by the specified JRE classpath container path or null if none.
      Parameters:
      jreContainerPath - the path to the container to try and resolve the IVMInstall from
      Returns:
      JRE referenced by the specified JRE classpath container path or null
      Since:
      3.2

    • getVMInstallTypeId

      public static String getVMInstallTypeId(org.eclipse.core.runtime.IPath jreContainerPath)
      Returns the identifier of the VM install type referenced by the given JRE classpath container path, or null if none.
      Parameters:
      jreContainerPath - the path to the container to try and resolve the IVMInstallType id from
      Returns:
      VM install type identifier or null
      Since:
      3.2

    • getVMInstallName

      public static String getVMInstallName(org.eclipse.core.runtime.IPath jreContainerPath)
      Returns the name of the VM install referenced by the given JRE classpath container path, or null if none.
      Parameters:
      jreContainerPath - the path to the container to try an resolve the IVMInstall name from
      Returns:
      VM name or null
      Since:
      3.2

    • getExecutionEnvironmentId

      public static String getExecutionEnvironmentId(org.eclipse.core.runtime.IPath jreContainerPath)
      Returns the execution environment identifier in the following JRE classpath container path, or null if none.
      Parameters:
      jreContainerPath - classpath container path
      Returns:
      execution environment identifier or null
      Since:
      3.2

    • computeJREEntry

      public static IRuntimeClasspathEntry computeJREEntry(org.eclipse.debug.core.ILaunchConfiguration configuration) throws org.eclipse.core.runtime.CoreException
      Returns a runtime classpath entry identifying the JRE to use when launching the specified configuration or null if none is specified. The entry returned represents a either a classpath variable or classpath container that resolves to a JRE.

      The entry is resolved as follows:

      1. If the ATTR_JRE_CONTAINER_PATH is present, it is used to create a classpath container referring to a JRE.
      2. Next, if the ATTR_VM_INSTALL_TYPE and ATTR_VM_INSTALL_NAME attributes are present, they are used to create a classpath container.
      3. When none of the above attributes are specified, a default entry is created which refers to the JRE referenced by the build path of the configuration's associated Java project. This could be a classpath variable or classpath container.
      4. When there is no Java project associated with a configuration, the workspace default JRE is used to create a container path.
      Parameters:
      configuration - the backing ILaunchConfiguration
      Returns:
      classpath container path identifying a JRE or null
      Throws:
      org.eclipse.core.runtime.CoreException - if an exception occurs retrieving attributes from the specified launch configuration
      Since:
      3.2

    • computeJREEntry

      public static IRuntimeClasspathEntry computeJREEntry(IJavaProject project) throws org.eclipse.core.runtime.CoreException
      Returns a runtime classpath entry identifying the JRE referenced by the specified project, or null if none. The entry returned represents a either a classpath variable or classpath container that resolves to a JRE.
      Parameters:
      project - Java project
      Returns:
      JRE runtime classpath entry or null
      Throws:
      org.eclipse.core.runtime.CoreException - if an exception occurs accessing the project's classpath
      Since:
      3.2

    • computeModularJREEntry

      public static IRuntimeClasspathEntry computeModularJREEntry(IJavaProject project) throws org.eclipse.core.runtime.CoreException
      Returns a runtime classpath or modulepath entry identifying the JRE referenced by the specified project, or null if none. The entry returned represents a either a classpath variable or classpath container that resolves to a JRE.
      Parameters:
      project - Java project
      Returns:
      JRE runtime classpath or modulepath entry or null
      Throws:
      org.eclipse.core.runtime.CoreException - if an exception occurs accessing the project's classpath
      Since:
      3.10

    • isVMInstallReference

      public static boolean isVMInstallReference(IRuntimeClasspathEntry entry)
      Returns whether the given runtime classpath entry refers to a VM install.
      Parameters:
      entry - the entry to check
      Returns:
      whether the given runtime classpath entry refers to a VM install
      Since:
      3.2

    • getVMConnector

      public static IVMConnector getVMConnector(String id)
      Returns the VM connector defined with the specified identifier, or null if none.
      Parameters:
      id - VM connector identifier
      Returns:
      VM connector or null if none
      Since:
      2.0

    • getVMConnectors

      public static IVMConnector[] getVMConnectors()
      Returns all VM connector extensions.
      Returns:
      VM connectors
      Since:
      2.0

    • getPreferences

      public static org.eclipse.core.runtime.Preferences getPreferences()
      Returns the preference store for the launching plug-in.
      Returns:
      the preference store for the launching plug-in
      Since:
      2.0

    • savePreferences

      public static void savePreferences()
      Saves the preferences for the launching plug-in.
      Since:
      2.0

    • addVariableResolver

      public static void addVariableResolver(IRuntimeClasspathEntryResolver resolver, String variableName)
      Registers the given resolver for the specified variable.
      Parameters:
      resolver - runtime classpath entry resolver
      variableName - variable name to register for
      Since:
      2.0

    • addContainerResolver

      public static void addContainerResolver(IRuntimeClasspathEntryResolver resolver, String containerIdentifier)
      Registers the given resolver for the specified container.
      Parameters:
      resolver - runtime classpath entry resolver
      containerIdentifier - identifier of the classpath container to register for
      Since:
      2.0

    • addVMInstallChangedListener

      public static void addVMInstallChangedListener(IVMInstallChangedListener listener)
      Adds the given listener to the list of registered VM install changed listeners. Has no effect if an identical listener is already registered.
      Parameters:
      listener - the listener to add
      Since:
      2.0

    • removeVMInstallChangedListener

      public static void removeVMInstallChangedListener(IVMInstallChangedListener listener)
      Removes the given listener from the list of registered VM install changed listeners. Has no effect if an identical listener is not already registered.
      Parameters:
      listener - the listener to remove
      Since:
      2.0

    • fireVMChanged

      public static void fireVMChanged(PropertyChangeEvent event)
      Notifies all VM install changed listeners of the given property change.
      Parameters:
      event - event describing the change.
      Since:
      2.0

    • fireVMAdded

      public static void fireVMAdded(IVMInstall vm)
      Notifies all VM install changed listeners of the VM addition
      Parameters:
      vm - the VM that has been added
      Since:
      2.0

    • fireVMRemoved

      public static void fireVMRemoved(IVMInstall vm)
      Notifies all VM install changed listeners of the VM removal
      Parameters:
      vm - the VM that has been removed
      Since:
      2.0

    • getProjectOutputDirectory

      public static String getProjectOutputDirectory(org.eclipse.debug.core.ILaunchConfiguration config)
      Return the String representation of the default output directory of the launch config's project or null if there is no configuration, no project or some sort of problem.
      Parameters:
      config - the ILaunchConfiguration
      Returns:
      the default output directory for the specified launch configuration's project
      Since:
      2.1

    • getSourceContainers

      public static org.eclipse.debug.core.sourcelookup.ISourceContainer[] getSourceContainers(IRuntimeClasspathEntry[] entries)
      Returns a collection of source containers corresponding to the given resolved runtime classpath entries.

      Note that the entries must be resolved to ARCHIVE and PROJECT entries, as source containers cannot be determined for unresolved entries.

      Parameters:
      entries - entries to translate
      Returns:
      source containers corresponding to the given runtime classpath entries
      Since:
      3.1

    • computeJavaLibraryPath

      public static String[] computeJavaLibraryPath(IJavaProject project, boolean requiredProjects) throws org.eclipse.core.runtime.CoreException
      Returns a collection of paths that should be appended to the given project's java.library.path system property when launched. Entries are searched for on the project's build path as extra classpath attributes. Each entry represents an absolute path in the local file system.
      Parameters:
      project - the project to compute the java.library.path for
      requiredProjects - whether to consider entries in required projects
      Returns:
      a collection of paths representing entries that should be appended to the given project's java.library.path
      Throws:
      org.eclipse.core.runtime.CoreException - if unable to compute the Java library path
      Since:
      3.1
      See Also:

    • newLibraryPathsAttribute

      public static IClasspathAttribute newLibraryPathsAttribute(String[] paths)
      Creates a new classpath attribute referencing a list of shared libraries that should appear on the -Djava.library.path system property at runtime for an associated IClasspathEntry.

      The factory methods newLibraryPathsAttribute(String[]) and getLibraryPaths(IClasspathAttribute) should be used to encode and decode the attribute value.

      Parameters:
      paths - an array of strings representing paths of shared libraries. Each string is used to create an IPath using the constructor Path(String), and may contain IStringVariable's. Variable substitution is performed on each string before a path is constructed from a string.
      Returns:
      a classpath attribute with the name CLASSPATH_ATTR_LIBRARY_PATH_ENTRY and an value encoded to the specified paths.
      Since:
      3.1

    • getLibraryPaths

      public static String[] getLibraryPaths(IClasspathAttribute attribute)
      Returns an array of strings referencing shared libraries that should appear on the -Djava.library.path system property at runtime for an associated IClasspathEntry, or null if the given attribute is not a CLASSPATH_ATTR_LIBRARY_PATH_ENTRY. Each string is used to create an IPath using the constructor Path(String), and may contain IStringVariable's.

      The factory methods newLibraryPathsAttribute(String[]) and getLibraryPaths(IClasspathAttribute) should be used to encode and decode the attribute value.

      Parameters:
      attribute - a CLASSPATH_ATTR_LIBRARY_PATH_ENTRY classpath attribute
      Returns:
      an array of strings referencing shared libraries that should appear on the -Djava.library.path system property at runtime for an associated IClasspathEntry, or null if the given attribute is not a CLASSPATH_ATTR_LIBRARY_PATH_ENTRY. Each string is used to create an IPath using the constructor Path(String), and may contain IStringVariable's.
      Since:
      3.1

    • getExecutionEnvironmentsManager

      public static IExecutionEnvironmentsManager getExecutionEnvironmentsManager()
      Returns the execution environments manager.
      Returns:
      execution environments manager
      Since:
      3.2

    • createVMFromDefinitionFile

      public static VMStandin createVMFromDefinitionFile(File eeFile, String name, String id) throws org.eclipse.core.runtime.CoreException
      Creates a new VM based on the attributes specified in the given execution environment description file. The format of the file is defined by http://wiki.eclipse.org/Execution_Environment_Descriptions.
      Parameters:
      eeFile - VM definition file
      name - name for the VM, or null if a default name should be assigned
      id - id to assign to the new VM
      Returns:
      VM stand-in
      Throws:
      org.eclipse.core.runtime.CoreException - if unable to create a VM from the given definition file
      Since:
      3.4

    • getModuleCLIOptions

      public static String getModuleCLIOptions(org.eclipse.debug.core.ILaunchConfiguration configuration)
      Returns the module-related command line options for the configuration that are needed at runtime as equivalents of those options specified by IClasspathAttributes of the following names: IClasspathAttribute.PATCH_MODULE is not handled here, but in AbstractJavaLaunchConfigurationDelegate.getModuleCLIOptions(ILaunchConfiguration), which then collates all options referring to the same module.
      Since:
      3.10