org.eclipse.core.runtime.IPluginPrerequisite Maven / Gradle / Ivy
The newest version!
/*******************************************************************************
* Copyright (c) 2000, 2008 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.core.runtime;
import org.eclipse.osgi.service.resolver.State;
import org.eclipse.osgi.util.ManifestElement;
import org.osgi.framework.Constants;
/**
* A prerequisite entry declared by a plug-in. The declaration causes
* classes defined by the prerequisite plug-in to be visible
* to the plug-in that declared the dependency.
*
* @see IPluginDescriptor#getPluginPrerequisites()
* @deprecated
* In Eclipse 3.0 the plug-in prerequisite representation was changed. Clients of
* IPluginPrerequisite are directed to the headers associated with the relevant bundle.
* In particular, the Require-Bundle header contains all available information
* about the prerequisites of a plug-in. Having retrieved the header, the {@link ManifestElement}
* helper class can be used to parse the value and discover the individual
* prerequisite plug-ins. The various header attributes are defined in {@link Constants}.
* For example,
*
String header = bundle.getHeaders().get(Constants.REQUIRE_BUNDLE);
* ManifestElement[] elements = ManifestElement.parseHeader(
* Constants.REQUIRE_BUNDLE, header);
* if (elements == null)
* return;
* elements[0].getValue(); // the prerequisite plug-in id
* elements[0].getAttribute(Constants.BUNDLE_VERSION_ATTRIBUTE); // the prerequisite plug-in version
* ...
*
*
* See {@link IPluginDescriptor} for information on the relationship between plug-in
* descriptors and bundles.
*
* This interface must only be used by plug-ins
* which explicitly require the org.eclipse.core.runtime.compatibility plug-in.
*
*
* @noimplement This interface is not intended to be implemented by clients.
*/
public interface IPluginPrerequisite {
/**
* Returns the actual version identifier that is used
* at runtime to resolve this prerequisite dependency,
* or null, if the dependency is not resolved.
*
* @return the plug-in version identifier, or null
* @deprecated Callers of this method should interrogate the current {@link State}
* of the platform. For example,
*
* State state = Platform.getPlatformAdmin().getState();
* BundleDescription bundle = state.getBundle("my plug-in id", my plug-in version);
* BundleSpecification spec = bundle.getRequiredBundle("required plug-in id");
* BundleDescription prereq = spec.getSupplier();
*
*/
public PluginVersionIdentifier getResolvedVersionIdentifier();
/**
* Returns the plug-in identifier of the prerequisite plug-in.
*
* @return the plug-in identifier
* @deprecated Given a manifest element equivalent of a plug-in
* prerequisite (see the class comment), this method is replaced by:
*
* element.getValue();
*
*/
public String getUniqueIdentifier();
/**
* Returns the version identifier of the prerequisite plug-in,
* or null if none.
*
* @return the plug-in version identifier, or null if
* none was specified
* @deprecated Callers of this method should interrogate the current {@link State}
* of the platform. For example,
*
* State state = Platform.getPlatformAdmin().getState();
* BundleDescription bundle = state.getBundle("my plug-in id", my plug-in version);
* BundleSpecification spec = bundle.getRequiredBundle("required plug-in id");
* Version reqMinVersion = spec.getVersionRange().getMinimum();
*
*/
public PluginVersionIdentifier getVersionIdentifier();
/**
* Indicates whether this prerequisite plug-in is further exposed to any
* plug-ins that declare a dependency on this plug-in. This allows
* for chaining of dependencies. For example, if plug-in A depends
* on plug-in B which depends on plug-in C, the classes from C
* are typically visible to B, but not to A. A can get around this
* if either B explicitly exports its dependency on C, or
* A explicitly declares C as a prerequisite in addition to B.
*
* @return true if this prerequisite plug-in is exposed,
* false otherwise
* @deprecated Given a manifest element equivalent of a plug-in
* prerequisite (see the class comment), this method is replaced by:
*
* element.getAttribute(Constants.REPROVIDE_ATTRIBUTE);
*
*/
public boolean isExported();
/**
* Indicates that this plug-in prerequisite can be resolved
* against a configured plug-in with an identifier that is
* greater than or equal to it.
*
* @return true if greater or equal match is allowed,
* false otherwise.
* @since 2.0
* @deprecated Callers of this method should interrogate the current {@link State}
* of the platform. For example,
*
* State state = Platform.getPlatformAdmin().getState();
* BundleDescription bundle = state.getBundle("my plug-in id", my plug-in version);
* BundleSpecification spec = bundle.getRequiredBundle("required plug-in id");
* VersionRange versionRange = spec.getVersionRange();
* if (versionRange == null || versionRange.getMinimum() == null)
* return false;
* Version minimum = versionRange.getMinimum();
* Version maximum = versionRange.getMaximum() == null ? Version.maxVersion : versionRange.getMaximum();
* if (maximum.equals(Version.maxVersion))
* return true;
* return false;
*
*/
public boolean isMatchedAsGreaterOrEqual();
/**
* Indicates that this plug-in prerequisite can be resolved
* against a configured plug-in with a compatible identifier.
*
* @return true if compatible match is allowed,
* false if exact match is required.
* @deprecated Callers of this method should interrogate the current {@link State}
* of the platform. For example,
*
* State state = Platform.getPlatformAdmin().getState();
* BundleDescription bundle = state.getBundle("my plug-in id", my plug-in version);
* BundleSpecification spec = bundle.getRequiredBundle("required plug-in id");
* VersionRange versionRange = spec.getVersionRange();
* if (versionRange == null || versionRange.getMinimum() == null)
* return false;
* Version minimum = versionRange.getMinimum();
* Version maximum = versionRange.getMaximum() == null ? Version.maxVersion : versionRange.getMaximum();
* if (!minimum.isInclusive() || maximum.isInclusive())
* return false;
* else if (minimum.getMajorComponent() == maximum.getMajorComponent() - 1)
* return true;
* return false;
*
*/
public boolean isMatchedAsCompatible();
/**
* Indicates that this plug-in prerequisite can only be resolved
* against a configured plug-in with an equivalent plug-in
* identifier.
*
* @return true if only equivalent identifier match
* satisfies this dependency, false otherwise.
* @since 2.0
* @deprecated Callers of this method should interrogate the current {@link State}
* of the platform. For example,
*
* State state = Platform.getPlatformAdmin().getState();
* BundleDescription bundle = state.getBundle("my plug-in id", my plug-in version);
* BundleSpecification spec = bundle.getRequiredBundle("required plug-in id");
* VersionRange versionRange = spec.getVersionRange();
* if (versionRange == null || versionRange.getMinimum() == null)
* return false;
* Version minimum = versionRange.getMinimum();
* Version maximum = versionRange.getMaximum() == null ? Version.maxVersion : versionRange.getMaximum();
* if (!minimum.isInclusive() || maximum.isInclusive())
* return false;
* else if (minimum.getMajorComponent() == maximum.getMajorComponent() - 1)
* return false;
* else if (minimum.getMajorComponent() != maximum.getMajorComponent())
* return false;
* else if (minimum.getMinorComponent() == maximum.getMinorComponent() - 1)
* return true;
* return false;
*
*/
public boolean isMatchedAsEquivalent();
/**
* Indicates that this plug-in prerequisite can only be resolved
* against a configured plug-in with a plug-in identifier that
* is perfectly equal.
*
* @return true if only perfectly equal
* identifier match satisfies this dependency,
* false otherwise.
* @since 2.0
* @deprecated Callers of this method should interrogate the current {@link State}
* of the platform. For example,
*
* State state = Platform.getPlatformAdmin().getState();
* BundleDescription bundle = state.getBundle("my plug-in id", my plug-in version);
* BundleSpecification spec = bundle.getRequiredBundle("required plug-in id");
* VersionRange versionRange = spec.getVersionRange();
* if (versionRange == null || versionRange.getMinimum() == null)
* return false;
* Version minimum = versionRange.getMinimum();
* Version maximum = versionRange.getMaximum() == null ? Version.maxVersion : versionRange.getMaximum();
* if (minimum.equals(maximum))
* return true;
* return false;
*
*/
public boolean isMatchedAsPerfect();
/**
* Indicates that this plug-in prerequisite can only be resolved
* against a configured plug-in with exactly the same plug-in
* identifier.
*
* @return true if only exact identifier match
* satisfies this dependency, false if compatible
* plug-in will satisfy this dependency.
* @deprecated Callers of this method should interrogate the current {@link State}
* of the platform. For example,
*
* State state = Platform.getPlatformAdmin().getState();
* BundleDescription bundle = state.getBundle("my plug-in id", my plug-in version);
* BundleSpecification spec = bundle.getRequiredBundle("required plug-in id");
* VersionRange versionRange = spec.getVersionRange();
* if (versionRange == null || versionRange.getMinimum() == null)
* return false;
* Version minimum = versionRange.getMinimum();
* Version maximum = versionRange.getMaximum() == null ? Version.maxVersion : versionRange.getMaximum();
* if (!minimum.isInclusive() || maximum.isInclusive())
* return false;
* else if (minimum.getMajorComponent() == maximum.getMajorComponent() - 1)
* return false;
* else if (minimum.getMajorComponent() != maximum.getMajorComponent())
* return false;
* else if (minimum.getMinorComponent() == maximum.getMinorComponent() - 1)
* return true;
* return false;
*
*/
public boolean isMatchedAsExact();
/**
* Indicates whether this plug-in prerequisite is optional. If a required (i.e., non-optional)
* prerequisite is missing, this plugin is disabled.
*
* @return true if this prerequisite is optional, false otherwise
* @deprecated Given a manifest element equivalent of a plug-in
* prerequisite (see the class comment), this method is replaced by:
*
* "true".equals(element.getAttribute(Constants.OPTIONAL_ATTRIBUTE);
*
*/
public boolean isOptional();
}