--- /dev/null
+
+/*
+ * Created on 16-feb-2004
+ *
+ */
+package com.quantum.extensions;
+import java.util.Vector;
+
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IConfigurationElement;
+import org.eclipse.core.runtime.IExtension;
+import org.eclipse.core.runtime.IExtensionPoint;
+import org.eclipse.core.runtime.IPluginRegistry;
+import org.eclipse.core.runtime.Platform;
+import org.eclipse.ui.IViewPart;
+import org.eclipse.ui.WorkbenchException;
+import org.w3c.dom.Document;
+
+import com.quantum.view.bookmark.BookmarkView;
+import com.quantum.view.tableview.TableView;
+
+/**
+ * Extension processing logic for the <code>functions</code> extension-point.
+ * Extract specific information about each function. Create callback
+ * function object when required.
+ *
+ * @author panic
+ *
+ */
+public class ProcessServiceMembers {
+
+ /**
+ * The fully-qualified name of the functions extension-point for this plug-in.
+ */
+ private static final String EXTENSION_POINT_METADATA =
+ "com.quantum.Quantum.metadata";
+ private static final String EXTENSION_POINT_DATA =
+ "com.quantum.Quantum.data";
+
+ /**
+ * Name of the XML attribute designating a metadata actor label.
+ */
+ private static final String FUNCTION_NAME_ATTRIBUTE = "label";
+
+ /**
+ * Name of the XML attribute designating the fully-qualified name
+ * of the implementation class of a function.
+ */
+ private static final String CLASS_ATTRIBUTE = "class";
+
+ /**
+ * Perform initial extension processing for the members of the
+ * <code>functions</code> extension-point. Make calls to the user interface
+ * module to add the functions of an extension to the UI functions grid.
+ * For each function, a virtual proxy callback object is created and handed
+ * to the user interface module. The proxy class is a nested top-level
+ * class and is therefore known at compile time. The actual (real) callback
+ * objects configured into extensions are instantiated and initialized in
+ * a lazy fashion by the proxy callback objects.
+ *
+ * @param grid The UI functions grid exposing the functions configured
+ * into <code>functions</code> extensions.
+ *
+ */
+ public static void process(IViewPart view, Vector extensionActions) throws WorkbenchException {
+
+ extensionActions.clear();
+
+ IPluginRegistry registry = Platform.getPluginRegistry();
+ String extPointId;
+ // We have two different extension points, we choose the needed one based
+ // on the view that calls this function.
+ // Our two extension points have the same attributes, so the only change is the name
+ // If the implementation differed more, we should probably make two different functions
+ if (view instanceof BookmarkView)
+ extPointId = EXTENSION_POINT_METADATA;
+ else if (view instanceof TableView)
+ extPointId = EXTENSION_POINT_DATA;
+ else
+ return;
+
+ IExtensionPoint extensionPoint =
+ registry.getExtensionPoint(extPointId);
+ if (extensionPoint == null) {
+ throw new WorkbenchException(
+ "unable to resolve extension-point: " + extPointId);
+ }
+ IConfigurationElement[] members =
+ extensionPoint.getConfigurationElements();
+
+ // For each service:
+ for (int m = 0; m < members.length; m++) {
+ IConfigurationElement member = members[m];
+ // Get the label of the extender plugin and the ID of the extension.
+ IExtension extension = member.getDeclaringExtension();
+ String pluginLabel =
+ extension.getDeclaringPluginDescriptor().getLabel();
+ if (pluginLabel == null) {
+ pluginLabel = "[unnamed plugin]";
+ }
+ // Get the name of the operation implemented by the service.
+ // The operation name is a service attribute in the extension's XML specification.
+ String functionName = member.getAttribute(FUNCTION_NAME_ATTRIBUTE);
+ if (functionName == null) {
+ functionName = "[unnamed function]";
+ }
+ String label = pluginLabel + "/" + functionName;
+ // Add a row to support this operation to the UI grid.
+ IQuantumExtension proxy = null;
+ if (view instanceof BookmarkView)
+ proxy = (IMetadataExtension) new MetadataFunctionProxy(member);
+ else if (view instanceof TableView)
+ proxy = (IDataExtension) new DataFunctionProxy(member);
+ //grid.addFunction(proxy, functionName, label);
+ extensionActions.add(new ExtensionAction(view, label, label, proxy));
+ }
+ }
+
+ /**
+ * Virtual proxy class for function invokation.
+ * Members of this class support lazy processing by fronting the real
+ * implementations of arithmetic functions configured into extensions.
+ */
+ private static class MetadataFunctionProxy implements IMetadataExtension {
+ // The "real" implementation of the function.
+ private IMetadataExtension delegate = null;
+ // The configured state of the extension element representing this arithmetic function.
+ private IConfigurationElement element;
+ // Whether this function has been invoked before.
+ // Used for lazy evaluation of the service.
+ private boolean invoked = false;
+
+ /**
+ * Construct a virtual proxy to stand in place of an extension function.
+ * The constructor simply keeps track of an arithmetic function's configured state
+ * without at this time instantiating the implementation of the function.
+ *
+ * @param element The configuration of this arithmetic function.
+ */
+ public MetadataFunctionProxy(IConfigurationElement element) {
+ this.element = element;
+ }
+
+ /**
+ * Compute the function value.
+ * The proxy computation first instantiates the implementation
+ * of the function, if this is the first time the function is called,
+ * and then delegates to that implementation. The instantiation and
+ * initialization of the delegate implementation uses the standard
+ * callback object instantiation and initialization methods of Eclipse.
+ *
+ * @see com.bolour.sample.eclipse.service.ui.IFunction#compute(long)
+ */
+ public final void run(Document doc) {
+ try {
+ getDelegate().run(doc);
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ }
+
+ /**
+ * Instantiate and initialize the implementation of the function if
+ * this is the first time the proxy has been called.
+ *
+ * @return The implementation delegate (same as the instance variable <code>delegate</code>.
+ * @throws Exception If the callback object is misconfigured.
+ */
+ private final IMetadataExtension getDelegate() throws Exception {
+ if (invoked) {
+ return delegate;
+ }
+ invoked = true;
+ try {
+ Object callback =
+ element.createExecutableExtension(CLASS_ATTRIBUTE);
+ if (!(callback instanceof IMetadataExtension)) {
+ String message =
+ "callback class '"
+ + callback.getClass().getName()
+ + "' is not an IFunction";
+ System.err.println(message);
+ throw new ClassCastException(message);
+ }
+ delegate = (IMetadataExtension) callback;
+ } catch (CoreException ex) {
+ System.err.println(ex.getMessage());
+ ex.printStackTrace();
+ throw ex;
+ } catch (Error err) {
+ System.err.println(err.getMessage());
+ err.printStackTrace();
+ throw err;
+ }
+ return delegate;
+ }
+ }
+ /**
+ * Virtual proxy class for function invokation.
+ * Members of this class support lazy processing by fronting the real
+ * implementations of arithmetic functions configured into extensions.
+ */
+ private static class DataFunctionProxy implements IDataExtension {
+ // The "real" implementation of the function.
+ private IDataExtension delegate = null;
+ // The configured state of the extension element representing this arithmetic function.
+ private IConfigurationElement element;
+ // Whether this function has been invoked before.
+ // Used for lazy evaluation of the service.
+ private boolean invoked = false;
+
+ /**
+ * Construct a virtual proxy to stand in place of an extension function.
+ * The constructor simply keeps track of an arithmetic function's configured state
+ * without at this time instantiating the implementation of the function.
+ *
+ * @param element The configuration of this arithmetic function.
+ */
+ public DataFunctionProxy(IConfigurationElement element) {
+ this.element = element;
+ }
+
+ /**
+ * Compute the function value.
+ * The proxy computation first instantiates the implementation
+ * of the function, if this is the first time the function is called,
+ * and then delegates to that implementation. The instantiation and
+ * initialization of the delegate implementation uses the standard
+ * callback object instantiation and initialization methods of Eclipse.
+ *
+ * @see com.bolour.sample.eclipse.service.ui.IFunction#compute(long)
+ */
+ public final void run(Document doc) {
+ try {
+ getDelegate().run(doc);
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ }
+
+ /**
+ * Instantiate and initialize the implementation of the function if
+ * this is the first time the proxy has been called.
+ *
+ * @return The implementation delegate (same as the instance variable <code>delegate</code>.
+ * @throws Exception If the callback object is misconfigured.
+ */
+ private final IDataExtension getDelegate() throws Exception {
+ if (invoked) {
+ return delegate;
+ }
+ invoked = true;
+ try {
+ Object callback =
+ element.createExecutableExtension(CLASS_ATTRIBUTE);
+ if (!(callback instanceof IDataExtension)) {
+ String message =
+ "callback class '"
+ + callback.getClass().getName()
+ + "' is not an IFunction";
+ System.err.println(message);
+ throw new ClassCastException(message);
+ }
+ delegate = (IDataExtension) callback;
+ } catch (CoreException ex) {
+ System.err.println(ex.getMessage());
+ ex.printStackTrace();
+ throw ex;
+ } catch (Error err) {
+ System.err.println(err.getMessage());
+ err.printStackTrace();
+ throw err;
+ }
+ return delegate;
+ }
+ }
+
+}
+
git://git.phpeclipse.com / phpeclipse.git / blobdiff