public interface IClasspathEntry
IPackageFragmentRoot.K_SOURCE, or binary,
IPackageFragmentRoot.K_BINARY), which is inherited by each package fragment root and package fragment associated with the entry.
A classpath entry can refer to any of the following:
Java-like extensions. The root folder itself represents a default package, subfolders represent package fragments, and files with a Java-like extension (e.g.
.javafiles) represent compilation units. All compilation units will be compiled when the project is built. The classpath entry must specify the absolute path to the root folder. Entries of this kind are associated with the
CPE_SOURCEconstant. Source classpath entries can carry inclusion and exclusion patterns for selecting which source files appear as compilation units and get compiled when the project is built.
.classfiles. The classpath entry must specify the absolute path to the JAR (or root folder), and in case it refers to an external JAR, then there is no associated resource in the workbench. Entries of this kind are associated with the
.classfiles when building). When performing other "development" operations - such as code assist, code resolve, type hierarchy creation, etc. - the source code of the project is referred to. Thus, development is performed against a required project's source code, and compilation is performed against a required project's last built state. The classpath entry must specify the absolute path to the project. Entries of this kind are associated with the
CPE_PROJECTconstant. Note: referencing a required project with a classpath entry refers to the source code or associated
.classfiles located in its output location. It will also automatically include any other libraries or projects that the required project's classpath refers to, iff the corresponding classpath entries are tagged as being exported (
isExported()). Unless exporting some classpath entries, classpaths are not chained by default - each project must specify its own classpath in its entirety.
CPE_VARIABLEconstant. Classpath variables are created using
JavaCore.setClasspathVariable(String, IPath, org.eclipse.core.runtime.IProgressMonitor), and gets resolved, to either a project or library entry, using
JavaCore.getResolvedClasspathEntry(IClasspathEntry). It is also possible to register an automatic initializer (
ClasspathVariableInitializer), which will be invoked through the extension point "org.eclipse.jdt.core.classpathVariableInitializer". After resolution, a classpath variable entry may either correspond to a project or a library entry.
CPE_CONTAINER. Typically, a classpath container can be used to describe a complex library composed of multiple JARs, projects or classpath variables, considering also that containers can be mapped differently on each project. Several projects can reference the same generic container path, but have each of them actually bound to a different container object. The container path is a formed by a first ID segment followed with extra segments, which can be used as additional hints for resolving this container reference. If no container was ever recorded for this container path onto this project (using
JavaCore.setClasspathContainer(org.eclipse.core.runtime.IPath, org.eclipse.jdt.core.IJavaProject, org.eclipse.jdt.core.IClasspathContainer, org.eclipse.core.runtime.IProgressMonitor), then a
ClasspathContainerInitializerwill be activated if any was registered for this container ID onto the extension point "org.eclipse.jdt.core.classpathContainerInitializer". A classpath container entry can be resolved explicitly using
JavaCore.getClasspathContainer(org.eclipse.core.runtime.IPath, org.eclipse.jdt.core.IJavaProject)and the resulting container entries can contain any non-container entry. In particular, it may contain variable entries, which in turn needs to be resolved before being directly used.
IJavaProject.getResolvedClasspath(boolean)will have all entries of type
CPE_CONTAINERresolved to a set of
Any classpath entry other than a source folder (kind
be marked as being exported. Exported entries are automatically contributed to
dependent projects, along with the project's default output folder, which is
implicitly exported, and any auxiliary output folders specified on source
classpath entries. The project's output folder(s) are always listed first,
followed by the any exported entries.
Classpath entries can be created via methods on
JavaCore.newLibraryEntry(org.eclipse.core.runtime.IPath, org.eclipse.core.runtime.IPath, org.eclipse.core.runtime.IPath),
JavaCore.newVariableEntry(org.eclipse.core.runtime.IPath, org.eclipse.core.runtime.IPath, org.eclipse.core.runtime.IPath),
|Modifier and Type||Field and Description|
Entry kind constant describing a classpath entry representing a name classpath container.
Entry kind constant describing a classpath entry identifying a library.
Entry kind constant describing a classpath entry identifying a required project.
Entry kind constant describing a classpath entry identifying a folder containing package fragments with source code to be compiled.
Entry kind constant describing a classpath entry defined using a path that begins with a classpath variable reference.
|Modifier and Type||Method and Description|
Returns whether the access rules of the project's exported entries should be combined with this entry's access rules.
Returns the possibly empty list of access rules for this entry.
Returns the kind of files found in the package fragments identified by this classpath entry.
Returns the kind of this classpath entry.
Returns the set of patterns used to exclude resources or classes associated with this classpath entry.
Returns the extra classpath attributes for this classpath entry.
Returns the set of patterns used to explicitly define resources or classes to be included with this classpath entry.
Returns the full path to the specific location where the builder writes
Returns the path of this classpath entry.
Returns the classpath entry that is making a reference to this classpath entry.
Returns the path to the source archive or folder associated with this classpath entry, or
Returns the path within the source archive or folder where package fragments are located.
Returns whether this entry is exported to dependent projects.
static final int CPE_LIBRARY
static final int CPE_PROJECT
static final int CPE_SOURCE
static final int CPE_VARIABLE
static final int CPE_CONTAINER
CPE_SOURCE- this entry describes a source root in its project
CPE_LIBRARY- this entry describes a folder or JAR containing binaries
CPE_PROJECT- this entry describes another project
CPE_VARIABLE- this entry describes a project or library indirectly via a classpath variable in the first segment of the path *
CPE_CONTAINER- this entry describes set of entries referenced indirectly via a classpath container
For source classpath entries, exclusion patterns allow specified portions of the resource tree rooted at this source entry's path to be filtered out. If no exclusion patterns are specified, this source entry includes all relevent files. Each path specified must be a relative path, and will be interpreted relative to this source entry's path. File patterns are case-sensitive. A file matched by one or more of these patterns is excluded from the corresponding package fragment root. Exclusion patterns have higher precedence than inclusion patterns; in other words, exclusion patterns can remove files for the ones that are to be included, not the other way around.
Note that there is no need to supply a pattern to exclude ".class" files because a source entry filters these out automatically.
The pattern mechanism is similar to Ant's. Each pattern is represented as a relative path. The path segments can be regular file or folder names or simple patterns involving standard wildcard characters.
'*' matches 0 or more characters within a segment. So
Foo.java, but not
(does not end with
'?' matches 1 character within a segment. So
xyz.java (neither have
just one character before
Combinations of *'s and ?'s are allowed.
The special pattern '**' matches zero or more segments. In a source entry,
a path like
tests/ that ends in a trailing separator is interpreted
tests/**, and would match everything under
the folder named
Example patterns in source entries (assuming that "java" is the only
tests/) matches all files under a root folder named
tests. This includes
tests/com/example/Foo.java, but not
com/example/tests/Foo.java(not under a root folder named
tests/*matches all files directly below a root folder named
tests. This includes
tests/com/example/Foo.java(not directly under a folder named
com/Foo.java(not under a folder named
**/tests/**matches all files under any folder named
tests. This includes
com/examples/tests/unit/Foo.java, but not
com/example/Foo.java(not under a folder named
nullif this kind of classpath entry does not support exclusion patterns
For source classpath entries, when no inclusion patterns are specified, the source entry includes all relevent files in the resource tree rooted at this source entry's path. Specifying one or more inclusion patterns means that only the specified portions of the resource tree are to be included. Each path specified must be a relative path, and will be interpreted relative to this source entry's path. File patterns are case-sensitive. A file matched by one or more of these patterns is included in the corresponding package fragment root unless it is excluded by one or more of this entrie's exclusion patterns. Exclusion patterns have higher precedence than inclusion patterns; in other words, exclusion patterns can remove files for the ones that are to be included, not the other way around.
getExclusionPatterns() for a discussion of the syntax and
semantics of path patterns. The absence of any inclusion patterns is
semantically equivalent to the explicit inclusion pattern
Example patterns in source entries:
src/**by itself includes all files under a root folder named
tests/**includes all files under the root folders named
src/**together with the exclusion pattern
src/**/Foo.javaincludes all files under a root folder named
srcexcept for ones named
nullif this kind of classpath entry does not support inclusion patterns
.classfiles generated for this source entry (entry kind
Source entries can optionally be associated with a specific output location.
If none is provided, the source entry will be implicitly associated with its project
default output location (see
NOTE: A specific output location cannot coincidate with another source/library entry.
.classfiles for this source entry, or
nullif using default output folder
CPE_SOURCE) - The path associated with this entry is the absolute path to the root folder.
CPE_LIBRARY) - the path associated with this entry is the absolute path to the JAR (or root folder), and in case it refers to an external library, then there is no associated resource in the workbench.
CPE_PROJECT) - the path of the entry denotes the path to the corresponding project resource.
CPE_VARIABLE) - the first segment of the path is the name of a classpath variable. If this classpath variable is bound to the path P, the path of the corresponding classpath entry is computed by appending to P the segments of the returned path without the variable.
CPE_CONTAINER) - the path of the entry is the name of the classpath container, which can be bound indirectly to a set of classpath entries after resolution. The containerPath is a formed by a first ID segment followed with extra segments that can be used as additional hints for resolving this container reference (also see
nullif this classpath entry has no source attachment.
Only library and variable classpath entries may have source attachments. For library classpath entries, the result path (if present) locates a source archive or folder. This archive or folder can be located in a project of the workspace or outside the workspace. For variable classpath entries, the result path (if present) has an analogous form and meaning as the variable path, namely the first segment is the name of a classpath variable.
nullvalue if and only if
getSourceAttachmentPath()returns a non-
nullif not applicable
CPE_LIBRARY, the return value is the entry that is representing the JAR that includes
thisin the MANIFEST.MF file's Class-Path section. For entry kinds other than
CPE_LIBRARY, this returns
null. For those entries that are on the raw classpath already, this returns
It is possible that multiple library entries refer to the same entry
via the MANIFEST.MF file. In those cases, this method returns the first classpath entry
that appears in the raw classpath. However, this does not mean that the other referencing
entries do not relate to their referenced entries.
JavaCore.getReferencedClasspathEntries(IClasspathEntry, IJavaProject) for
nullif not applicable.
falsefor source entries (kind
CPE_SOURCE), which cannot be exported.
trueif exported, and
nullif unable to resolve using the following algorithm:
Variable source attachment is also resolved and recorded in the resulting classpath entry.
nullif the given path could not be resolved to a classpath entry
Note that this deprecated API doesn't handle CPE_CONTAINER entries.
Copyright (c) 2000, 2015 Eclipse Contributors and others. All rights reserved.Guidelines for using Eclipse APIs.