org.eclipse.wst.jsdt.libraries

## Class BasicBrowserLibraryJsGlobalScopeContainerInitializer

- java.lang.Object
- - org.eclipse.wst.jsdt.core.JsGlobalScopeContainerInitializer
  - - org.eclipse.wst.jsdt.libraries.BasicBrowserLibraryJsGlobalScopeContainerInitializer

All Implemented Interfaces:
  IJsGlobalScopeContainer, IJsGlobalScopeContainerInitializer

    public class BasicBrowserLibraryJsGlobalScopeContainerInitializer
    extends JsGlobalScopeContainerInitializer
    implements IJsGlobalScopeContainer

Provisional API: This class/interface is part of an interim API that is still under development and expected to change significantly before reaching stability. It is being made available at this early stage to solicit feedback from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken (repeatedly) as the API evolves.

### Field Summary

### Fields inherited from class org.eclipse.wst.jsdt.core.JsGlobalScopeContainerInitializer

`ATTRIBUTE_NOT_SUPPORTED, ATTRIBUTE_READ_ONLY`

### Fields inherited from interface org.eclipse.wst.jsdt.core.IJsGlobalScopeContainer

`K_APPLICATION, K_DEFAULT_SYSTEM, K_SYSTEM`

### Constructor Summary

Constructors
Constructor and Description
`BasicBrowserLibraryJsGlobalScopeContainerInitializer()`

### Method Summary

All Methods Instance Methods Concrete Methods
`boolean` `canUpdateJsGlobalScopeContainer(IPath containerPath, IJavaScriptProject project)` Returns `true` if this container initializer can be requested to perform updates on its own container values.
`java.lang.String[]` `containerSuperTypes()` returns a String of all SuperTypes provided by this library.
`protected IJsGlobalScopeContainer` `getContainer(IPath containerPath, IJavaScriptProject project)`
`java.lang.String` `getDescription()` Answers a readable description of this container
`java.lang.String` `getDescription(IPath containerPath, IJavaScriptProject project)` Returns a readable description for a container path.
`IIncludePathEntry[]` `getIncludepathEntries()` Answers the set of includepath entries this container is mapping to.
`java.lang.String` `getInferenceID()` Get the id of the inference provider for this library
`int` `getKind()` Answers the kind of this container.
`LibraryLocation` `getLibraryLocation()`
`IPath` `getPath()` Answers the container path identifying this container.
`void` `initialize(IPath containerPath, IJavaScriptProject project)` Binds a includepath container to a `IJsGlobalScopeContainer` for a given project, or silently fails if unable to do so.

### Methods inherited from class org.eclipse.wst.jsdt.core.JsGlobalScopeContainerInitializer

`allowAttachJsDoc, getAccessRulesStatus, getAttributeStatus, getComparisonID, getFailureContainer, getHostPath, getSourceAttachmentStatus, removeFromProject, requestJsGlobalScopeContainerUpdate, resolvedLibraryImport`

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

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

### Methods inherited from interface org.eclipse.wst.jsdt.core.IJsGlobalScopeContainer

`resolvedLibraryImport`

### Constructor Detail

#### BasicBrowserLibraryJsGlobalScopeContainerInitializer

    public BasicBrowserLibraryJsGlobalScopeContainerInitializer()

### Method Detail

#### getLibraryLocation

    public LibraryLocation getLibraryLocation()

Specified by:
  `getLibraryLocation` in interface `IJsGlobalScopeContainerInitializer`

#### getIncludepathEntries

    public IIncludePathEntry[] getIncludepathEntries()

Description copied from interface: `IJsGlobalScopeContainer`
Answers the set of includepath entries this container is mapping to.

The set of entries associated with a includepath container may contain any of the following:

- library entries (`CPE_LIBRARY`)
- project entries (`CPE_PROJECT`)

A includepath container can neither reference further includepath containers or includepath variables.

This method is called by the JavaScript model when it needs to resolve this includepath container entry into a list of library and project entries. The method is typically called exactly once for a given JavaScript project, and the resulting list of entries cached internally by the JavaScript model. 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 JavaScript model, the implementation should use only the following JavaScript model APIs:

- `JavaScriptCore.newLibraryEntry(IPath, IPath, IPath, boolean)` and variants
- `JavaScriptCore.newProjectEntry(IPath, boolean)` and variants
- `JavaScriptCore#create(org.eclipse.core.resources.IWorkspaceRoot)`
- `JavaScriptCore#create(org.eclipse.core.resources.IProject)`
- `IJavaScriptModel.getJavaScriptProjects()`
- `IJavaScriptProject.getRawIncludepath()`
- `IJavaScriptProject.readRawIncludepath()`
- `IJavaScriptProject#getOutputLocation()`
- `IJavaScriptProject#readOutputLocation()`
- JavaScript element operations marked as "handle-only"

The effects of using other JavaScript model APIs are unspecified.

Specified by:
  `getIncludepathEntries` in interface `IJsGlobalScopeContainer`
Overrides:
  `getIncludepathEntries` in class `JsGlobalScopeContainerInitializer`
Returns:
  IIncludePathEntry[] - the includepath entries this container represents
See Also:
  `IIncludePathEntry`

#### canUpdateJsGlobalScopeContainer

    public boolean canUpdateJsGlobalScopeContainer(IPath containerPath,
                                                   IJavaScriptProject project)

Description copied from interface: `IJsGlobalScopeContainerInitializer`
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 `JsGlobalScopeContainerInitializer#requestJsGlobalScopeContainerUpdate`/

