org.eclipse.emf.common.CommonPlugin Maven / Gradle / Ivy
/**
* Copyright (c) 2002-2007 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v2.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v20.html
*
* Contributors:
* IBM - Initial API and implementation
*/
package org.eclipse.emf.common;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Method;
import java.net.URL;
import java.text.Collator;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Platform;
import org.eclipse.emf.common.util.CommonUtil;
import org.eclipse.emf.common.util.ResourceLocator;
import org.eclipse.emf.common.util.URI;
import org.eclipse.osgi.service.resolver.BundleDescription;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleActivator;
import org.osgi.resource.Capability;
/**
* The Plugin for the model EMF.Common library.
* EMF must run
* within an Eclipse workbench,
* within a headless Eclipse workspace,
* or just stand-alone as part of some other application.
* To support this, all resource access should be directed to the resource locator,
* which can redirect the service as appropriate to the runtime.
* During stand-alone invocation no plugin initialization takes place.
* In this case, common.resources.jar must be on the CLASSPATH.
* @see #INSTANCE
*/
public final class CommonPlugin extends EMFPlugin
{
/**
* The singleton instance of the plugin.
*/
public static final CommonPlugin INSTANCE = new CommonPlugin();
/**
* The one instance of this class.
*/
private static Implementation plugin;
/**
* Creates the singleton instance.
*/
private CommonPlugin()
{
super(new ResourceLocator[] {});
}
@Override
public ResourceLocator getPluginResourceLocator()
{
return plugin;
}
/**
* Returns the singleton instance of the Eclipse plugin.
* @return the singleton instance.
*/
public static Implementation getPlugin()
{
return plugin;
}
/**
* Use the platform, if available, to convert to a local URI.
*/
public static URI asLocalURI(URI uri)
{
return plugin == null ? uri : Implementation.asLocalURI(uri);
}
/**
* Use the platform, if available, to resolve the URI.
*/
public static URI resolve(URI uri)
{
return plugin == null ? uri : Implementation.resolve(uri);
}
/**
* Use the platform, if available, to load the named class using the right class loader.
*/
public static Class loadClass(String pluginID, String className) throws ClassNotFoundException
{
return plugin == null ? Class.forName(className) : Implementation.loadClass(pluginID, className);
}
/**
* Computes a list of {@link ElementRecord element records} for each requested extension point.
* Each key in the map is extension point ID.
*
* The corresponding value is a list of the extension point element records associated with that extension point.
*
*
* Each root element record has synthetic attributes derived from the extension point:
*
*
* - {@code point}
* - The extension point ID itself.
* - {@code symbolicName}
* - The symbolic name of the bundle that contains the extension point.
* - {@code location}
* -
* The root location URI the bundle containing the extension point.
* For example, {@code platform:/resource/org.example.plugin} for an extension point in the workspace,
* {@code file:/folder/org.eclipse.plugin} for folder bundle in the target platform,
* or {@code archive:file:/file/folder/org.example.plugin.jar!/} for a jarred bundle in the target platform.
* This is useful for resolving a relative path in attribute value to its absolute path in the bundle.
*
*
*
* This method uses the Plug-in Development Environment (PDE) to compute the results.
* It will include results for plug-ins in the workspace as well as for plug-ins in the target platform.
* If PDE is not available, this information cannot be computed.
*
*
* @param extensionPoints a set of extension points to query; if it's {@code null} or empty, all extension points will be queried.
* @return a map of extension point data, or {@code null} if PDE is not available.
* @since 2.14
*/
public static Map> getTargetPlatformExtensionPoints(Set extensionPoints)
{
if (IS_ECLIPSE_RUNNING && PDEHelper.IS_PDE_BUNDLE_AVAILABLE)
{
return PDEHelper.computeModels(extensionPoints);
}
else
{
return null;
}
}
/**
* Computes a map from bundle symbolic name to the bundle's location URI.
*
* This method uses the Plug-in Development Environment (PDE) to compute the results.
* It will include results for plug-ins in the workspace as well as for plug-ins in the target platform.
* If PDE is not available, this information cannot be computed.
*
*
* @return a map from bundle symbolic name to the bundle's location URI, or {@code null} if PDE is not available.
* @since 2.14
*/
public static Map getTargetPlatformBundleMappings()
{
if (IS_ECLIPSE_RUNNING && PDEHelper.IS_PDE_BUNDLE_AVAILABLE)
{
return PDEHelper.computeTargetPlatformBundleMappings();
}
else
{
return null;
}
}
private static volatile Method collatorGetInstanceMethod;
private static volatile boolean collatorGetInstanceMethodInitialized;
private static Method getCollatorGetInstanceMethod()
{
if (!collatorGetInstanceMethodInitialized)
{
try
{
Class collatorClass = loadClass("com.ibm.icu", "com.ibm.icu.text.Collator");
collatorGetInstanceMethod = collatorClass.getMethod("getInstance", Locale.class);
}
catch (Throwable throwable)
{
// Assume the class is not available.
}
collatorGetInstanceMethodInitialized = true;
}
return collatorGetInstanceMethod;
}
/**
* Returns a string comparator appropriate for collating strings for the {@link Locale#getDefault() current locale}.
* @return a string comparator appropriate for collating strings for the {@link Locale#getDefault() current locale}.
*/
public Comparator getComparator()
{
return getComparator(Locale.getDefault());
}
/**
* Returns a string comparator appropriate for collating strings for the give locale.
* This will use ICU, when available that plug-in is available, or {@link Collator} otherwise.
* @param locale the locale for which a comparator is needed.
* @return a string comparator appropriate for collating strings for the give locale.
*/
@SuppressWarnings("unchecked")
public Comparator getComparator(Locale locale)
{
Method collatorGetInstanceMethod = getCollatorGetInstanceMethod();
if (collatorGetInstanceMethod != null)
{
try
{
return (Comparator)collatorGetInstanceMethod.invoke(null, locale);
}
catch (Throwable eception)
{
// Just return the default.
}
}
return (Comparator)(Comparator)Collator.getInstance(locale);
}
/**
* The actual implementation of the Eclipse Plugin.
*/
public static class Implementation extends EclipsePlugin
{
/**
* Creates an instance.
*/
public Implementation()
{
super();
// Remember the static instance.
//
plugin = this;
}
/**
* Use the platform to convert to a local URI.
*/
protected static URI asLocalURI(URI uri)
{
try
{
String fragment = uri.fragment();
URL url = FileLocator.toFileURL(CommonUtil.newURL(uri.trimFragment().toString()));
return fix(url, fragment);
}
catch (IOException exception)
{
// Ignore the exception and return the original URI.
}
return uri;
}
/**
* Use the platform to convert to a local URI.
*/
protected static URI resolve(URI uri)
{
String fragment = uri.fragment();
URI uriWithoutFragment = uri.trimFragment();
String uriWithoutFragmentToString = uriWithoutFragment.toString();
URL url = null;
try
{
url = FileLocator.resolve(CommonUtil.newURL(uriWithoutFragmentToString));
}
catch (IOException exception1)
{
// Platform.resolve() doesn't work if the project is encoded.
//
try
{
uriWithoutFragmentToString = URI.decode(uriWithoutFragmentToString);
url = FileLocator.resolve(CommonUtil.newURL(uriWithoutFragmentToString));
}
catch (IOException exception2)
{
// Continue with the unresolved URI.
}
}
if (url != null)
{
try
{
return fix(url, fragment);
}
catch (IOException exception)
{
// Return the original URI.
}
}
return uri;
}
protected static URI fix(URL url, String fragment) throws IOException
{
// Only file-scheme URIs will be re-encoded. If a URI was decoded in the workaround
// above, and Platform.resolve() didn't return a file-scheme URI, then this will return
// an decoded URI.
//
URI result =
"file".equalsIgnoreCase(url.getProtocol()) ?
URI.createFileURI(URI.decode(url.getFile())) :
URI.createURI(url.toString());
if (fragment != null)
{
result = result.appendFragment(fragment);
}
return result;
}
/**
* Use the platform to load the named class using the right class loader.
*/
public static Class loadClass(String pluginID, String className) throws ClassNotFoundException
{
Bundle bundle = Platform.getBundle(pluginID);
if (bundle == null)
{
throw new ClassNotFoundException(className + " cannot be loaded because because bundle " + pluginID + " cannot be resolved");
}
else
{
return bundle.loadClass(className);
}
}
/**
* @since 2.10
*/
public static class Activator extends EMFPlugin.OSGiDelegatingBundleActivator
{
@Override
protected BundleActivator createBundle()
{
return new Implementation();
}
}
}
/**
* A specialized {@link HashMap} map that supports {@link #getTargetPlatformValues(String,String) computing} information from the target platform, if the PDE is available.
* It is abstract because the {@link #createKey(String)} method must be specialized to convert each attribute's string value to a value of the map's key type.
*
* @param the type of the key.
* @param the type of the value.
*
* @since 2.14
*/
public static abstract class SimpleTargetPlatformRegistryImpl extends HashMap
{
private static final long serialVersionUID = 1L;
/**
* Creates an instance.
*/
public SimpleTargetPlatformRegistryImpl()
{
}
/**
* Returns the set of values computed by {@link CommonPlugin#getTargetPlatformExtensionPoints(Set) fetching} all the given extension points
* and {@link ElementRecord#getAttributes() looking up} the given attribute name in each {@link ElementRecord#getChildren() element} of that extension point.
* Each attribute value is {@link #createKey(String) converted} to a value of the map's key type.
* @param extensionPoint the qualified extension point name.
* @param attributeName the attribute name to query.
* @return the values computed from the target platform, if the Plug-in Development Environment is available, or a copy of the {@link #keySet()} otherwise.
* @see #createKey(String)
*/
protected Set getTargetPlatformValues(String extensionPoint, String attributeName)
{
Map> targetPlatformExtensionPoints = getTargetPlatformExtensionPoints(Collections.singleton(extensionPoint));
if (targetPlatformExtensionPoints != null)
{
Set result = new LinkedHashSet();
List extensionPointElementRecords = targetPlatformExtensionPoints.get(extensionPoint);
if (extensionPointElementRecords != null)
{
for (CommonPlugin.ElementRecord extensionPointRecord : extensionPointElementRecords)
{
for (ElementRecord elementRecord : extensionPointRecord.getChildren())
{
String attribute = elementRecord.getAttributes().get(attributeName);
if (attribute != null)
{
result.add(createKey(attribute));
}
}
}
}
return result;
}
else
{
return new LinkedHashSet(keySet());
}
}
/**
* Returns the attribute value converted to a value of the key type.
* @param attribute the attribute value.
* @return the attribute value converted to a value of the key type.
*/
protected abstract K createKey(String attribute);
}
/**
* A simple representation of an element in a {@code plugin.xml}.
* It has the obvious things you'd expect of an element, i.e., a name, attributes, and children.
*
* @since 2.14
*/
public static final class ElementRecord
{
/**
* The element name.
*/
private final String name;
/**
* The attributes of the element.
*/
private final Map attributes = new TreeMap();
/**
* The children of the element.
*/
private final List children = new ArrayList();
/**
* Creates an element with the given name.
*
* @param name the name of the element.
*/
private ElementRecord(String name)
{
this.name = name;
}
/**
* Returns the name of the element.
* @return the name of the element.
*/
public String getName()
{
return name;
}
/**
* Returns the attributes of the element.
* @return the attributes of the element.
*/
public Map getAttributes()
{
return Collections.unmodifiableMap(attributes);
}
/**
* Returns the children elements.
* @return the children elements.
*/
public List getChildren()
{
return Collections.unmodifiableList(children);
}
/**
* A helpful override for debugging.
*/
@Override
public String toString()
{
return "" + name + " attributes= " + attributes + " children=" + children;
}
}
private static class PDEHelper
{
private static final String ECORE_GENERATED_PACKAGE = "org.eclipse.emf.ecore.generated_package";
private static final String ECORE_DYNAMIC_PACKAGE = "org.eclipse.emf.ecore.dynamic_package";
private static final Method PLUGIN_MODEL_BASE_GET_BUNDLE_DESCRIPTION_METHOD;
private static final Method PLUGIN_MODEL_BASE_GET_UNDERLYING_RESOURCE_METHOD;
private static final Method RESOURCE_GET_PROJECT_METHOD;
private static final Method RESOURCE_GET_FULL_PATH_METHOD;
private static final Method PLUGIN_MODEL_BASE_GET_INSTALL_LOCATION_METHOD;
private static final Method PLUGIN_MODEL_BASE_GET_EXTENSIONS_METHOD;
private static final Method PLUGIN_REGISTRY_GET_ACTIVE_MODELS_METHOD;
private static final Method EXTENSIONS_GET_EXTENSIONS_METHOD;
private static final Method PLUGIN_EXTENSION_GET_POINT_METHOD;
private static final Method PLUGIN_EXTENSION_GET_CHILDREN_METHOD;
private static final Class PLUGIN_ELEMENT_CLASS;
private static final Method PLUGIN_ELEMENT_GET_ATTRIBUTES_METHOD;
private static final Method PLUGIN_OBJECT_GET_NAME_METHOD;
private static final Method PLUGIN_ATTRIBUTE_GET_VALUE_METHOD;
private static final boolean IS_PDE_BUNDLE_AVAILABLE;
static
{
Method pluginModelBaseGetBundleDescriptionMethod = null;
Method pluginModelBaseGetUnderlyingResourceMethod = null;
Method resourceGetProjectMethod = null;
Method resourceGetFullPathtMethod = null;
Method pluginModelBaseGetInstallLocationMethod = null;
Method pluginModelBaseGetExtensionsMethod = null;
Method pluginRegistryGetActiveModelsMethod = null;
Method extensionsGetExtensionsMethod = null;
Method pluginExtensionGetPointMethod = null;
Method pluginExtensionGetChildrenMethod = null;
Class pluginElementClass = null;
Method pluginElementGetAttributesMethod = null;
Method pluginObjectGetNameMethod = null;
Method pluginAttributeGetValueMethod = null;
boolean isPDEBundleAvailable = false;
try
{
Class pluginModelBaseClass = CommonPlugin.loadClass("org.eclipse.pde.core", "org.eclipse.pde.core.plugin.IPluginModelBase");
pluginModelBaseGetBundleDescriptionMethod = pluginModelBaseClass.getMethod("getBundleDescription");
pluginModelBaseGetUnderlyingResourceMethod = pluginModelBaseClass.getMethod("getUnderlyingResource");
resourceGetProjectMethod = pluginModelBaseGetUnderlyingResourceMethod.getReturnType().getMethod("getProject");
resourceGetFullPathtMethod = resourceGetProjectMethod.getReturnType().getMethod("getFullPath");
pluginModelBaseGetInstallLocationMethod = pluginModelBaseClass.getMethod("getInstallLocation");
pluginModelBaseGetExtensionsMethod = pluginModelBaseClass.getMethod("getExtensions");
Class pluginRegistryClass = CommonPlugin.loadClass("org.eclipse.pde.core", "org.eclipse.pde.core.plugin.PluginRegistry");
pluginRegistryGetActiveModelsMethod = pluginRegistryClass.getMethod("getActiveModels", boolean.class);
Class extensionsClass = CommonPlugin.loadClass("org.eclipse.pde.core", "org.eclipse.pde.core.plugin.IExtensions");
extensionsGetExtensionsMethod = extensionsClass.getMethod("getExtensions");
Class pluginExtensionClass = CommonPlugin.loadClass("org.eclipse.pde.core", "org.eclipse.pde.core.plugin.IPluginExtension");
pluginExtensionGetPointMethod = pluginExtensionClass.getMethod("getPoint");
pluginExtensionGetChildrenMethod = pluginExtensionClass.getMethod("getChildren");
pluginElementClass = CommonPlugin.loadClass("org.eclipse.pde.core", "org.eclipse.pde.core.plugin.IPluginElement");
pluginObjectGetNameMethod = pluginElementClass.getMethod("getName");
pluginElementGetAttributesMethod = pluginElementClass.getMethod("getAttributes");
Class pluginAttributeClass = CommonPlugin.loadClass("org.eclipse.pde.core", "org.eclipse.pde.core.plugin.IPluginAttribute");
pluginAttributeGetValueMethod = pluginAttributeClass.getMethod("getValue");
isPDEBundleAvailable = true;
}
catch (Throwable exception)
{
// Ignore.
}
PLUGIN_MODEL_BASE_GET_BUNDLE_DESCRIPTION_METHOD = pluginModelBaseGetBundleDescriptionMethod;
PLUGIN_MODEL_BASE_GET_UNDERLYING_RESOURCE_METHOD = pluginModelBaseGetUnderlyingResourceMethod;
RESOURCE_GET_PROJECT_METHOD = resourceGetProjectMethod;
RESOURCE_GET_FULL_PATH_METHOD = resourceGetFullPathtMethod;
PLUGIN_MODEL_BASE_GET_INSTALL_LOCATION_METHOD = pluginModelBaseGetInstallLocationMethod;
PLUGIN_MODEL_BASE_GET_EXTENSIONS_METHOD = pluginModelBaseGetExtensionsMethod;
PLUGIN_REGISTRY_GET_ACTIVE_MODELS_METHOD = pluginRegistryGetActiveModelsMethod;
EXTENSIONS_GET_EXTENSIONS_METHOD = extensionsGetExtensionsMethod;
PLUGIN_EXTENSION_GET_POINT_METHOD = pluginExtensionGetPointMethod;
PLUGIN_EXTENSION_GET_CHILDREN_METHOD = pluginExtensionGetChildrenMethod;
PLUGIN_ELEMENT_CLASS = pluginElementClass;
PLUGIN_OBJECT_GET_NAME_METHOD = pluginObjectGetNameMethod;
PLUGIN_ELEMENT_GET_ATTRIBUTES_METHOD = pluginElementGetAttributesMethod;
PLUGIN_ATTRIBUTE_GET_VALUE_METHOD = pluginAttributeGetValueMethod;
IS_PDE_BUNDLE_AVAILABLE = isPDEBundleAvailable && !"true".equals(System.getProperty("org.eclipse.emf.common.CommonPlugin.doNotUsePDE"));
}
@SuppressWarnings("unchecked")
private static T invoke(Object object, Method method, Object... arguments)
{
try
{
return (T)method.invoke(object, arguments);
}
catch (Exception exception)
{
return null;
}
}
private static Map computeTargetPlatformBundleMappings()
{
final Map result = new TreeMap();
new ActiveModelVisitor()
{
@Override
void visitActiveModel(Object activeModel, BundleDescription bundleDescription, URI location)
{
String symbolicName = bundleDescription == null ? null : bundleDescription.getSymbolicName();
if (symbolicName != null && location != null)
{
result.put(symbolicName, location);
}
}
};
return result;
}
private static Map> computeModels(final Set extensionPoints)
{
final Map> result = new TreeMap>();
new ActiveModelVisitor()
{
@Override
void visitActiveModel(Object activeModel, BundleDescription bundleDescription, URI location)
{
String symbolicName = bundleDescription == null ? null : bundleDescription.getSymbolicName();
// Iterate over the plugin's extensions...
//
// IExtensions extensions = activeModel.getExtensions();
// IPluginExtension[] pluginExtensions = extensions.getExtensions();
//
Object extensions = invoke(activeModel, PLUGIN_MODEL_BASE_GET_EXTENSIONS_METHOD);
Object[] pluginExtensions = invoke(extensions, EXTENSIONS_GET_EXTENSIONS_METHOD);
if (pluginExtensions.length == 0)
{
if (extensionPoints != null && bundleDescription != null)
{
if (extensionPoints.contains(ECORE_GENERATED_PACKAGE))
{
List capabilities = bundleDescription.getCapabilities(ECORE_GENERATED_PACKAGE);
if (!capabilities.isEmpty())
{
ElementRecord extensionRecord = new ElementRecord("extension");
recordExtensionAttributes(extensionRecord, ECORE_GENERATED_PACKAGE, symbolicName, location);
for (Capability capability : capabilities)
{
ElementRecord elementRecord = new ElementRecord("package");
Map attributes = capability.getAttributes();
elementRecord.attributes.put("uri", "" + attributes.get("uri"));
elementRecord.attributes.put("class", "" + attributes.get("class"));
elementRecord.attributes.put("genModel", "" + attributes.get("genModel"));
extensionRecord.children.add(elementRecord);
}
List elementRecords = getElementRecords(ECORE_GENERATED_PACKAGE);
elementRecords.add(extensionRecord);
}
}
if (extensionPoints.contains(ECORE_DYNAMIC_PACKAGE))
{
List capabilities = bundleDescription.getCapabilities(ECORE_DYNAMIC_PACKAGE);
if (!capabilities.isEmpty())
{
ElementRecord extensionRecord = new ElementRecord("extension");
recordExtensionAttributes(extensionRecord, ECORE_DYNAMIC_PACKAGE, symbolicName, location);
for (Capability capability : capabilities)
{
ElementRecord elementRecord = new ElementRecord("resource");
Map attributes = capability.getAttributes();
elementRecord.attributes.put("uri", "" + attributes.get("uri"));
elementRecord.attributes.put("location", "" + attributes.get("location"));
extensionRecord.children.add(elementRecord);
}
List elementRecords = getElementRecords(ECORE_DYNAMIC_PACKAGE);
elementRecords.add(extensionRecord);
}
}
}
}
else
{
for (Object pluginExtension : pluginExtensions)
{
// String point = pluginExtension.getPoint();
//
String point = invoke(pluginExtension, PLUGIN_EXTENSION_GET_POINT_METHOD);
// Process all or the specified extension points.
//
if (extensionPoints == null || extensionPoints.isEmpty() || extensionPoints.contains(point))
{
ElementRecord elementRecord = visitElement(pluginExtension);
recordExtensionAttributes(elementRecord, point, symbolicName, location);
List elementRecords = getElementRecords(point);
elementRecords.add(elementRecord);
}
}
}
}
private void recordExtensionAttributes(ElementRecord elementRecord, String point, String symbolicName, URI location)
{
if (location != null)
{
elementRecord.attributes.put("point", point);
elementRecord.attributes.put("symbolicName", symbolicName);
elementRecord.attributes.put("location", location.toString());
}
}
private List getElementRecords(String point)
{
List elementRecords = result.get(point);
if (elementRecords == null)
{
elementRecords = new ArrayList();
result.put(point, elementRecords);
}
return elementRecords;
}
};
// dump(result);
return result;
}
private static void visitElement(Object[] children, List elementRecords)
{
// Visit the children.
//
for (Object child : children)
{
// if (child instanceof IPluginElement)
//
if (PLUGIN_ELEMENT_CLASS.isInstance(child))
{
elementRecords.add(visitElement(child));
}
}
}
private static ElementRecord visitElement(Object child)
{
ElementRecord elementRecord;
if (PLUGIN_ELEMENT_CLASS.isInstance(child))
{
// child.getName();
//
String elementName = invoke(child, PLUGIN_OBJECT_GET_NAME_METHOD);
// Record it by name.
//
elementRecord = new ElementRecord(elementName);
// child.getAttributes()
Object[] attributes = invoke(child, PLUGIN_ELEMENT_GET_ATTRIBUTES_METHOD);
for (Object attribute : attributes)
{
// attribute.getName() and attribute.getValue()
//
String attributeName = invoke(attribute, PLUGIN_OBJECT_GET_NAME_METHOD);
String attributeValue = invoke(attribute, PLUGIN_ATTRIBUTE_GET_VALUE_METHOD);
// Record in the map.
//
elementRecord.attributes.put(attributeName, attributeValue);
}
}
else
{
elementRecord = new ElementRecord("extension");
}
// Visit the child elements recursively.
//
Object[] elements = invoke(child, PLUGIN_EXTENSION_GET_CHILDREN_METHOD);
if (elements.length != 0)
{
visitElement(elements, elementRecord.children);
}
return elementRecord;
}
private static abstract class ActiveModelVisitor
{
public ActiveModelVisitor() {
// Iterate over all the active models in the workspace and target platform.
//
// IPluginModelBase[] activeModels = PluginRegistry.getActiveModels(false);
//
Object[] activeModels = invoke(null, PLUGIN_REGISTRY_GET_ACTIVE_MODELS_METHOD, Boolean.FALSE);
if (activeModels != null)
{
for (Object activeModel : activeModels)
{
// Determine the symbolic name, underlying resource, if any, and the install location.
//
// BundleDescription bundleDescription = activeModel.getBundleDescription();
// IResource underlyingResource = activeModel.getUnderlyingResource();
// String installLocation = activeModel.getInstallLocation();
//
BundleDescription bundleDescription = invoke(activeModel, PLUGIN_MODEL_BASE_GET_BUNDLE_DESCRIPTION_METHOD);
Object underlyingResource = invoke(activeModel, PLUGIN_MODEL_BASE_GET_UNDERLYING_RESOURCE_METHOD);
String installLocation = (String)invoke(activeModel, PLUGIN_MODEL_BASE_GET_INSTALL_LOCATION_METHOD);
// The URI for the location is determined from the underlying resource or the install location, with preference to the former if available.
//
URI location;
if (underlyingResource != null)
{
// If there is an underlying resource, use the platform resource URI referencing the project in the workspace as the location.
// underlyingResource.getProject()
//
Object project = invoke(underlyingResource, RESOURCE_GET_PROJECT_METHOD);
IPath fullPath = invoke(project, RESOURCE_GET_FULL_PATH_METHOD);
location = URI.createPlatformResourceURI(fullPath.toString(), true);
}
else if (installLocation != null)
{
// Otherwise, the install location in the file system is used...
//
File file = new File(installLocation);
if (file.isDirectory())
{
// If the file is a directory, create a file URI for that directory.
//
location = URI.createFileURI(installLocation);
}
else
{
// Otherwise, the location must be an archive, create an archive URI for the file URI of the jar.
//
location = URI.createURI("archive:" + URI.createFileURI(installLocation) + "!/");
}
}
else
{
location = null;
}
visitActiveModel(activeModel, bundleDescription, location);
}
}
}
abstract void visitActiveModel(Object activeModel, BundleDescription bundleDescription, URI location);
}
// private static void dump(Map> data)
// {
// for (Map.Entry> entry : data.entrySet())
// {
// System.out.println(entry.getKey());
// dump(entry.getValue(), " ");
// }
// }
//
// private static void dump(List data, String indent)
// {
// for (ElementRecord elementRecord : data)
// {
// System.out.print(indent + "<" + elementRecord.getName());
// for (Map.Entry attribute : elementRecord.getAttributes().entrySet())
// {
// System.out.println();
// System.out.print(indent + " " + attribute.getKey() + "='" + attribute.getValue() + "'");
// }
// List children = elementRecord.getChildren();
// if (children.isEmpty())
// {
// System.out.println("/>");
// }
// else
// {
// System.out.println(">");
// dump(children, indent + " ");
// System.out.print(indent + "");
// }
// }
// }
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy