| package org.eclipse.scout.sdk.util.pde; |
| |
| import java.util.Iterator; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Map.Entry; |
| import java.util.Vector; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.jdt.core.IPackageFragment; |
| import org.eclipse.osgi.service.resolver.ExportPackageDescription; |
| import org.eclipse.osgi.service.resolver.ImportPackageSpecification; |
| import org.eclipse.pde.core.build.IBuildEntry; |
| import org.eclipse.pde.core.plugin.IPluginAttribute; |
| import org.eclipse.pde.core.plugin.IPluginElement; |
| import org.eclipse.pde.core.plugin.IPluginExtension; |
| import org.eclipse.pde.core.plugin.IPluginImport; |
| import org.eclipse.pde.core.plugin.IPluginModelBase; |
| import org.eclipse.pde.core.plugin.IPluginObject; |
| import org.eclipse.pde.core.plugin.PluginRegistry; |
| import org.eclipse.pde.internal.core.ICoreConstants; |
| import org.eclipse.pde.internal.core.bundle.BundlePluginBase; |
| import org.eclipse.pde.internal.core.bundle.BundlePluginModelBase; |
| import org.eclipse.pde.internal.core.ibundle.IBundlePlugin; |
| import org.eclipse.pde.internal.core.ibundle.IManifestHeader; |
| import org.eclipse.pde.internal.core.text.bundle.BundleClasspathHeader; |
| import org.eclipse.pde.internal.core.text.bundle.ExportPackageHeader; |
| import org.eclipse.pde.internal.core.text.bundle.ImportPackageHeader; |
| import org.eclipse.pde.internal.core.text.bundle.ImportPackageObject; |
| import org.eclipse.pde.internal.core.text.bundle.RequireBundleHeader; |
| import org.eclipse.scout.commons.CompareUtility; |
| import org.osgi.framework.Constants; |
| import org.osgi.framework.Version; |
| |
| /** |
| * Helper class for basic plug-in model operations. |
| * |
| * @author Matthias Villiger |
| * @since 3.8.0 |
| */ |
| @SuppressWarnings("restriction") |
| public class PluginModelHelper { |
| |
| /** |
| * Class for operations executed on the MANIFEST.MF part of a plug-in model. |
| */ |
| public final ManifestPart Manifest; |
| |
| /** |
| * Class for operations executed on the plugin.xml part of a plug-in model. |
| */ |
| public final PluginXmlPart PluginXml; |
| |
| /** |
| * Class for operations executed on the build.properties part of a plug-in model. |
| */ |
| public final BuildPropertiesPart BuildProperties; |
| |
| /** |
| * Creates a new helper that operates on the project with the same name as denoted by the given model base.<br> |
| * <br> |
| * If there is no project in the workspace with the given name, it is searched in the plug-in registry. Then the |
| * resulting instance cannot be modified. |
| * |
| * @param pluginModelBase |
| * The model base that defines the project name. |
| * @throws IllegalArgumentException |
| * when no project with the same name as denoted by the given model description can be found in the |
| * workspace or is not a valid plug-in project. |
| */ |
| public PluginModelHelper(IPluginModelBase pluginModelBase) { |
| this(createPluginModel(pluginModelBase.getBundleDescription().getName())); |
| } |
| |
| /** |
| * Creates a new helper that operates on the plug-in with the given name.<br> |
| * <br> |
| * If there is no project in the workspace with the given name, it is searched in the plug-in registry. Then the |
| * resulting instance cannot be modified. |
| * |
| * @param projectName |
| * The name of the project. |
| * @throws IllegalArgumentException |
| * when no project with the given name can be found in the workspace or is not a valid plugin project. |
| */ |
| public PluginModelHelper(String projectName) { |
| this(createPluginModel(projectName)); |
| } |
| |
| private static LazyPluginModel createPluginModel(String projectName) { |
| IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName); |
| if (project != null && project.isAccessible()) { |
| return new LazyPluginModel(project); |
| } |
| |
| IPluginModelBase model = PluginRegistry.findModel(projectName); |
| return new LazyPluginModel(model); |
| } |
| |
| /** |
| * Creates a new helper that operates on the given project. |
| * |
| * @param project |
| * The project to modify. |
| * @throws IllegalArgumentException |
| * when the project is null or is not a valid plug-in project. |
| */ |
| public PluginModelHelper(IProject project) { |
| this(new LazyPluginModel(project)); |
| } |
| |
| private PluginModelHelper(LazyPluginModel model) { |
| Manifest = new ManifestPart(model); |
| PluginXml = new PluginXmlPart(model); |
| BuildProperties = new BuildPropertiesPart(model); |
| } |
| |
| /** |
| * Gets the project associated with this helper. |
| * |
| * @return The project this helper was created with. |
| */ |
| public IProject getProject() { |
| return Manifest.m_model.getProject(); |
| } |
| |
| private static String getProjectRelativeResourcePath(IResource r) { |
| if (r == null) return null; |
| String entry = r.getProjectRelativePath().toString(); |
| if (r.getType() == IResource.FOLDER) { |
| if (!entry.endsWith("/")) { |
| entry = entry + "/"; |
| } |
| } |
| return entry; |
| } |
| |
| public static class ManifestPart { |
| |
| private final LazyPluginModel m_model; |
| |
| private ManifestPart(LazyPluginModel m) { |
| m_model = m; |
| } |
| |
| /** |
| * Adds the given plugin to the dependencies of the project associated with this helper.<br> |
| * The dependency is not re-exported and marked as non-optional.<br> |
| * If a dependency for the given plugin already exists (even if the existing dependency has different options), this |
| * method does nothing.<br> |
| * This method is thread safe. |
| * |
| * @param pluginId |
| * The plugin ID |
| * @throws CoreException |
| */ |
| public void addDependency(String pluginId) throws CoreException { |
| addDependency(pluginId, false); |
| } |
| |
| /** |
| * Adds the given plugin to the dependencies of the project associated with this helper.<br> |
| * The dependency is marked as non-optional.<br> |
| * If a dependency for the given plugin already exists (even if the existing dependency has different options), this |
| * method does nothing.<br> |
| * This method is thread safe. |
| * |
| * @param pluginId |
| * The plugin ID |
| * @param reexport |
| * If the dependency should be re-exported. |
| * @throws CoreException |
| */ |
| public void addDependency(String pluginId, boolean reexport) throws CoreException { |
| addDependency(pluginId, reexport, false); |
| } |
| |
| /** |
| * Adds the given plugin to the dependencies of the project associated with this helper.<br> |
| * If the given plugin is null, empty or a dependency for the given plugin already exists |
| * (even if the existing dependency has different options), this method does nothing.<br> |
| * This method is thread safe. |
| * |
| * @param pluginId |
| * The plugin ID |
| * @param reexport |
| * If the dependency should be re-exported. |
| * @param optional |
| * If the dependency should be optional |
| * @return the new created import for the given pluginId if it did not exist or the already existing import. |
| * @throws CoreException |
| */ |
| public void addDependency(String pluginId, boolean reexport, boolean optional) throws CoreException { |
| if (pluginId == null || pluginId.length() < 1) return; |
| synchronized (m_model.getProject()) { |
| if (!existsDependency(pluginId)) { |
| IPluginModelBase pluginModelBase = m_model.getBundlePluginModel(); |
| if (pluginModelBase instanceof BundlePluginModelBase) { |
| IPluginImport imp = ((BundlePluginModelBase) pluginModelBase).createImport(pluginId); |
| imp.setReexported(reexport); |
| imp.setOptional(optional); |
| m_model.getPluginBase().add(imp); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Removes the given plugin from the dependency list of the project associated with this helper.<br> |
| * |
| * @param pluginId |
| * The plugin id to remove. |
| * @throws CoreException |
| */ |
| public void removeDependency(String pluginId) throws CoreException { |
| synchronized (m_model.getProject()) { |
| IPluginImport existing = getDependency(pluginId); |
| if (existing != null) { |
| m_model.getPluginBase().remove(existing); |
| |
| RequireBundleHeader reqHeader = getRequireBundleHeader(); |
| reqHeader.removeBundle(pluginId); |
| setEntryValue(Constants.REQUIRE_BUNDLE, reqHeader.getValue()); |
| } |
| } |
| } |
| |
| private String getHeaderValue(IManifestHeader header) { |
| if (header == null || header.getValue() == null) { |
| return ""; |
| } |
| else { |
| return header.getValue(); |
| } |
| } |
| |
| private RequireBundleHeader getRequireBundleHeader() { |
| IManifestHeader header = m_model.getBundle().getManifestHeader(Constants.REQUIRE_BUNDLE); |
| return (RequireBundleHeader) m_model.getBundleModel().getFactory().createHeader(Constants.REQUIRE_BUNDLE, getHeaderValue(header)); |
| } |
| |
| /** |
| * Checks whether the given plugin id is already in the dependency list of the project associated with this helper. |
| * |
| * @param pluginId |
| * The plugin id to check |
| * @return true if the given plugin is already in the dependency list, false otherwise. |
| */ |
| public boolean existsDependency(String pluginId) { |
| IPluginImport existing = getDependency(pluginId); |
| return existing != null; |
| } |
| |
| /** |
| * Returns all dependencies defined in the plug-in project associated with this helper. |
| * |
| * @return an array of import objects |
| */ |
| public IPluginImport[] getAllDependencies() { |
| return m_model.getPluginBase().getImports(); |
| } |
| |
| private IPluginImport getDependency(String pluginId) { |
| if (pluginId == null || pluginId.length() < 1) return null; |
| for (IPluginImport existing : m_model.getPluginBase().getImports()) { |
| if (existing.getId().equals(pluginId)) { |
| return existing; |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Checks whether the given package is already exported. |
| * |
| * @param pck |
| * The package name to check. |
| * @return true, if the given package is exported, false otherwise. |
| */ |
| public boolean existsExportPackage(IPackageFragment pck) { |
| if (pck == null) return false; |
| return existsExportPackage(pck.getElementName()); |
| } |
| |
| /** |
| * Checks whether the given package name is already exported. |
| * |
| * @param packageName |
| * The package name to check. |
| * @return true, if the given package is exported, false otherwise. |
| */ |
| public boolean existsExportPackage(String packageName) { |
| if (packageName == null || packageName.length() < 1) return false; |
| ExportPackageDescription[] exportPackages = m_model.getBundleDescription().getExportPackages(); |
| for (ExportPackageDescription epd : exportPackages) { |
| if (packageName.equals(epd.getName())) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Gets all exported packages defined in the plug-in project associated with this helper. |
| * |
| * @return an array of all exported packages (is never null). |
| */ |
| public ExportPackageDescription[] getAllExportedPackages() { |
| return m_model.getBundleDescription().getExportPackages(); |
| } |
| |
| /** |
| * Checks whether the given package name is already imported.<br> |
| * Any version constraints are ignored when checking if the import exists. |
| * |
| * @param packageName |
| * The package name to check. |
| * @return true, if the given package is exported, false otherwise. |
| */ |
| public boolean existsImportPackage(String packageName) { |
| if (packageName == null || packageName.length() < 1) return false; |
| ImportPackageSpecification[] importedPackages = m_model.getBundleDescription().getImportPackages(); |
| for (ImportPackageSpecification ips : importedPackages) { |
| if (packageName.equals(ips.getName())) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Gets all imported packages defined in the plug-in project associated with this helper. |
| * |
| * @return an array of all imported packages (is never null). |
| */ |
| public ImportPackageSpecification[] getAllImportedPackages() { |
| return m_model.getBundleDescription().getImportPackages(); |
| } |
| |
| /** |
| * Adds the given fully qualified package to the imported packages of the bundle associated with this helper.<br> |
| * If an import for the given package already exists, this method does nothing (only the package name is |
| * considered). |
| * |
| * @param pck |
| * The package. E.g.: org.eclipse.scout.rt.client |
| * @param version |
| * The version constraint for the given import package. E.g.: [1.1.0,2.0.0) |
| */ |
| public void addImportPackage(String pck, String version) { |
| if (pck == null || pck.length() < 1) return; |
| synchronized (m_model.getProject()) { |
| if (!existsImportPackage(pck)) { |
| ImportPackageHeader impHeader = getImportPackageHeader(); |
| ImportPackageObject obj = new ImportPackageObject(impHeader, pck, version, getVersionAttribute()); |
| impHeader.addPackage(obj); |
| setEntryValue(Constants.IMPORT_PACKAGE, impHeader.getValue()); |
| } |
| } |
| } |
| |
| private String getVersionAttribute() { |
| int manifestVersion = BundlePluginBase.getBundleManifestVersion(m_model.getBundle()); |
| return (manifestVersion < 2) ? ICoreConstants.PACKAGE_SPECIFICATION_VERSION : Constants.VERSION_ATTRIBUTE; |
| } |
| |
| /** |
| * Adds the given package to the exported packages of the project associated with this helper.<br> |
| * If the given package is null, empty or already in the exported list, this method does nothing.<br> |
| * This method is thread safe. |
| * |
| * @param packageName |
| * The fully qualified name of the package. |
| */ |
| public void addExportPackage(String packageName) { |
| if (packageName == null || packageName.length() < 1) return; |
| synchronized (m_model.getProject()) { |
| if (!existsExportPackage(packageName)) { |
| ExportPackageHeader expHeader = getExportPackageHeader(); |
| expHeader.addPackage(packageName); |
| setEntryValue(Constants.EXPORT_PACKAGE, expHeader.getValue()); |
| } |
| } |
| } |
| |
| /** |
| * Adds the given package to the exported packages of the project associated with this helper.<br> |
| * If the given package is already in the exported list, this method does nothing. |
| * |
| * @param pck |
| * The package to add |
| */ |
| public void addExportPackage(IPackageFragment pck) { |
| addExportPackage(pck.getElementName()); |
| } |
| |
| /** |
| * Removes the given package from the exported packages list of the project associated with this helper.<br> |
| * This method does nothing if the give package is null. |
| * |
| * @param pck |
| * The package to remove |
| */ |
| public void removeExportPackage(IPackageFragment pck) { |
| if (pck == null) return; |
| removeExportPackage(pck.getElementName()); |
| } |
| |
| /** |
| * Removes the given package from the exported packages list of the project associated with this helper.<br> |
| * This method does nothing if the give package is null or empty. |
| * |
| * @param packageName |
| * The fully qualified name of the package |
| */ |
| public void removeExportPackage(String packageName) { |
| if (packageName == null || packageName.length() < 1) return; |
| ExportPackageHeader expHeader = getExportPackageHeader(); |
| expHeader.removePackage(packageName); |
| setEntryValue(Constants.EXPORT_PACKAGE, expHeader.getValue()); |
| } |
| |
| /** |
| * Removes the given package from the imported packages list of the project associated with this helper.<br> |
| * This method does nothing if the give package is null or empty. |
| * |
| * @param packageName |
| * The fully qualified name of the package |
| */ |
| public void removeImportPackage(String packageName) { |
| if (packageName == null || packageName.length() < 1) return; |
| ImportPackageHeader impHeader = getImportPackageHeader(); |
| impHeader.removePackage(packageName); |
| setEntryValue(Constants.IMPORT_PACKAGE, impHeader.getValue()); |
| } |
| |
| private ExportPackageHeader getExportPackageHeader() { |
| IManifestHeader header = m_model.getBundle().getManifestHeader(Constants.EXPORT_PACKAGE); |
| return (ExportPackageHeader) m_model.getBundleModel().getFactory().createHeader(Constants.EXPORT_PACKAGE, getHeaderValue(header)); |
| } |
| |
| private ImportPackageHeader getImportPackageHeader() { |
| IManifestHeader header = m_model.getBundle().getManifestHeader(Constants.IMPORT_PACKAGE); |
| return (ImportPackageHeader) m_model.getBundleModel().getFactory().createHeader(Constants.IMPORT_PACKAGE, getHeaderValue(header)); |
| } |
| |
| private BundleClasspathHeader getBundleClasspathHeader() { |
| IManifestHeader header = m_model.getBundle().getManifestHeader(Constants.BUNDLE_CLASSPATH); |
| return (BundleClasspathHeader) m_model.getBundleModel().getFactory().createHeader(Constants.BUNDLE_CLASSPATH, getHeaderValue(header)); |
| } |
| |
| /** |
| * Creates or updates the given manifest header key to the given value.<br> |
| * This method does nothing if the given key is null or empty. |
| * |
| * @param key |
| * The key. Will be created if it does not exist. |
| * @param value |
| * The value that should be set for the given key. if value is null, the key is removed from the manifest. |
| */ |
| public void setEntryValue(String key, String value) { |
| if (key == null || key.length() < 1) return; |
| m_model.getBundle().setHeader(key, value); |
| } |
| |
| /** |
| * Removes the given key from the manifest.<br> |
| * This method does nothing if the given key is null or empty. |
| * |
| * @param key |
| * The key to remove. |
| */ |
| public void removeEntry(String key) { |
| setEntryValue(key, null); |
| } |
| |
| /** |
| * Gets the value of the given manifest header key. |
| * |
| * @param key |
| * The property name. |
| * @return The value (or null if it does not exist) of the given key. |
| */ |
| public String getEntry(String key) { |
| return m_model.getBundle().getHeader(key); |
| } |
| |
| /** |
| * Gets all classpath entries of the project associated with this helper. |
| * |
| * @return an array with all entries. |
| */ |
| @SuppressWarnings("unchecked") |
| public String[] getAllClasspathEntries() { |
| BundleClasspathHeader h = getBundleClasspathHeader(); |
| Vector<String> names = h.getElementNames(); |
| return names.toArray(new String[names.size()]); |
| } |
| |
| /** |
| * Removes the given entry from the classpath.<br> |
| * If a null resource is passed, this method does nothing. |
| * |
| * @param resource |
| * The entry to remove. |
| */ |
| public void removeClasspathEntry(IResource resource) { |
| if (resource == null) return; |
| removeClasspathEntry(getProjectRelativeResourcePath(resource)); |
| } |
| |
| /** |
| * Removes the given entry from the classpath.<br> |
| * If a null entry or empty entry is passed, this method does nothing. |
| * |
| * @param entry |
| * The entry to remove. |
| */ |
| public void removeClasspathEntry(String entry) { |
| if (entry == null || entry.length() < 1) return; |
| |
| BundleClasspathHeader h = getBundleClasspathHeader(); |
| h.removeLibrary(entry); |
| setEntryValue(Constants.BUNDLE_CLASSPATH, h.getValue()); |
| } |
| |
| /** |
| * Adds the default classpath entry (".") to the classpath list.<br> |
| * If the default entry does already exist, this method does nothing. |
| */ |
| public void addClasspathDefaultEntry() { |
| addClasspathEntry("."); |
| } |
| |
| /** |
| * Checks whether the given entry is already in the classpath entries of the project associated with this helper. |
| * |
| * @param resource |
| * The entry to search |
| * @return false if the resource is null or does not exist, true otherwise. |
| */ |
| public boolean existsClasspathEntry(IResource resource) { |
| if (resource == null) return false; |
| return existsClasspathEntry(getProjectRelativeResourcePath(resource)); |
| } |
| |
| /** |
| * Checks whether the given entry is already in the classpath entries of the project associated with this helper. |
| * |
| * @param entry |
| * The entry to search. |
| * @return true if the given entry already exists, false otherwise. |
| */ |
| public boolean existsClasspathEntry(String entry) { |
| if (entry == null || entry.length() < 1) return false; |
| for (String e : getAllClasspathEntries()) { |
| if (e.equals(entry)) return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Adds the given classpath entry to the classpath of the project associated with this helper.<br> |
| * If the resource is null, does not exist in the project or is already in the classpath, this method does nothing.<br> |
| * This method is thread safe. |
| * |
| * @param resource |
| * The classpath entry to add. |
| */ |
| public void addClasspathEntry(IResource resource) { |
| if (resource == null) return; |
| if (!resource.exists()) return; |
| addClasspathEntry(getProjectRelativeResourcePath(resource)); |
| } |
| |
| /** |
| * Adds the given classpath entry to the classpath of the project associated with this helper.<br> |
| * If the given entry is null, an empty string or already exists in the classpath, this method does nothing.<br> |
| * This method is thread safe. |
| * |
| * @param entry |
| * The classpath entry to add. |
| */ |
| public void addClasspathEntry(String entry) { |
| if (entry == null || entry.length() < 1) return; |
| synchronized (m_model.getProject()) { |
| if (!existsClasspathEntry(entry)) { |
| BundleClasspathHeader h = getBundleClasspathHeader(); |
| h.addLibrary(entry); |
| setEntryValue(Constants.BUNDLE_CLASSPATH, h.getValue()); |
| } |
| } |
| } |
| |
| /** |
| * Sets the version of the plug-in to the given value.<br> |
| * If the given value is null, this method does nothing. |
| * |
| * @param newVersion |
| * the new version |
| */ |
| public void setVersion(Version newVersion) { |
| if (newVersion == null) return; |
| setVersion(newVersion.toString()); |
| } |
| |
| /** |
| * Sets the version of the plug-in to the given value.<br> |
| * If the given value is empty or null, this method does nothing. |
| * |
| * @param newVersion |
| * the new version |
| */ |
| public void setVersion(String newVersion) { |
| if (newVersion == null || newVersion.length() < 1) return; |
| setEntryValue(Constants.BUNDLE_VERSION, newVersion); |
| } |
| |
| /** |
| * Gets the version of the plug-in. |
| * |
| * @return The version of this plug-in. |
| */ |
| public Version getVersion() { |
| return m_model.getBundleDescription().getVersion(); |
| } |
| |
| /** |
| * Gets the version of the plug-in. |
| * |
| * @return The version of the plug-in. |
| */ |
| public String getVersionAsString() { |
| return m_model.getBundleDescription().getVersion().toString(); |
| } |
| |
| /** |
| * Gets the MANIFEST.MF file of the plug-in. |
| * |
| * @return |
| */ |
| public IFile getFile() { |
| return m_model.getManifestFile(); |
| } |
| } |
| |
| /** |
| * saves all changes of all underlying models that require saving. |
| */ |
| public void save() { |
| // same lazy model instance for all parts -> does not matter which one is saved. |
| Manifest.m_model.save(); |
| } |
| |
| public static class PluginXmlPart { |
| private final LazyPluginModel m_model; |
| |
| private PluginXmlPart(LazyPluginModel m) { |
| m_model = m; |
| } |
| |
| /** |
| * Adds a simple extension to the project associated with this helper.<br> |
| * If exactly the same extension already exists, it is added another time.<br> |
| * A simple extension is of the following format:<br> |
| * <code> |
| * <extension point="extensionPointId"><br> |
| * <elementName attribute1="value1" attribute2="value2"></elementName><br> |
| * </extension><br> |
| * </code> |
| * |
| * @param extensionPointId |
| * The full id of the extension point for which the extension should be added. |
| * @param elementName |
| * The tag name of the extension. |
| * @param attributes |
| * The attribute (name-value-pairs) that should be added to the element. |
| * @throws CoreException |
| */ |
| public void addSimpleExtension(String extensionPointId, String elementName, Map<String, String> attributes) throws CoreException { |
| IPluginExtension pe = null; |
| // find existing extension |
| for (IPluginExtension existing : m_model.getExtensionsModel().getExtensions().getExtensions()) { |
| if (existing.getPoint().equals(extensionPointId)) { |
| pe = existing; |
| break; |
| } |
| } |
| if (pe == null) { |
| // no extension for given extension point exists: create new |
| pe = m_model.getExtensionsModel().createExtension(); |
| pe.setPoint(extensionPointId); |
| m_model.getExtensionsModel().getExtensions().add(pe); |
| } |
| |
| IPluginElement extension = m_model.getExtensionsModel().createElement(pe); |
| extension.setName(elementName); |
| if (attributes != null && attributes.size() > 0) { |
| for (Map.Entry<String, String> entry : attributes.entrySet()) { |
| extension.setAttribute(entry.getKey(), entry.getValue()); |
| } |
| } |
| pe.add(extension); |
| } |
| |
| /** |
| * Adds a simple extension to the project associated with this helper.<br> |
| * If exactly the same extension already exists, it is added another time.<br> |
| * A simple extension is of the following format:<br> |
| * <code> |
| * <extension point="extensionPointId"><br> |
| * <elementName></elementName><br> |
| * </extension><br> |
| * </code> |
| * |
| * @param extensionPointId |
| * The full id of the extension point for which the extension should be added. |
| * @param elementName |
| * The tag name of the extension. |
| * @throws CoreException |
| */ |
| public void addSimpleExtension(String extensionPointId, String elementName) throws CoreException { |
| addSimpleExtension(extensionPointId, elementName, null); |
| } |
| |
| /** |
| * Removes the simple extension from this plugin. An existing extension must match in <code>extensionPointId</code>, |
| * <code>elementName</code> and all <code>attributes</code> given.<br> |
| * A simple extension is of the following format:<br> |
| * <code> |
| * <extension point="extensionPointId"><br> |
| * <elementName attribute1="value1" attribute2="value2"></elementName><br> |
| * </extension><br> |
| * </code> |
| * |
| * @param extensionPointId |
| * The full extension point id. |
| * @param elementName |
| * the tag name |
| * @param attributes |
| * key-value-pairs of the attributes. |
| * @throws CoreException |
| */ |
| public void removeSimpleExtension(String extensionPointId, String elementName, Map<String, String> attributes) throws CoreException { |
| IPluginElement[] toDeleteList = getSimpleExtensions(extensionPointId, elementName, attributes); |
| for (IPluginElement toDelete : toDeleteList) { |
| if (toDelete.getParent() instanceof IPluginExtension) { |
| ((IPluginExtension) toDelete.getParent()).remove(toDelete); |
| } |
| } |
| } |
| |
| /** |
| * Removes the simple extension from this plugin. An existing extension must match in <code>extensionPointId</code> |
| * and <code>elementName</code>.<br> |
| * A simple extension is of the following format:<br> |
| * <code> |
| * <extension point="extensionPointId"><br> |
| * <elementName></elementName><br> |
| * </extension><br> |
| * </code> |
| * |
| * @param extensionPointId |
| * The full extension point id. |
| * @param elementName |
| * @throws CoreException |
| */ |
| public void removeSimpleExtension(String extensionPointId, String elementName) throws CoreException { |
| removeSimpleExtension(extensionPointId, elementName, null); |
| } |
| |
| public void removeExtensionPoint(String extensionPointId) throws CoreException { |
| List<IPluginExtension> pluginExtensionPoints = getPluginExtensionPoints(extensionPointId); |
| for (IPluginExtension point : pluginExtensionPoints) { |
| if (point.getParent() instanceof IBundlePlugin) { |
| ((IBundlePlugin) point.getParent()).remove(point); |
| } |
| } |
| } |
| |
| /** |
| * Gets all simple extensions with given <code>extensionPointId</code>, <code>elementName</code> and |
| * <code>attributes</code>.<br> |
| * A simple extension is of the following format:<br> |
| * <code> |
| * <extension point="extensionPointId"><br> |
| * <elementName attribute1="value1" attribute2="value2"></elementName><br> |
| * </extension><br> |
| * </code> |
| * |
| * @param extensionPointId |
| * The full extension point id. |
| * @param elementName |
| * The tag name |
| * @param attributes |
| * the attributes that must match. |
| * @return an array containing all extensions that match the given criteria. |
| */ |
| public IPluginElement[] getSimpleExtensions(String extensionPointId, String elementName, Map<String, String> attributes) { |
| List<IPluginElement> candidates = getPluginExtensions(extensionPointId); |
| Iterator<IPluginElement> it = candidates.iterator(); |
| while (it.hasNext()) { |
| IPluginElement candidate = it.next(); |
| if (!elementName.equals(candidate.getName())) { |
| it.remove(); // element name does not match -> no candidate (remove from list) |
| } |
| else if (attributes != null && attributes.size() > 0) { |
| // name matches. check also for the attributes |
| for (Entry<String, String> entry : attributes.entrySet()) { |
| IPluginAttribute a = candidate.getAttribute(entry.getKey()); |
| if (a == null) { |
| it.remove(); // search attribute does not exist -> no candidate (remove from list) |
| break; |
| } |
| else if (CompareUtility.notEquals(entry.getValue(), a.getValue())) { |
| it.remove(); // search attribute does not contain the requested value -> no candidate (remove from list) |
| break; |
| } |
| } |
| } |
| } |
| return candidates.toArray(new IPluginElement[candidates.size()]); |
| } |
| |
| /** |
| * Gets all simple extensions with given <code>extensionPointId</code> and <code>elementName</code>.<br> |
| * A simple extension is of the following format:<br> |
| * <code> |
| * <extension point="extensionPointId"><br> |
| * <elementName></elementName><br> |
| * </extension><br> |
| * </code> |
| * |
| * @param extensionPointId |
| * The full extension point id. |
| * @param elementName |
| * The tag name |
| * @return an array containing all extensions that match the given criteria. |
| */ |
| public IPluginElement[] getSimpleExtensions(String extensionPointId, String elementName) { |
| return getSimpleExtensions(extensionPointId, elementName, null); |
| } |
| |
| private List<IPluginExtension> getPluginExtensionPoints(String extensionPointId) { |
| LinkedList<IPluginExtension> result = new LinkedList<IPluginExtension>(); |
| for (IPluginExtension extPoint : m_model.getBundlePluginModel().getExtensions(true).getExtensions()) { |
| if (extPoint.getPoint().equals(extensionPointId)) { |
| result.add(extPoint); |
| } |
| } |
| return result; |
| } |
| |
| private List<IPluginElement> getPluginExtensions(String extensionPointId) { |
| LinkedList<IPluginElement> result = new LinkedList<IPluginElement>(); |
| for (IPluginExtension extPoint : getPluginExtensionPoints(extensionPointId)) { |
| for (IPluginObject element : extPoint.getChildren()) { |
| if (element instanceof IPluginElement) { |
| result.add((IPluginElement) element); |
| } |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * Gets the first simple extension with given <code>extensionPointId</code>, <code>elementName</code> and |
| * <code>attributes</code>.<br> |
| * A simple extension is of the following format:<br> |
| * <code> |
| * <extension point="extensionPointId"><br> |
| * <elementName attribute1="value1" attribute2="value2"></elementName><br> |
| * </extension><br> |
| * </code> |
| * |
| * @param extensionPointId |
| * The full extension point id |
| * @param elementName |
| * The tag name |
| * @param attributes |
| * The attributes |
| * @return the first extension that matches all criteria. |
| */ |
| public IPluginElement getSimpleExtension(String extensionPointId, String elementName, Map<String, String> attributes) { |
| IPluginElement[] matches = getSimpleExtensions(extensionPointId, elementName, attributes); |
| if (matches != null && matches.length > 0) return matches[0]; |
| return null; |
| } |
| |
| /** |
| * Gets the first simple extension with given <code>extensionPointId</code> and <code>elementName</code>.<br> |
| * A simple extension is of the following format:<br> |
| * <code> |
| * <extension point="extensionPointId"><br> |
| * <elementName></elementName><br> |
| * </extension><br> |
| * </code> |
| * |
| * @param extensionPointId |
| * The full extension point id |
| * @param elementName |
| * The tag name |
| * @return the first extension that matches all criteria. |
| */ |
| public IPluginElement getSimpleExtension(String extensionPointId, String elementName) { |
| return getSimpleExtension(extensionPointId, elementName, null); |
| } |
| |
| /** |
| * Checks if a simple extension with given <code>extensionPointId</code>, <code>elementName</code> and |
| * <code>attributes</code> already exists.<br> |
| * A simple extension is of the following format:<br> |
| * <code> |
| * <extension point="extensionPointId"><br> |
| * <elementName attribute1="value1" attribute2="value2"></elementName><br> |
| * </extension><br> |
| * </code> |
| * |
| * @param extensionPointId |
| * The full extension point id |
| * @param elementName |
| * The tag name |
| * @param attributes |
| * The attributes |
| * @return true if such an extension exists, false otherwise. |
| */ |
| public boolean existsSimpleExtension(String extensionPointId, String elementName, Map<String, String> attributes) { |
| IPluginElement[] matches = getSimpleExtensions(extensionPointId, elementName, attributes); |
| return matches != null && matches.length > 0; |
| } |
| |
| /** |
| * Checks if a simple extension with given <code>extensionPointId</code> and <code>elementName</code> already |
| * exists.<br> |
| * A simple extension is of the following format:<br> |
| * <code> |
| * <extension point="extensionPointId"><br> |
| * <elementName></elementName><br> |
| * </extension><br> |
| * </code> |
| * |
| * @param extensionPointId |
| * The full extension point id |
| * @param elementName |
| * The tag name |
| * @return true if such an extension exists, false otherwise. |
| */ |
| public boolean existsSimpleExtension(String extensionPointId, String elementName) { |
| return existsSimpleExtension(extensionPointId, elementName, null); |
| } |
| |
| /** |
| * Gets the plugin.xml file of the plugin. |
| * |
| * @return |
| */ |
| public IFile getFile() { |
| return m_model.getPluginXmlFile(); |
| } |
| } |
| |
| public static class BuildPropertiesPart { |
| private final static String BINARY_BUILD_INCLUDES = "bin.includes"; |
| |
| private final LazyPluginModel m_model; |
| |
| private BuildPropertiesPart(LazyPluginModel m) { |
| m_model = m; |
| } |
| |
| /** |
| * Removes the given resource from the binary build includes list.<br> |
| * If the resource is null, this method does nothing. |
| * |
| * @param resource |
| * The resource to remove. |
| * @throws CoreException |
| */ |
| public void removeBinaryBuildEntry(IResource resource) throws CoreException { |
| if (resource == null) return; |
| removeBinaryBuildEntry(getProjectRelativeResourcePath(resource)); |
| } |
| |
| /** |
| * Removes the given token from the binary build includes list.<br> |
| * If the token is null or empty, this method does nothing. |
| * |
| * @param token |
| * The token to remove. |
| * @throws CoreException |
| */ |
| public void removeBinaryBuildEntry(String token) throws CoreException { |
| if (token == null || token.length() < 1) return; |
| IBuildEntry entry = m_model.getBuildModel().getBuild().getEntry(BINARY_BUILD_INCLUDES); |
| if (entry != null) { |
| entry.removeToken(token); |
| } |
| } |
| |
| /** |
| * Gets all binary build includes. |
| * |
| * @return An array containing all binary build includes of the plugin. |
| */ |
| public String[] getBinaryBuildEntries() { |
| IBuildEntry entry = m_model.getBuildModel().getBuild().getEntry(BINARY_BUILD_INCLUDES); |
| if (entry != null) { |
| return entry.getTokens(); |
| } |
| return new String[]{}; |
| } |
| |
| private IBuildEntry getBuildEntry(String name) throws CoreException { |
| IBuildEntry entry = m_model.getBuildModel().getBuild().getEntry(name); |
| if (entry == null) { |
| entry = m_model.getBuildModel().getFactory().createEntry(name); |
| m_model.getBuildModel().getBuild().add(entry); |
| } |
| return entry; |
| } |
| |
| /** |
| * Checks whether the given resource exists in the binary build includes list of the project associated with this |
| * helper. |
| * |
| * @param resource |
| * The resource to search. |
| * @return true if the given resource is already in the binary build includes list, false otherwise. |
| * @throws CoreException |
| */ |
| public boolean existsBinaryBuildEntry(IResource resource) throws CoreException { |
| if (resource == null) return false; |
| return existsBinaryBuildEntry(getProjectRelativeResourcePath(resource)); |
| } |
| |
| /** |
| * Checks whether the given token exists in the binary build includes list of the project associated with this |
| * helper. |
| * |
| * @param token |
| * The token to search. |
| * @return true if the given token is already in the binary build includes list, false otherwise. |
| * @throws CoreException |
| */ |
| public boolean existsBinaryBuildEntry(String token) throws CoreException { |
| if (token == null || token.length() < 1) return false; |
| IBuildEntry entry = getBuildEntry(BINARY_BUILD_INCLUDES); |
| return entry.contains(token); |
| } |
| |
| /** |
| * Adds the given token to the binary build includes.<br> |
| * If no "bin.includes" exists, it is created.<br> |
| * If the token is null, does not exist or is already in the list, this method does nothing.<br> |
| * This method is thread safe. |
| * |
| * @param resource |
| * The resource to add. |
| * @throws CoreException |
| */ |
| public void addBinaryBuildEntry(IResource resource) throws CoreException { |
| if (resource == null) return; |
| if (!resource.exists()) return; |
| addBinaryBuildEntry(getProjectRelativeResourcePath(resource)); |
| } |
| |
| /** |
| * Adds the given token to the binary build includes.<br> |
| * If no "bin.includes" exists, it is created.<br> |
| * If the token is null, empty or is already in the list, this method does nothing.<br> |
| * This method is thread safe. |
| * |
| * @param token |
| * The token to add. |
| * @throws CoreException |
| */ |
| public void addBinaryBuildEntry(String token) throws CoreException { |
| if (token == null || token.length() < 1) return; |
| synchronized (m_model.getProject()) { |
| IBuildEntry entry = getBuildEntry(BINARY_BUILD_INCLUDES); |
| if (!entry.contains(token)) { |
| entry.addToken(token); |
| } |
| } |
| } |
| |
| /** |
| * Gets the build.properties file of the plugin. |
| * |
| * @return |
| */ |
| public IFile getFile() { |
| return m_model.getBuildPropertiesFile(); |
| } |
| } |
| } |