Specified by:
  `canUpdateJsGlobalScopeContainer` in interface `IJsGlobalScopeContainerInitializer`
Overrides:
  `canUpdateJsGlobalScopeContainer` in class `JsGlobalScopeContainerInitializer`
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

#### getContainer

    protected IJsGlobalScopeContainer getContainer(IPath containerPath,
                                                   IJavaScriptProject project)

Overrides:
  `getContainer` in class `JsGlobalScopeContainerInitializer`

#### getDescription

    public java.lang.String getDescription()

Description copied from interface: `IJsGlobalScopeContainer`
Answers a readable description of this container

Specified by:
  `getDescription` in interface `IJsGlobalScopeContainer`
Overrides:
  `getDescription` in class `JsGlobalScopeContainerInitializer`
Returns:
  String - a string description of the container

#### getDescription

    public java.lang.String getDescription(IPath containerPath,
                                           IJavaScriptProject project)

Description copied from interface: `IJsGlobalScopeContainerInitializer`
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 `IJsGlobalScopeContainer.getDescription()`).

Specified by:
  `getDescription` in interface `IJsGlobalScopeContainerInitializer`
Overrides:
  `getDescription` in class `JsGlobalScopeContainerInitializer`
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

#### getKind

    public int getKind()

Description copied from interface: `IJsGlobalScopeContainer`
Answers the kind of this container. Can be either:

- `K_APPLICATION` if this container maps to an application library
- `K_SYSTEM` if this container maps to a system library
- `K_DEFAULT_SYSTEM` if this container maps to a default system library (library implicitly contributed by the runtime).

Typically, system containers should be placed first on a build path.

Specified by:
  `getKind` in interface `IJsGlobalScopeContainer`
Overrides:
  `getKind` in class `JsGlobalScopeContainerInitializer`
Returns:
  the kind of this container

#### getPath

    public IPath getPath()

Description copied from interface: `IJsGlobalScopeContainer`
Answers the container path identifying this container. A container path is formed by a first ID segment followed with extra segments, which can be used as additional hints for resolving to this container.

The container ID is also used to identify a`JsGlobalScopeContainerInitializer` registered on the extension point "org.eclipse.wst.jsdt.core.JsGlobalScopeContainerInitializer", which can be invoked if needing to resolve the container before it is explicitly set.

Specified by:
  `getPath` in interface `IJsGlobalScopeContainer`
Overrides:
  `getPath` in class `JsGlobalScopeContainerInitializer`
Returns:
  IPath - the container path that is associated with this container

#### initialize

    public void initialize(IPath containerPath,
                           IJavaScriptProject project)
                    throws CoreException

Description copied from interface: `IJsGlobalScopeContainerInitializer`
Binds a includepath container to a `IJsGlobalScopeContainer` 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 `JavaScriptCore#setJsGlobalScopeContainer`.

A container initialization can be indirectly performed while attempting to resolve a project includepath using `IJavaScriptProject#getResolvedClasspath(`; or directly when using `JavaScriptCore#getJsGlobalScopeContainer`. 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 includepath, as the operation needs to resolve the includepath 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 includepath, it will not see the new assigned includepath until the operation has completed. Note that once the JavaScript change notification occurs (at the end of the operation), the model has been updated, and the project includepath can be queried normally.

This method is called by the JavaScript model to give the party that defined this particular kind of includepath container the chance to install includepath container objects that will be used to convert includepath container entries into simpler includepath entries. The method is typically called exactly once for a given JavaScript project and includepath 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 JavaScript model, the implementation should use only the following JavaScript model APIs:

- `JavaScriptCore#setJsGlobalScopeContainer(IPath, IJavaScriptProject[], IJsGlobalScopeContainer[], org.eclipse.core.runtime.IProgressMonitor)`
- `JavaScriptCore.getJsGlobalScopeContainer(IPath, IJavaScriptProject)`
- `JavaScriptCore#create(org.eclipse.core.resources.IWorkspaceRoot)`
- `JavaScriptCore#create(org.eclipse.core.resources.IProject)`
- `IJavaScriptModel.getJavaScriptProjects()`
- JavaScript element operations marked as "handle-only"

The effects of using other JavaScript model APIs are unspecified.

Specified by:
  `initialize` in interface `IJsGlobalScopeContainerInitializer`
Overrides:
  `initialize` in class `JsGlobalScopeContainerInitializer`
Parameters:
  `containerPath` - a two-segment path (ID/hint) identifying the container that needs to be resolved
  `project` - the JavaScript 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:
  `JavaScriptCore.getJsGlobalScopeContainer(IPath, IJavaScriptProject)`, `JavaScriptCore#setJsGlobalScopeContainer(IPath, IJavaScriptProject[], IJsGlobalScopeContainer[], org.eclipse.core.runtime.IProgressMonitor)`, `IJsGlobalScopeContainer`

#### containerSuperTypes

    public java.lang.String[] containerSuperTypes()

Description copied from interface: `IJsGlobalScopeContainerInitializer`
returns a String of all SuperTypes provided by this library.

Specified by:
  `containerSuperTypes` in interface `IJsGlobalScopeContainerInitializer`
Overrides:
  `containerSuperTypes` in class `JsGlobalScopeContainerInitializer`

#### getInferenceID

    public java.lang.String getInferenceID()

Description copied from interface: `IJsGlobalScopeContainerInitializer`
Get the id of the inference provider for this library

Specified by:
  `getInferenceID` in interface `IJsGlobalScopeContainerInitializer`
Overrides:
  `getInferenceID` in class `JsGlobalScopeContainerInitializer`
Returns:
  inference provider id