Package org.eclipse.jdt.core

## Class ClasspathContainerInitializer

- java.lang.Object
- - org.eclipse.jdt.core.ClasspathContainerInitializer

    public abstract class ClasspathContainerInitializer
    extends Object

Abstract base implementation of all classpath container initializer. Classpath variable containers are used in conjunction with the "org.eclipse.jdt.core.classpathContainerInitializer" extension point.

Clients should subclass this class to implement a specific classpath container initializer. The subclass must have a public 0-argument constructor and a concrete implementation of `initialize(IPath, IJavaProject)`.

Multiple classpath containers can be registered, each of them declares the container ID they can handle, so as to narrow the set of containers they can resolve, in other words, a container initializer is guaranteed to only be activated to resolve containers which match the ID they registered onto.

In case multiple container initializers collide on the same container ID, the first registered one will be invoked.

Since:
  2.0
See Also:
  `IClasspathEntry`, `IClasspathContainer`

### Field Summary

Fields
`static int` `ATTRIBUTE_NOT_SUPPORTED` Status code indicating that an attribute is not supported.
`static int` `ATTRIBUTE_READ_ONLY` Status code indicating that an attribute is not modifiable.

### Constructor Summary

Constructors
`ClasspathContainerInitializer()` Creates a new classpath container initializer.

### Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
`boolean` `canUpdateClasspathContainer​(IPath containerPath, IJavaProject project)` Returns `true` if this container initializer can be requested to perform updates on its own container values.
`IStatus` `getAccessRulesStatus​(IPath containerPath, IJavaProject project)` Returns the access rules attribute status according to this initializer.
`IStatus` `getAttributeStatus​(IPath containerPath, IJavaProject project, String attributeKey)` Returns the extra attribute status according to this initializer.
`Object` `getComparisonID​(IPath containerPath, IJavaProject project)` Returns an object which identifies a container for comparison purpose.
`String` `getDescription​(IPath containerPath, IJavaProject project)` Returns a readable description for a container path.
`IClasspathContainer` `getFailureContainer​(IPath containerPath, IJavaProject project)` Returns a classpath container that is used after this initializer failed to bind a classpath container to a `IClasspathContainer` for the given project.
`IStatus` `getSourceAttachmentStatus​(IPath containerPath, IJavaProject project)` Returns the source attachment attribute status according to this initializer.
`abstract void` `initialize​(IPath containerPath, IJavaProject project)` Binds a classpath container to a `IClasspathContainer` for a given project, or silently fails if unable to do so.
`void` `requestClasspathContainerUpdate​(IPath containerPath, IJavaProject project, IClasspathContainer containerSuggestion)` Request a registered container definition to be updated according to a container suggestion.

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Field Detail

#### ATTRIBUTE_NOT_SUPPORTED

    public static final int ATTRIBUTE_NOT_SUPPORTED

Status code indicating that an attribute is not supported.

Since:
  3.3
See Also:
  `getAccessRulesStatus(IPath, IJavaProject)`, `getAttributeStatus(IPath, IJavaProject, String)`, `getSourceAttachmentStatus(IPath, IJavaProject)`, Constant Field Values

#### ATTRIBUTE_READ_ONLY

    public static final int ATTRIBUTE_READ_ONLY

Status code indicating that an attribute is not modifiable.

Since:
  3.3
See Also:
  `getAccessRulesStatus(IPath, IJavaProject)`, `getAttributeStatus(IPath, IJavaProject, String)`, `getSourceAttachmentStatus(IPath, IJavaProject)`, Constant Field Values

### Constructor Detail

#### ClasspathContainerInitializer

    public ClasspathContainerInitializer()

Creates a new classpath container initializer.

### Method Detail

#### initialize

    public abstract void initialize​(IPath containerPath,
                                    IJavaProject project)
                             throws CoreException

Binds a classpath container to a `IClasspathContainer` for a given project, or silently fails if unable to do so.

A container is identified by a container path, which must be formed of two segments. The first segment is used as a unique identifier (which this initializer did register onto), and the second segment can be used as an additional hint when performing the resolution.

The initializer is invoked if a container path needs to be resolved for a given project, and no value for it was recorded so far. The implementation of the initializer would typically set the corresponding container using `JavaCore#setClasspathContainer`.

