--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2005, 2012 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
+ * Marcel Bruch <bruch@cs.tu-darmstadt.de> - [content assist] Allow to re-sort proposals - https://bugs.eclipse.org/bugs/show_bug.cgi?id=350991
+ *******************************************************************************/
+package org.eclipse.jdt.internal.ui.text.java;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+
+import org.osgi.framework.Bundle;
+
+import org.eclipse.core.runtime.Assert;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IConfigurationElement;
+import org.eclipse.core.runtime.IContributor;
+import org.eclipse.core.runtime.IExtension;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.InvalidRegistryObjectException;
+import org.eclipse.core.runtime.PerformanceStats;
+import org.eclipse.core.runtime.Platform;
+import org.eclipse.core.runtime.Status;
+
+import org.eclipse.jface.text.IDocument;
+import org.eclipse.jface.text.contentassist.ICompletionProposal;
+import org.eclipse.jface.text.contentassist.IContextInformation;
+
+import org.eclipse.jdt.internal.corext.util.Messages;
+
+import org.eclipse.jdt.ui.text.IJavaPartitions;
+import org.eclipse.jdt.ui.text.java.ContentAssistInvocationContext;
+import org.eclipse.jdt.ui.text.java.IJavaCompletionProposalComputer;
+
+import org.eclipse.jdt.internal.ui.JavaPlugin;
+
+/**
+ * The description of an extension to the
+ * <code>org.eclipse.jdt.ui.javaCompletionProposalComputer</code> extension point. Instances are
+ * immutable. Instances can be obtained from a {@link CompletionProposalComputerRegistry}.
+ *
+ * @see CompletionProposalComputerRegistry
+ * @since 3.2
+ */
+final class CompletionProposalComputerDescriptor {
+ /** The default category id. */
+ private static final String DEFAULT_CATEGORY_ID= "org.eclipse.jdt.ui.defaultProposalCategory"; //$NON-NLS-1$
+ /** The extension schema name of the category id attribute. */
+ private static final String CATEGORY_ID= "categoryId"; //$NON-NLS-1$
+ /** The extension schema name of the partition type attribute. */
+ private static final String TYPE= "type"; //$NON-NLS-1$
+ /** The extension schema name of the class attribute. */
+ private static final String CLASS= "class"; //$NON-NLS-1$
+ /** The extension schema name of the activate attribute. */
+ private static final String ACTIVATE= "activate"; //$NON-NLS-1$
+ /** The extension schema name of the needsSortingAfterFiltering attribute. */
+ private static final String NEEDS_SORTING_AFTER_FILTERING= "needsSortingAfterFiltering"; //$NON-NLS-1$
+ /** The extension schema name of the partition child elements. */
+ private static final String PARTITION= "partition"; //$NON-NLS-1$
+ /** Set of Java partition types. */
+ private static final Set<String> PARTITION_SET;
+ /** The name of the performance event used to trace extensions. */
+ private static final String PERFORMANCE_EVENT= JavaPlugin.getPluginId() + "/perf/content_assist/extensions"; //$NON-NLS-1$
+ /**
+ * If <code>true</code>, execution time of extensions is measured and the data forwarded to
+ * core's {@link PerformanceStats} service.
+ */
+ private static final boolean MEASURE_PERFORMANCE= PerformanceStats.isEnabled(PERFORMANCE_EVENT);
+ /**
+ * Independently of the {@link PerformanceStats} service, any operation that takes longer than
+ * {@value} milliseconds will be flagged as an violation. This timeout does not apply to the
+ * first invocation, as it may take longer due to plug-in initialization etc. See also
+ * {@link #fIsReportingDelay}.
+ */
+ private static final long MAX_DELAY= 5000;
+
+ /* log constants */
+ private static final String COMPUTE_COMPLETION_PROPOSALS= "computeCompletionProposals()"; //$NON-NLS-1$
+ private static final String COMPUTE_CONTEXT_INFORMATION= "computeContextInformation()"; //$NON-NLS-1$
+ private static final String SESSION_STARTED= "sessionStarted()"; //$NON-NLS-1$
+ private static final String SESSION_ENDED= "sessionEnded()"; //$NON-NLS-1$
+
+ static {
+ Set<String> partitions= new HashSet<String>();
+ partitions.add(IDocument.DEFAULT_CONTENT_TYPE);
+ partitions.add(IJavaPartitions.JAVA_DOC);
+ partitions.add(IJavaPartitions.JAVA_MULTI_LINE_COMMENT);
+ partitions.add(IJavaPartitions.JAVA_SINGLE_LINE_COMMENT);
+ partitions.add(IJavaPartitions.JAVA_STRING);
+ partitions.add(IJavaPartitions.JAVA_CHARACTER);
+
+ PARTITION_SET= Collections.unmodifiableSet(partitions);
+ }
+
+ /** The identifier of the extension. */
+ private final String fId;
+ /** The name of the extension. */
+ private final String fName;
+ /** The class name of the provided <code>IJavaCompletionProposalComputer</code>. */
+ private final String fClass;
+ /** The activate attribute value. */
+ private final boolean fActivate;
+ /** The partition of the extension (element type: {@link String}). */
+ private final Set<String> fPartitions;
+ /** The configuration element of this extension. */
+ private final IConfigurationElement fElement;
+ /** The registry we are registered with. */
+ private final CompletionProposalComputerRegistry fRegistry;
+ /** The computer, if instantiated, <code>null</code> otherwise. */
+ private IJavaCompletionProposalComputer fComputer;
+ /** The ui category. */
+ private final CompletionProposalCategory fCategory;
+ /** The first error message in the most recent operation, or <code>null</code>. */
+ private String fLastError;
+ /**
+ * Tells whether to inform the user when <code>MAX_DELAY</code> has been exceeded.
+ * We start timing execution after the first session because the first may take
+ * longer due to plug-in activation and initialization.
+ */
+ private boolean fIsReportingDelay= false;
+ /** The start of the last operation. */
+ private long fStart;
+ /**
+ * Tells whether we tried to load the computer.
+ * @since 3.4
+ */
+ boolean fTriedLoadingComputer= false;
+
+ /**
+ * Tells whether this proposal engine provides dynamic content that needs to be sorted after its
+ * proposal have been filtered. Filtering happens, e.g., when a user continues typing with an
+ * open completion window.
+ *
+ * @since 3.8
+ */
+ private boolean fNeedsSortingAfterFiltering;
+
+
+ /**
+ * Creates a new descriptor.
+ *
+ * @param element the configuration element to read
+ * @param registry the computer registry creating this descriptor
+ * @param categories the categories
+ * @throws InvalidRegistryObjectException if this extension is no longer valid
+ * @throws CoreException if the extension contains invalid values
+ */
+ CompletionProposalComputerDescriptor(IConfigurationElement element, CompletionProposalComputerRegistry registry, List<CompletionProposalCategory> categories) throws InvalidRegistryObjectException, CoreException {
+ Assert.isLegal(registry != null);
+ Assert.isLegal(element != null);
+
+ fRegistry= registry;
+ fElement= element;
+ IExtension extension= element.getDeclaringExtension();
+ fId= extension.getUniqueIdentifier();
+ checkNotNull(fId, "id"); //$NON-NLS-1$
+
+ String name= extension.getLabel();
+ if (name.length() == 0)
+ fName= fId;
+ else
+ fName= name;
+
+ Set<String> partitions= new HashSet<String>();
+ IConfigurationElement[] children= element.getChildren(PARTITION);
+ if (children.length == 0) {
+ fPartitions= PARTITION_SET; // add to all partition types if no partition is configured
+ } else {
+ for (int i= 0; i < children.length; i++) {
+ String type= children[i].getAttribute(TYPE);
+ checkNotNull(type, TYPE);
+ partitions.add(type);
+ }
+ fPartitions= Collections.unmodifiableSet(partitions);
+ }
+
+ String activateAttribute= element.getAttribute(ACTIVATE);
+ fActivate= Boolean.valueOf(activateAttribute).booleanValue();
+
+ String needsSortingAfterFilteringAttribute= element.getAttribute(NEEDS_SORTING_AFTER_FILTERING);
+ fNeedsSortingAfterFiltering= Boolean.valueOf(needsSortingAfterFilteringAttribute).booleanValue();
+
+ fClass= element.getAttribute(CLASS);
+ checkNotNull(fClass, CLASS);
+
+ String categoryId= element.getAttribute(CATEGORY_ID);
+ if (categoryId == null)
+ categoryId= DEFAULT_CATEGORY_ID;
+ CompletionProposalCategory category= null;
+ for (Iterator<CompletionProposalCategory> it= categories.iterator(); it.hasNext();) {
+ CompletionProposalCategory cat= it.next();
+ if (cat.getId().equals(categoryId)) {
+ category= cat;
+ break;
+ }
+ }
+ if (category == null) {
+ // create a category if it does not exist
+ fCategory= new CompletionProposalCategory(categoryId, fName, registry);
+ categories.add(fCategory);
+ } else {
+ fCategory= category;
+ }
+ }
+
+ /**
+ * Checks that the given attribute value is not <code>null</code>.
+ *
+ * @param value the object to check if not null
+ * @param attribute the attribute
+ * @throws InvalidRegistryObjectException if the registry element is no longer valid
+ * @throws CoreException if <code>value</code> is <code>null</code>
+ */
+ private void checkNotNull(Object value, String attribute) throws InvalidRegistryObjectException, CoreException {
+ if (value == null) {
+ Object[] args= { getId(), fElement.getContributor().getName(), attribute };
+ String message= Messages.format(JavaTextMessages.CompletionProposalComputerDescriptor_illegal_attribute_message, args);
+ IStatus status= new Status(IStatus.WARNING, JavaPlugin.getPluginId(), IStatus.OK, message, null);
+ throw new CoreException(status);
+ }
+ }
+
+ /**
+ * Returns the identifier of the described extension.
+ *
+ * @return Returns the id
+ */
+ public String getId() {
+ return fId;
+ }
+
+ /**
+ * Returns the name of the described extension.
+ *
+ * @return Returns the name
+ */
+ public String getName() {
+ return fName;
+ }
+
+ /**
+ * Returns the partition types of the described extension.
+ *
+ * @return the set of partition types (element type: {@link String})
+ */
+ public Set<String> getPartitions() {
+ return fPartitions;
+ }
+
+ /**
+ * Returns a cached instance of the computer as described in the
+ * extension's xml. If the computer is not yet created and
+ * <code>canCreate</code> is <code>true</code> then {@link #createComputer()}
+ * is called and the result cached.
+ *
+ * @param canCreate <code>true</code> if the proposal computer can be created
+ * @return a new instance of the completion proposal computer as
+ * described by this descriptor
+ * @throws CoreException if the creation fails
+ * @throws InvalidRegistryObjectException if the extension is not
+ * valid any longer (e.g. due to plug-in unloading)
+ */
+ private synchronized IJavaCompletionProposalComputer getComputer(boolean canCreate) throws CoreException, InvalidRegistryObjectException {
+ if (fComputer == null && canCreate && !fTriedLoadingComputer && (fActivate || isPluginLoaded())) {
+ fTriedLoadingComputer= true;
+ fComputer= createComputer();
+ }
+ return fComputer;
+ }
+
+ private boolean isPluginLoaded() {
+ Bundle bundle= getBundle();
+ return bundle != null && bundle.getState() == Bundle.ACTIVE;
+ }
+
+ private Bundle getBundle() {
+ String namespace= fElement.getDeclaringExtension().getContributor().getName();
+ Bundle bundle= Platform.getBundle(namespace);
+ return bundle;
+ }
+
+ /**
+ * Returns a new instance of the computer as described in the
+ * extension's xml. Note that the safest way to access the computer
+ * is by using the
+ * {@linkplain #computeCompletionProposals(ContentAssistInvocationContext, IProgressMonitor) computeCompletionProposals}
+ * and
+ * {@linkplain #computeContextInformation(ContentAssistInvocationContext, IProgressMonitor) computeContextInformation}
+ * methods. These delegate the functionality to the contributed
+ * computer, but handle instance creation and any exceptions thrown.
+ *
+ * @return a new instance of the completion proposal computer as
+ * described by this descriptor
+ * @throws CoreException if the creation fails
+ * @throws InvalidRegistryObjectException if the extension is not
+ * valid any longer (e.g. due to plug-in unloading)
+ */
+ public IJavaCompletionProposalComputer createComputer() throws CoreException, InvalidRegistryObjectException {
+ return (IJavaCompletionProposalComputer) fElement.createExecutableExtension(CLASS);
+ }
+
+ /**
+ * Safely computes completion proposals through the described extension. If the extension
+ * is disabled, throws an exception or otherwise does not adhere to the contract described in
+ * {@link IJavaCompletionProposalComputer}, an empty list is returned.
+ *
+ * @param context the invocation context passed on to the extension
+ * @param monitor the progress monitor passed on to the extension
+ * @return the list of computed completion proposals (element type:
+ * {@link org.eclipse.jface.text.contentassist.ICompletionProposal})
+ */
+ public List<ICompletionProposal> computeCompletionProposals(ContentAssistInvocationContext context, IProgressMonitor monitor) {
+ if (!isEnabled())
+ return Collections.emptyList();
+
+ IStatus status;
+ try {
+ IJavaCompletionProposalComputer computer= getComputer(true);
+ if (computer == null) // not active yet
+ return Collections.emptyList();
+
+ try {
+ PerformanceStats stats= startMeter(context, computer);
+ List<ICompletionProposal> proposals= computer.computeCompletionProposals(context, monitor);
+ stopMeter(stats, COMPUTE_COMPLETION_PROPOSALS);
+
+ if (proposals != null) {
+ fLastError= computer.getErrorMessage();
+ return proposals;
+ }
+ } finally {
+ fIsReportingDelay= true;
+ }
+ status= createAPIViolationStatus(COMPUTE_COMPLETION_PROPOSALS);
+ } catch (InvalidRegistryObjectException x) {
+ status= createExceptionStatus(x);
+ } catch (CoreException x) {
+ status= createExceptionStatus(x);
+ } catch (RuntimeException x) {
+ status= createExceptionStatus(x);
+ } finally {
+ monitor.done();
+ }
+
+ fRegistry.informUser(this, status);
+
+ return Collections.emptyList();
+ }
+
+ /**
+ * Safely computes context information objects through the described extension. If the extension
+ * is disabled, throws an exception or otherwise does not adhere to the contract described in
+ * {@link IJavaCompletionProposalComputer}, an empty list is returned.
+ *
+ * @param context the invocation context passed on to the extension
+ * @param monitor the progress monitor passed on to the extension
+ * @return the list of computed context information objects (element type:
+ * {@link org.eclipse.jface.text.contentassist.IContextInformation})
+ */
+ public List<IContextInformation> computeContextInformation(ContentAssistInvocationContext context, IProgressMonitor monitor) {
+ if (!isEnabled())
+ return Collections.emptyList();
+
+ IStatus status;
+ try {
+ IJavaCompletionProposalComputer computer= getComputer(true);
+ if (computer == null) // not active yet
+ return Collections.emptyList();
+
+ PerformanceStats stats= startMeter(context, computer);
+ List<IContextInformation> proposals= computer.computeContextInformation(context, monitor);
+ stopMeter(stats, COMPUTE_CONTEXT_INFORMATION);
+
+ if (proposals != null) {
+ fLastError= computer.getErrorMessage();
+ return proposals;
+ }
+
+ status= createAPIViolationStatus(COMPUTE_CONTEXT_INFORMATION);
+ } catch (InvalidRegistryObjectException x) {
+ status= createExceptionStatus(x);
+ } catch (CoreException x) {
+ status= createExceptionStatus(x);
+ } catch (RuntimeException x) {
+ status= createExceptionStatus(x);
+ } finally {
+ monitor.done();
+ }
+
+ fRegistry.informUser(this, status);
+
+ return Collections.emptyList();
+ }
+
+
+ /**
+ * Notifies the described extension of a proposal computation session start.
+ * <p><em>
+ * Note: This method is called every time code assist is invoked and
+ * is <strong>not</strong> filtered by partition type.
+ * </em></p>
+ */
+ public void sessionStarted() {
+ if (!isEnabled())
+ return;
+
+ IStatus status;
+ try {
+ IJavaCompletionProposalComputer computer= getComputer(true);
+ if (computer == null) // not active yet
+ return;
+
+ PerformanceStats stats= startMeter(SESSION_STARTED, computer);
+ computer.sessionStarted();
+ stopMeter(stats, SESSION_ENDED);
+
+ return;
+ } catch (InvalidRegistryObjectException x) {
+ status= createExceptionStatus(x);
+ } catch (CoreException x) {
+ status= createExceptionStatus(x);
+ } catch (RuntimeException x) {
+ status= createExceptionStatus(x);
+ }
+
+ fRegistry.informUser(this, status);
+ }
+
+ /**
+ * Notifies the described extension of a proposal computation session end.
+ * <p><em>
+ * Note: This method is called every time code assist is invoked and
+ * is <strong>not</strong> filtered by partition type.
+ * </em></p>
+ */
+ public void sessionEnded() {
+ if (!isEnabled())
+ return;
+
+ IStatus status;
+ try {
+ IJavaCompletionProposalComputer computer= getComputer(false);
+ if (computer == null) // not active yet
+ return;
+
+ PerformanceStats stats= startMeter(SESSION_ENDED, computer);
+ computer.sessionEnded();
+ stopMeter(stats, SESSION_ENDED);
+
+ return;
+ } catch (InvalidRegistryObjectException x) {
+ status= createExceptionStatus(x);
+ } catch (CoreException x) {
+ status= createExceptionStatus(x);
+ } catch (RuntimeException x) {
+ status= createExceptionStatus(x);
+ }
+
+ fRegistry.informUser(this, status);
+ }
+
+ private PerformanceStats startMeter(Object context, IJavaCompletionProposalComputer computer) {
+ final PerformanceStats stats;
+ if (MEASURE_PERFORMANCE) {
+ stats= PerformanceStats.getStats(PERFORMANCE_EVENT, computer);
+ stats.startRun(context.toString());
+ } else {
+ stats= null;
+ }
+
+ if (fIsReportingDelay) {
+ fStart= System.currentTimeMillis();
+ }
+
+ return stats;
+ }
+
+ private void stopMeter(final PerformanceStats stats, String operation) {
+ if (MEASURE_PERFORMANCE) {
+ stats.endRun();
+ if (stats.isFailure()) {
+ IStatus status= createPerformanceStatus(operation);
+ fRegistry.informUser(this, status);
+ return;
+ }
+ }
+
+ if (fIsReportingDelay) {
+ long current= System.currentTimeMillis();
+ if (current - fStart > MAX_DELAY) {
+ IStatus status= createPerformanceStatus(operation);
+ fRegistry.informUser(this, status);
+ }
+ }
+ }
+
+ private IStatus createExceptionStatus(InvalidRegistryObjectException x) {
+ // extension has become invalid - log & disable
+ String blame= createBlameMessage();
+ String reason= JavaTextMessages.CompletionProposalComputerDescriptor_reason_invalid;
+ return new Status(IStatus.INFO, JavaPlugin.getPluginId(), IStatus.OK, blame + " " + reason, x); //$NON-NLS-1$
+ }
+
+ private IStatus createExceptionStatus(CoreException x) {
+ // unable to instantiate the extension - log
+ String blame= createBlameMessage();
+ String reason= JavaTextMessages.CompletionProposalComputerDescriptor_reason_instantiation;
+ return new Status(IStatus.ERROR, JavaPlugin.getPluginId(), IStatus.OK, blame + " " + reason, x); //$NON-NLS-1$
+ }
+
+ private IStatus createExceptionStatus(RuntimeException x) {
+ // misbehaving extension - log
+ String blame= createBlameMessage();
+ String reason= JavaTextMessages.CompletionProposalComputerDescriptor_reason_runtime_ex;
+ return new Status(IStatus.WARNING, JavaPlugin.getPluginId(), IStatus.OK, blame + " " + reason, x); //$NON-NLS-1$
+ }
+
+ private IStatus createAPIViolationStatus(String operation) {
+ String blame= createBlameMessage();
+ Object[] args= {operation};
+ String reason= Messages.format(JavaTextMessages.CompletionProposalComputerDescriptor_reason_API, args);
+ return new Status(IStatus.WARNING, JavaPlugin.getPluginId(), IStatus.OK, blame + " " + reason, null); //$NON-NLS-1$
+ }
+
+ private IStatus createPerformanceStatus(String operation) {
+ String blame= createBlameMessage();
+ Object[] args= {operation};
+ String reason= Messages.format(JavaTextMessages.CompletionProposalComputerDescriptor_reason_performance, args);
+ return new Status(IStatus.WARNING, JavaPlugin.getPluginId(), IStatus.OK, blame + " " + reason, null); //$NON-NLS-1$
+ }
+
+ private String createBlameMessage() {
+ Object[] args= { getName(), fElement.getDeclaringExtension().getContributor().getName() };
+ String disable= Messages.format( JavaTextMessages.CompletionProposalComputerDescriptor_blame_message, args);
+ return disable;
+ }
+
+ /**
+ * Returns the enablement state of the described extension.
+ *
+ * @return the enablement state of the described extension
+ */
+ private boolean isEnabled() {
+ return fCategory.isEnabled();
+ }
+
+ CompletionProposalCategory getCategory() {
+ return fCategory;
+ }
+
+ /**
+ * Returns the error message from the described extension.
+ *
+ * @return the error message from the described extension
+ */
+ public String getErrorMessage() {
+ return fLastError;
+ }
+
+ /**
+ * Returns the contributor of the described extension.
+ *
+ * @return the contributor of the described extension
+ */
+ IContributor getContributor() {
+ try {
+ return fElement.getContributor();
+ } catch (InvalidRegistryObjectException e) {
+ return null;
+ }
+ }
+
+ /**
+ * Returns the <code>needsSortingAfterFiltering</code> flag of the described extension.
+ *
+ * @return the needsSortingAfterFiltering flag of the described extension
+ * @since 3.8
+ */
+ public boolean isSortingAfterFilteringNeeded() {
+ return fNeedsSortingAfterFiltering;
+ }
+}
git://git.uio.no / ifi-stolz-refaktor.git / blobdiff