org.eclipse.jdt.core
Interface IClasspathEntry

public interface IClasspathEntry

An entry on a Java project classpath identifying one or more package fragment roots. A classpath entry has a content kind (either source, K_SOURCE, or binary, 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:

• Source code in the current project. In this case, the entry identifies a root folder in the current project containing package fragments and .java source files. The root folder itself represents a default package, subfolders represent package fragments, and .java files 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_SOURCE constant.
• A binary library in the current project, in another project, or in the external file system. In this case the entry identifies a JAR (or root folder) containing package fragments and .class files. 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 CPE_LIBRARY constant.
• A required project. In this case the entry identifies another project in the workspace. The required project is used as a binary library when compiling (that is, the builder looks in the output location of the required project for required .class files 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_PROJECT constant. Note: referencing a required project with a classpath entry refers to the source code or associated .class files 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 (IClasspathEntry#isExported). Unless exporting some classpath entries, classpaths are not chained by default - each project must specify its own classpath in its entirety.
• A path beginning in a classpath variable defined globally to the workspace. Entries of this kind are associated with the CPE_VARIABLE constant. Classpath variables are created using JavaCore#setClasspathVariable, and gets resolved, to either a project or library entry, using JavaCore#getResolvedClasspathVariable. 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.
• A named classpath container identified by its container path. A classpath container provides a way to indirectly reference a set of classpath entries through a classpath entry of kind 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 setClasspathContainer, then a ClasspathContainerInitializer will 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 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.
  Also note that the container resolution APIs include an IJavaProject argument, so as to allow the same container path to be interpreted in different ways for different projects.

The result of IJavaProject#getResolvedClasspath will have all entries of type CPE_VARIABLE and CPE_CONTAINER resolved to a set of CPE_SOURCE, CPE_LIBRARY or CPE_PROJECT classpath entries.

Any classpath entry other than a source folder (kind CPE_SOURCE) can be marked as being exported. Exported entries are automatically contributed to dependent projects, along with the project's output folder, which is implicitly exported. The project's output folder is always listed first, followed by the any exported entries.

This interface is not intended to be implemented by clients. Classpath entries can be created via methods on JavaCore.

See Also:

JavaCore.newLibraryEntry(org.eclipse.core.runtime.IPath, org.eclipse.core.runtime.IPath, org.eclipse.core.runtime.IPath), JavaCore.newProjectEntry(org.eclipse.core.runtime.IPath), JavaCore.newSourceEntry(org.eclipse.core.runtime.IPath), JavaCore.newVariableEntry(org.eclipse.core.runtime.IPath, org.eclipse.core.runtime.IPath, org.eclipse.core.runtime.IPath), JavaCore.newContainerEntry(org.eclipse.core.runtime.IPath), ClasspathVariableInitializer, ClasspathContainerInitializer

Field Summary

static int	CPE_CONTAINER Entry kind constant describing a classpath entry representing a name classpath container.
static int	CPE_LIBRARY Entry kind constant describing a classpath entry identifying a library.
static int	CPE_PROJECT Entry kind constant describing a classpath entry identifying a required project.
static int	CPE_SOURCE Entry kind constant describing a classpath entry identifying a folder containing package fragments with source code to be compiled.
static int	CPE_VARIABLE Entry kind constant describing a classpath entry defined using a path that begins with a classpath variable reference.

Method Summary

int	getContentKind() Returns the kind of files found in the package fragments identified by this classpath entry.
int	getEntryKind() Returns the kind of this classpath entry.
IPath	getPath() Returns the path of this classpath entry.
IClasspathEntry	getResolvedEntry() Deprecated. - use JavaCore.getResolvedClasspathEntry(...)
IPath	getSourceAttachmentPath() Returns the path to the source archive associated with this classpath entry, or null if this classpath entry has no source attachment.
IPath	getSourceAttachmentRootPath() Returns the path within the source archive where package fragments are located.
boolean	isExported() Returns whether this entry is exported to dependent projects.

Field Detail

CPE_LIBRARY

public static final int CPE_LIBRARY

Entry kind constant describing a classpath entry identifying a library. A library is a folder or JAR containing package fragments consisting of pre-compiled binaries.

See Also:

Constant Field Values

CPE_PROJECT

public static final int CPE_PROJECT

Entry kind constant describing a classpath entry identifying a required project.

See Also:

Constant Field Values

CPE_SOURCE

public static final int CPE_SOURCE

Entry kind constant describing a classpath entry identifying a folder containing package fragments with source code to be compiled.

See Also:

Constant Field Values

CPE_VARIABLE

public static final int CPE_VARIABLE

Entry kind constant describing a classpath entry defined using a path that begins with a classpath variable reference.

See Also:

Constant Field Values

CPE_CONTAINER

public static final int CPE_CONTAINER

Entry kind constant describing a classpath entry representing a name classpath container.

Since:

2.0

See Also:

Constant Field Values

Method Detail

getContentKind

public int getContentKind()

Returns the kind of files found in the package fragments identified by this classpath entry.

Returns:

IPackageFragmentRoot.K_SOURCE for files containing source code, and IPackageFragmentRoot.K_BINARY for binary class files. There is no specified value for an entry denoting a variable (CPE_VARIABLE) or a classpath container (CPE_CONTAINER).

getEntryKind

public int getEntryKind()

Returns the kind of this classpath entry.

Returns:

one of:

• 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

getPath

public IPath getPath()

Returns the path of this classpath entry. The meaning of the path of a classpath entry depends on its entry kind:

• Source code in the current project (CPE_SOURCE) - The path associated with this entry is the absolute path to the root folder.
• A binary library in the current project (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 JAR, then there is no associated resource in the workbench.
• A required project (CPE_PROJECT) - the path of the entry denotes the path to the corresponding project resource.
• A variable entry (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.
• A container entry (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 IClasspathContainer).

Returns:

the path of this classpath entry

getSourceAttachmentPath

public IPath getSourceAttachmentPath()

Returns the path to the source archive associated with this classpath entry, or null if 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. 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.

Returns:

the path to the source archive, or null if none

getSourceAttachmentRootPath

public IPath getSourceAttachmentRootPath()

Returns the path within the source archive where package fragments are located. An empty path indicates that packages are located at the root of the source archive. Returns a non-null value if and only if getSourceAttachmentPath returns a non-null value.

Returns:

the path within the source archive, or null if not applicable

isExported

public boolean isExported()

Returns whether this entry is exported to dependent projects. Always returns false for source entries (kind CPE_SOURCE), which cannot be exported.

Returns:

true if exported, and false otherwise

Since:

2.0

getResolvedEntry

public IClasspathEntry getResolvedEntry()

Deprecated. - use JavaCore.getResolvedClasspathEntry(...)

This is a helper method, which returns the resolved classpath entry denoted by an entry (if it is a variable entry). It is obtained by resolving the variable reference in the first segment. Returns null if unable to resolve using the following algorithm:

• if variable segment cannot be resolved, returns null
• finds a project, JAR or binary folder in the workspace at the resolved path location
• if none finds an external JAR file or folder outside the workspace at the resolved path location
• if none returns null

Variable source attachment is also resolved and recorded in the resulting classpath entry.

Returns:

the resolved library or project classpath entry, or null if the given path could not be resolved to a classpath entry

Note that this deprecated API doesn't handle CPE_CONTAINER entries.