A container initialization can be indirectly performed while attempting to resolve a project classpath using `IJavaProject#getResolvedClasspath(`; or directly when using `JavaCore#getClasspathContainer`. During the initialization process, any attempt to further obtain the same container will simply return `null` so as to avoid an infinite regression of initializations.

A container initialization may also occur indirectly when setting a project classpath, as the operation needs to resolve the classpath for validation purpose. While the operation is in progress, a referenced container initializer may be invoked. If the initializer further tries to access the referring project classpath, it will not see the new assigned classpath until the operation has completed. Note that once the Java change notification occurs (at the end of the operation), the model has been updated, and the project classpath can be queried normally.

This method is called by the Java model to give the party that defined this particular kind of classpath container the chance to install classpath container objects that will be used to convert classpath container entries into simpler classpath entries. The method is typically called exactly once for a given Java project and classpath container entry. This method must not be called by other clients.

There are a wide variety of conditions under which this method may be invoked. To ensure that the implementation does not interfere with correct functioning of the Java model, the implementation should use only the following Java model APIs:

- `JavaCore.setClasspathContainer(IPath, IJavaProject[], IClasspathContainer[], org.eclipse.core.runtime.IProgressMonitor)`
- `JavaCore.getClasspathContainer(IPath, IJavaProject)`
- `JavaCore.create(org.eclipse.core.resources.IWorkspaceRoot)`
- `JavaCore.create(org.eclipse.core.resources.IProject)`
- `IJavaModel.getJavaProjects()`
- Java element operations marked as "handle-only"

The effects of using other Java model APIs are unspecified.

Parameters:
  `containerPath` - a two-segment path (ID/hint) identifying the container that needs to be resolved
  `project` - the Java project in which context the container is to be resolved. This allows generic containers to be bound with project specific values.
Throws:
  `CoreException` - if an exception occurs during the initialization
See Also:
  `JavaCore.getClasspathContainer(IPath, IJavaProject)`, `JavaCore.setClasspathContainer(IPath, IJavaProject[], IClasspathContainer[], org.eclipse.core.runtime.IProgressMonitor)`, `IClasspathContainer`

#### canUpdateClasspathContainer

    public boolean canUpdateClasspathContainer​(IPath containerPath,
                                               IJavaProject project)

Returns `true` if this container initializer can be requested to perform updates on its own container values. If so, then an update request will be performed using `requestClasspathContainerUpdate(IPath, IJavaProject, IClasspathContainer)`.

Parameters:
  `containerPath` - the path of the container which requires to be updated
  `project` - the project for which the container is to be updated
Returns:
  returns `true` if the container can be updated
Since:
  2.1

#### requestClasspathContainerUpdate

    public void requestClasspathContainerUpdate​(IPath containerPath,
                                                IJavaProject project,
                                                IClasspathContainer containerSuggestion)
                                         throws CoreException

Request a registered container definition to be updated according to a container suggestion. The container suggestion only acts as a place-holder to pass along the information to update the matching container definition(s) held by the container initializer. In particular, it is not expected to store the container suggestion as is, but rather adjust the actual container definition based on suggested changes.

IMPORTANT: In reaction to receiving an update request, a container initializer will update the corresponding container definition (after reconciling changes) at its earliest convenience, using `JavaCore.setClasspathContainer(IPath, IJavaProject[], IClasspathContainer[], IProgressMonitor)`. Until it does so, the update will not be reflected in the Java Model.

In order to anticipate whether the container initializer allows to update its containers, the predicate `canUpdateClasspathContainer(IPath, IJavaProject)` should be used.

Parameters:
  `containerPath` - the path of the container which requires to be updated
  `project` - the project for which the container is to be updated
  `containerSuggestion` - a suggestion to update the corresponding container definition
Throws:
  `CoreException` - when `JavaCore#setClasspathContainer` would throw any.
Since:
  2.1
See Also:
  `JavaCore.setClasspathContainer(IPath, IJavaProject[], IClasspathContainer[], org.eclipse.core.runtime.IProgressMonitor)`, `canUpdateClasspathContainer(IPath, IJavaProject)`

#### getDescription

    public String getDescription​(IPath containerPath,
                                 IJavaProject project)

Returns a readable description for a container path. A readable description for a container path can be used for improving the display of references to container, without actually needing to resolve them. A good implementation should answer a description consistent with the description of the associated target container (see `IClasspathContainer.getDescription()`).

Parameters:
  `containerPath` - the path of the container which requires a readable description
  `project` - the project from which the container is referenced
Returns:
  a string description of the container
Since:
  2.1

#### getFailureContainer

    public IClasspathContainer getFailureContainer​(IPath containerPath,
                                                   IJavaProject project)

Returns a classpath container that is used after this initializer failed to bind a classpath container to a `IClasspathContainer` for the given project. A non-`null` failure container indicates that there will be no more request to initialize the given container for the given project.

By default a non-`null` failure container with no classpath entries is returned. Clients wishing to get a chance to run the initializer again should override this method and return `null`.

Parameters:
  `containerPath` - the path of the container which failed to initialize
  `project` - the project from which the container is referenced
Returns:
  the default failure container, or `null` if wishing to run the initializer again
Since:
  3.3

#### getComparisonID

    public Object getComparisonID​(IPath containerPath,
                                  IJavaProject project)

Returns an object which identifies a container for comparison purpose. This allows to eliminate redundant containers when accumulating classpath entries (e.g. runtime classpath computation). When requesting a container comparison ID, one should ensure using its corresponding container initializer. Indeed, a random container initializer cannot be held responsible for determining comparison IDs for arbitrary containers.

Parameters:
  `containerPath` - the path of the container which is being checked
  `project` - the project for which the container is to being checked
Returns:
  returns an Object identifying the container for comparison
Since:
  3.0

#### getAccessRulesStatus

    public IStatus getAccessRulesStatus​(IPath containerPath,
                                        IJavaProject project)

Returns the access rules attribute status according to this initializer.

The returned `status` can have one of the following severities:

- `OK`: means that the attribute is supported and is modifiable
- `ERROR`: means that either the attribute is not supported or is not modifiable.
  In this case, the `code`will have respectively the `ATTRIBUTE_NOT_SUPPORTED` value or the `ATTRIBUTE_READ_ONLY` value.

The status message can contain more information.

If the subclass does not override this method, then the default behavior is to return `OK` if and only if the classpath container can be updated (see `canUpdateClasspathContainer(IPath, IJavaProject)`).

Parameters:
  `containerPath` - the path of the container which requires to be updated
  `project` - the project for which the container is to be updated
Returns:
  returns the access rules attribute status
Since:
  3.3

#### getAttributeStatus

    public IStatus getAttributeStatus​(IPath containerPath,
                                      IJavaProject project,
                                      String attributeKey)

Returns the extra attribute status according to this initializer.

The returned `status` can have one of the following severities:

- `OK`: means that the attribute is supported and is modifiable
- `ERROR`: means that either the attribute is not supported or is not modifiable.
  In this case, the `code`will have respectively the `ATTRIBUTE_NOT_SUPPORTED` value or the `ATTRIBUTE_READ_ONLY` value.

The status message can contain more information.

If the subclass does not override this method, then the default behavior is to return `OK` if and only if the classpath container can be updated (see `canUpdateClasspathContainer(IPath, IJavaProject)`).

Parameters:
  `containerPath` - the path of the container which requires to be updated
  `project` - the project for which the container is to be updated
  `attributeKey` - the key of the extra attribute
Returns:
  returns the extra attribute status
Since:
  3.3
See Also:
  `IClasspathAttribute`

#### getSourceAttachmentStatus

    public IStatus getSourceAttachmentStatus​(IPath containerPath,
                                             IJavaProject project)

Returns the source attachment attribute status according to this initializer.

The returned `status` can have one of the following severities:

- `OK`: means that the attribute is supported and is modifiable
- `ERROR`: means that either the attribute is not supported or is not modifiable.
  In this case, the `code`will have respectively the `ATTRIBUTE_NOT_SUPPORTED` value or the `ATTRIBUTE_READ_ONLY` value.

The status message can contain more information.

If the subclass does not override this method, then the default behavior is to return `OK` if and only if the classpath container can be updated (see `canUpdateClasspathContainer(IPath, IJavaProject)`).

Parameters:
  `containerPath` - the path of the container which requires to be updated
  `project` - the project for which the container is to be updated
Returns:
  returns the source attachment attribute status
Since:
  3.3