Skip to main content
aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--org.eclipse.debug.core/core/org/eclipse/debug/core/commands/AbstractDebugCommand.java815
1 files changed, 407 insertions, 408 deletions
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/core/commands/AbstractDebugCommand.java b/org.eclipse.debug.core/core/org/eclipse/debug/core/commands/AbstractDebugCommand.java
index d131619fc..1dc6b994b 100644
--- a/org.eclipse.debug.core/core/org/eclipse/debug/core/commands/AbstractDebugCommand.java
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/core/commands/AbstractDebugCommand.java
@@ -1,408 +1,407 @@
-/*******************************************************************************
- * Copyright (c) 2006, 2009 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- * IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.eclipse.debug.core.commands;
-
-import java.util.LinkedHashSet;
-
-import org.eclipse.core.runtime.CoreException;
-import org.eclipse.core.runtime.IProgressMonitor;
-import org.eclipse.core.runtime.IStatus;
-import org.eclipse.core.runtime.Status;
-import org.eclipse.core.runtime.jobs.IJobChangeEvent;
-import org.eclipse.core.runtime.jobs.IJobChangeListener;
-import org.eclipse.core.runtime.jobs.ISchedulingRule;
-import org.eclipse.core.runtime.jobs.Job;
-import org.eclipse.debug.core.DebugPlugin;
-import org.eclipse.debug.core.IRequest;
-import org.eclipse.debug.internal.core.DebugOptions;
-
-/**
- * Abstract implementation of a debug command handler. Handles {@link IDebugCommandRequest}
- * and {@link IEnabledStateRequest} updates asynchronously using jobs.
- * <p>
- * Clients may subclass this class.
- * </p>
- * @since 3.6
- */
-public abstract class AbstractDebugCommand implements IDebugCommandHandler {
-
- /**
- * Job to update enabled state of action.
- */
- private class UpdateJob extends Job implements IJobChangeListener {
-
- /**
- * The request to update
- */
- private IEnabledStateRequest request;
-
- /**
- * Whether this job has been run
- */
- private boolean run = false;
-
- /**
- * Creates a new job to update the specified request
- *
- * @param stateRequest
- */
- UpdateJob(IEnabledStateRequest stateRequest) {
- super(getEnabledStateTaskName());
- request = stateRequest;
- setSystem(true);
- setRule(getEnabledStateSchedulingRule(request));
- getJobManager().addJobChangeListener(this);
- }
-
- /* (non-Javadoc)
- * @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor)
- */
- protected IStatus run(IProgressMonitor monitor) {
- run = true;
- if (DebugOptions.DEBUG_COMMANDS) {
- System.out.print("can execute command: " + AbstractDebugCommand.this); //$NON-NLS-1$
- }
- if (monitor.isCanceled()) {
- if (DebugOptions.DEBUG_COMMANDS) {
- System.out.println(" >> *CANCELED* <<"); //$NON-NLS-1$
- }
- request.cancel();
- }
- Object[] elements = request.getElements();
- Object[] targets = new Object[elements.length];
- if (!request.isCanceled()) {
- for (int i = 0; i < elements.length; i++) {
- targets[i] = getTarget(elements[i]);
- if (targets[i] == null) {
- request.setEnabled(false);
- request.cancel();
- if (DebugOptions.DEBUG_COMMANDS) {
- System.out.println(" >> false (no adapter)"); //$NON-NLS-1$
- }
- }
- }
- if (monitor.isCanceled()) {
- request.cancel();
- }
- }
- if (!request.isCanceled()) {
- targets = coalesce(targets);
- monitor.beginTask(getEnabledStateTaskName(), targets.length);
- try {
- boolean executable = isExecutable(targets, monitor, request);
- if (DebugOptions.DEBUG_COMMANDS) {
- System.out.println(" >> " + executable); //$NON-NLS-1$
- }
- request.setEnabled(executable);
- } catch (CoreException e) {
- request.setStatus(e.getStatus());
- request.setEnabled(false);
- if (DebugOptions.DEBUG_COMMANDS) {
- System.out.println(" >> ABORTED"); //$NON-NLS-1$
- System.out.println("\t" + e.getStatus().getMessage()); //$NON-NLS-1$
- }
- }
- }
- monitor.setCanceled(request.isCanceled());
- request.done();
- monitor.done();
- return Status.OK_STATUS;
- }
-
- /* (non-Javadoc)
- * @see org.eclipse.core.runtime.jobs.Job#belongsTo(java.lang.Object)
- */
- public boolean belongsTo(Object family) {
- Object myFamily = getEnabledStateJobFamily(request);
- if (myFamily != null) {
- return myFamily.equals(family);
- }
- return false;
- }
-
- public void aboutToRun(IJobChangeEvent event) {
- }
-
- public void awake(IJobChangeEvent event) {
- }
-
- public void done(IJobChangeEvent event) {
- if (event.getJob() == this) {
- if (!run) {
- request.cancel();
- request.done();
- if (DebugOptions.DEBUG_COMMANDS) {
- System.out.println(" >> *CANCELED* <<" + AbstractDebugCommand.this); //$NON-NLS-1$
- }
- }
- getJobManager().removeJobChangeListener(this);
- }
- }
-
- public void running(IJobChangeEvent event) {
- }
-
- public void scheduled(IJobChangeEvent event) {
- }
-
- public void sleeping(IJobChangeEvent event) {
- }
-
- }
-
- /**
- * Scheduling rule to serialize commands on an object
- */
- private class SerialPerObjectRule implements ISchedulingRule {
-
- private Object fObject = null;
-
- public SerialPerObjectRule(Object lock) {
- fObject = lock;
- }
-
- /*
- * (non-Javadoc)
- *
- * @see org.eclipse.core.runtime.jobs.ISchedulingRule#contains(org.eclipse.core.runtime.jobs.ISchedulingRule)
- */
- public boolean contains(ISchedulingRule rule) {
- return rule == this;
- }
-
- /*
- * (non-Javadoc)
- *
- * @see org.eclipse.core.runtime.jobs.ISchedulingRule#isConflicting(org.eclipse.core.runtime.jobs.ISchedulingRule)
- */
- public boolean isConflicting(ISchedulingRule rule) {
- if (rule instanceof SerialPerObjectRule) {
- SerialPerObjectRule vup = (SerialPerObjectRule) rule;
- return fObject == vup.fObject;
- }
- return false;
- }
-
- }
-
- /* (non-Javadoc)
- * @see org.eclipse.debug.core.commands.IDebugCommandHandler#execute(org.eclipse.debug.core.commands.IDebugCommandRequest)
- */
- public boolean execute(final IDebugCommandRequest request) {
- Job job = new Job(getExecuteTaskName()) {
- protected IStatus run(IProgressMonitor monitor) {
- if (DebugOptions.DEBUG_COMMANDS) {
- System.out.println("execute: " + AbstractDebugCommand.this); //$NON-NLS-1$
- }
- Object[] elements = request.getElements();
- Object[] targets = new Object[elements.length];
- for (int i = 0; i < elements.length; i++) {
- targets[i]= getTarget(elements[i]);
- }
- targets = coalesce(targets);
- monitor.beginTask(getExecuteTaskName(), targets.length);
- try {
- doExecute(targets, monitor, request);
- } catch (CoreException e) {
- request.setStatus(e.getStatus());
- if (DebugOptions.DEBUG_COMMANDS) {
- System.out.println("\t" + e.getStatus().getMessage()); //$NON-NLS-1$
- }
- }
- request.done();
- monitor.setCanceled(request.isCanceled());
- monitor.done();
- return Status.OK_STATUS;
- }
- public boolean belongsTo(Object family) {
- Object jobFamily = getExecuteJobFamily(request);
- if (jobFamily != null) {
- return jobFamily.equals(family);
- }
- return false;
- }
- };
- job.setSystem(true);
- job.setRule(getExecuteSchedulingRule(request));
- job.schedule();
- return isRemainEnabled(request);
- }
-
- /**
- * Returns whether this command should remain enabled after starting execution of the specified request.
- *
- * @param request the request being executed
- * @return whether to remain enabled while executing the request
- */
- protected boolean isRemainEnabled(IDebugCommandRequest request) {
- return false;
- }
-
- /* (non-Javadoc)
- * @see org.eclipse.debug.core.commands.IDebugCommandHandler#canExecute(org.eclipse.debug.core.commands.IEnabledStateRequest)
- */
- public void canExecute(final IEnabledStateRequest request) {
- Job job = new UpdateJob(request);
- job.schedule();
- }
-
- /**
- * Returns the name to use for a job and progress monitor task names when performing
- * an {@link IEnabledStateRequest}.
- *
- * @return task name
- */
- protected String getEnabledStateTaskName() {
- // this is a system job name and does not need to be NLS'd
- return "Check Debug Command"; //$NON-NLS-1$
- }
-
- /**
- * Returns the name to use for jobs and progress monitor task names when executing
- * an {@link IDebugCommandRequest}.
- *
- * @return task name
- */
- protected String getExecuteTaskName() {
- // this is a system job name and does not need to be NLS'd
- return "Execute Debug Command"; //$NON-NLS-1$
- }
-
- /**
- * Executes this command synchronously on the specified targets, reporting progress. This method
- * is called by a job. If an exception is thrown, the calling job will set the associated status
- * on the request object. The calling job also calls #done() on the request object after this method
- * is called, and sets a cancel status on the progress monitor if the request is canceled.
- * <p>
- * Handlers must override this method.
- * </p>
- * @param targets objects to perform this command on
- * @param monitor progress monitor
- * @param request can be used to cancel this command
- * @exception CoreException if this handler fails to perform the request
- */
- protected abstract void doExecute(Object[] targets, IProgressMonitor monitor, IRequest request) throws CoreException;
-
- /**
- * Returns whether this command is executable on the specified targets, reporting progress. This method
- * is called by a job. If an exception is thrown, the calling job will set the associated status
- * on the request object and report that this command is not enabled. The calling job also calls #done()
- * on the request object after this method is called, and sets a cancel status on the progress monitor if
- * the request is canceled. Enabled state is set to <code>false</code> if the request is canceled.
- * <p>
- * Handlers must override this method.
- * </p>
- * @param targets objects to check command enabled state for
- * @param monitor progress monitor
- * @param request can be used to cancel this update request
- * @return whether this command can be executed for the given targets
- */
- protected abstract boolean isExecutable(Object[] targets, IProgressMonitor monitor, IEnabledStateRequest request) throws CoreException;
-
- /**
- * Returns the appropriate target for this command handler for the given object.
- * This method is called to map each element in a command request to the target
- * object that is used in {@link #doExecute(Object[], IProgressMonitor, IRequest)}
- * and {@link #isExecutable(Object[], IProgressMonitor, IEnabledStateRequest)}.
- * The target may be the element itself, or some other object. Allows for redirection.
- * <p>
- * Clients must override this method.
- * </p>
- * @param element element from a {@link IDebugCommandRequest}
- * @return associated target object for execution or enabled state update. Cannot return <code>null</code>.
- */
- protected abstract Object getTarget(Object element);
-
- /**
- * Convenience method to return an adapter of the specified type for the given object or <code>null</code>
- * if none.
- *
- * @param element element to retrieve adapter for
- * @param type adapter type
- * @return adapter or <code>null</code>
- * @see {@link DebugPlugin#getAdapter(Object, Class)}
- */
- protected Object getAdapter(Object element, Class type) {
- return DebugPlugin.getAdapter(element, type);
- }
-
- /**
- * Returns a scheduling rule for this command's {@link IEnabledStateRequest} update job
- * or <code>null</code> if none. By default a rule is created to serialize
- * jobs on the first element in the request.
- * <p>
- * Clients may override this method as required.
- * </p>
- * @param request request that a scheduling rule is required for
- * @return scheduling rule or <code>null</code>
- */
- protected ISchedulingRule getEnabledStateSchedulingRule(IDebugCommandRequest request) {
- return new SerialPerObjectRule(request.getElements()[0]);
- }
-
- /**
- * Returns a scheduling rule for this command's {@link IDebugCommandRequest} execute job
- * or <code>null</code> if none. By default, execution jobs have no scheduling rule.
- * <p>
- * Clients may override this method as required.
- * </p>
- * @param request request that a scheduling rule is required for
- * @return scheduling rule or <code>null</code>
- */
- protected ISchedulingRule getExecuteSchedulingRule(IDebugCommandRequest request) {
- return null;
- }
-
- /**
- * Returns the job family for the this command's {@link IEnabledStateRequest} update job
- * or <code>null</code> if none. The default implementation returns <code>null</code>.
- * <p>
- * Clients may override this method as required.
- * </p>
- * @param request request the job family is required for
- * @return job family object or <code>null</code> if none
- */
- protected Object getEnabledStateJobFamily(IDebugCommandRequest request) {
- return null;
- }
-
- /**
- * Returns the job family for the this command's {@link IDebugCommandRequest} execute job
- * or <code>null</code> if none. The default implementation returns <code>null</code>.
- * <p>
- * Clients may override this method as required.
- * </p>
- * @param request request the job family is required for
- * @return job family object or <code>null</code> if none
- */
- protected Object getExecuteJobFamily(IDebugCommandRequest request) {
- return null;
- }
-
- /**
- * Returns an array of objects with duplicates removed, if any.
- *
- * @param objects array of objects
- * @return array of object in same order with duplicates removed, if any.
- */
- private Object[] coalesce(Object[] objects) {
- if (objects.length == 1) {
- return objects;
- } else {
- LinkedHashSet set = new LinkedHashSet(objects.length);
- for (int i = 0; i < objects.length; i++) {
- set.add(objects[i]);
- }
- return set.toArray();
- }
- }
-
-}
+/*******************************************************************************
+ * Copyright (c) 2006, 2009 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.debug.core.commands;
+
+import java.util.LinkedHashSet;
+
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.core.runtime.jobs.IJobChangeEvent;
+import org.eclipse.core.runtime.jobs.IJobChangeListener;
+import org.eclipse.core.runtime.jobs.ISchedulingRule;
+import org.eclipse.core.runtime.jobs.Job;
+import org.eclipse.debug.core.DebugPlugin;
+import org.eclipse.debug.core.IRequest;
+import org.eclipse.debug.internal.core.DebugOptions;
+
+/**
+ * Abstract implementation of a debug command handler. Handles {@link IDebugCommandRequest}
+ * and {@link IEnabledStateRequest} updates asynchronously using jobs.
+ * <p>
+ * Clients may subclass this class.
+ * </p>
+ * @since 3.6
+ */
+public abstract class AbstractDebugCommand implements IDebugCommandHandler {
+
+ /**
+ * Job to update enabled state of action.
+ */
+ private class UpdateJob extends Job implements IJobChangeListener {
+
+ /**
+ * The request to update
+ */
+ private IEnabledStateRequest request;
+
+ /**
+ * Whether this job has been run
+ */
+ private boolean run = false;
+
+ /**
+ * Creates a new job to update the specified request
+ *
+ * @param stateRequest
+ */
+ UpdateJob(IEnabledStateRequest stateRequest) {
+ super(getEnabledStateTaskName());
+ request = stateRequest;
+ setSystem(true);
+ setRule(getEnabledStateSchedulingRule(request));
+ getJobManager().addJobChangeListener(this);
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor)
+ */
+ protected IStatus run(IProgressMonitor monitor) {
+ run = true;
+ if (DebugOptions.DEBUG_COMMANDS) {
+ System.out.print("can execute command: " + AbstractDebugCommand.this); //$NON-NLS-1$
+ }
+ if (monitor.isCanceled()) {
+ if (DebugOptions.DEBUG_COMMANDS) {
+ System.out.println(" >> *CANCELED* <<"); //$NON-NLS-1$
+ }
+ request.cancel();
+ }
+ Object[] elements = request.getElements();
+ Object[] targets = new Object[elements.length];
+ if (!request.isCanceled()) {
+ for (int i = 0; i < elements.length; i++) {
+ targets[i] = getTarget(elements[i]);
+ if (targets[i] == null) {
+ request.setEnabled(false);
+ request.cancel();
+ if (DebugOptions.DEBUG_COMMANDS) {
+ System.out.println(" >> false (no adapter)"); //$NON-NLS-1$
+ }
+ }
+ }
+ if (monitor.isCanceled()) {
+ request.cancel();
+ }
+ }
+ if (!request.isCanceled()) {
+ targets = coalesce(targets);
+ monitor.beginTask(getEnabledStateTaskName(), targets.length);
+ try {
+ boolean executable = isExecutable(targets, monitor, request);
+ if (DebugOptions.DEBUG_COMMANDS) {
+ System.out.println(" >> " + executable); //$NON-NLS-1$
+ }
+ request.setEnabled(executable);
+ } catch (CoreException e) {
+ request.setStatus(e.getStatus());
+ request.setEnabled(false);
+ if (DebugOptions.DEBUG_COMMANDS) {
+ System.out.println(" >> ABORTED"); //$NON-NLS-1$
+ System.out.println("\t" + e.getStatus().getMessage()); //$NON-NLS-1$
+ }
+ }
+ }
+ monitor.setCanceled(request.isCanceled());
+ request.done();
+ monitor.done();
+ return Status.OK_STATUS;
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.core.runtime.jobs.Job#belongsTo(java.lang.Object)
+ */
+ public boolean belongsTo(Object family) {
+ Object myFamily = getEnabledStateJobFamily(request);
+ if (myFamily != null) {
+ return myFamily.equals(family);
+ }
+ return false;
+ }
+
+ public void aboutToRun(IJobChangeEvent event) {
+ }
+
+ public void awake(IJobChangeEvent event) {
+ }
+
+ public void done(IJobChangeEvent event) {
+ if (event.getJob() == this) {
+ if (!run) {
+ request.cancel();
+ request.done();
+ if (DebugOptions.DEBUG_COMMANDS) {
+ System.out.println(" >> *CANCELED* <<" + AbstractDebugCommand.this); //$NON-NLS-1$
+ }
+ }
+ getJobManager().removeJobChangeListener(this);
+ }
+ }
+
+ public void running(IJobChangeEvent event) {
+ }
+
+ public void scheduled(IJobChangeEvent event) {
+ }
+
+ public void sleeping(IJobChangeEvent event) {
+ }
+
+ }
+
+ /**
+ * Scheduling rule to serialize commands on an object
+ */
+ private class SerialPerObjectRule implements ISchedulingRule {
+
+ private Object fObject = null;
+
+ public SerialPerObjectRule(Object lock) {
+ fObject = lock;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.eclipse.core.runtime.jobs.ISchedulingRule#contains(org.eclipse.core.runtime.jobs.ISchedulingRule)
+ */
+ public boolean contains(ISchedulingRule rule) {
+ return rule == this;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.eclipse.core.runtime.jobs.ISchedulingRule#isConflicting(org.eclipse.core.runtime.jobs.ISchedulingRule)
+ */
+ public boolean isConflicting(ISchedulingRule rule) {
+ if (rule instanceof SerialPerObjectRule) {
+ SerialPerObjectRule vup = (SerialPerObjectRule) rule;
+ return fObject == vup.fObject;
+ }
+ return false;
+ }
+
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.debug.core.commands.IDebugCommandHandler#execute(org.eclipse.debug.core.commands.IDebugCommandRequest)
+ */
+ public boolean execute(final IDebugCommandRequest request) {
+ Job job = new Job(getExecuteTaskName()) {
+ protected IStatus run(IProgressMonitor monitor) {
+ if (DebugOptions.DEBUG_COMMANDS) {
+ System.out.println("execute: " + AbstractDebugCommand.this); //$NON-NLS-1$
+ }
+ Object[] elements = request.getElements();
+ Object[] targets = new Object[elements.length];
+ for (int i = 0; i < elements.length; i++) {
+ targets[i]= getTarget(elements[i]);
+ }
+ targets = coalesce(targets);
+ monitor.beginTask(getExecuteTaskName(), targets.length);
+ try {
+ doExecute(targets, monitor, request);
+ } catch (CoreException e) {
+ request.setStatus(e.getStatus());
+ if (DebugOptions.DEBUG_COMMANDS) {
+ System.out.println("\t" + e.getStatus().getMessage()); //$NON-NLS-1$
+ }
+ }
+ request.done();
+ monitor.setCanceled(request.isCanceled());
+ monitor.done();
+ return Status.OK_STATUS;
+ }
+ public boolean belongsTo(Object family) {
+ Object jobFamily = getExecuteJobFamily(request);
+ if (jobFamily != null) {
+ return jobFamily.equals(family);
+ }
+ return false;
+ }
+ };
+ job.setSystem(true);
+ job.setRule(getExecuteSchedulingRule(request));
+ job.schedule();
+ return isRemainEnabled(request);
+ }
+
+ /**
+ * Returns whether this command should remain enabled after starting execution of the specified request.
+ *
+ * @param request the request being executed
+ * @return whether to remain enabled while executing the request
+ */
+ protected boolean isRemainEnabled(IDebugCommandRequest request) {
+ return false;
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.debug.core.commands.IDebugCommandHandler#canExecute(org.eclipse.debug.core.commands.IEnabledStateRequest)
+ */
+ public void canExecute(final IEnabledStateRequest request) {
+ Job job = new UpdateJob(request);
+ job.schedule();
+ }
+
+ /**
+ * Returns the name to use for a job and progress monitor task names when performing
+ * an {@link IEnabledStateRequest}.
+ *
+ * @return task name
+ */
+ protected String getEnabledStateTaskName() {
+ // this is a system job name and does not need to be NLS'd
+ return "Check Debug Command"; //$NON-NLS-1$
+ }
+
+ /**
+ * Returns the name to use for jobs and progress monitor task names when executing
+ * an {@link IDebugCommandRequest}.
+ *
+ * @return task name
+ */
+ protected String getExecuteTaskName() {
+ // this is a system job name and does not need to be NLS'd
+ return "Execute Debug Command"; //$NON-NLS-1$
+ }
+
+ /**
+ * Executes this command synchronously on the specified targets, reporting progress. This method
+ * is called by a job. If an exception is thrown, the calling job will set the associated status
+ * on the request object. The calling job also calls #done() on the request object after this method
+ * is called, and sets a cancel status on the progress monitor if the request is canceled.
+ * <p>
+ * Handlers must override this method.
+ * </p>
+ * @param targets objects to perform this command on
+ * @param monitor progress monitor
+ * @param request can be used to cancel this command
+ * @exception CoreException if this handler fails to perform the request
+ */
+ protected abstract void doExecute(Object[] targets, IProgressMonitor monitor, IRequest request) throws CoreException;
+
+ /**
+ * Returns whether this command is executable on the specified targets, reporting progress. This method
+ * is called by a job. If an exception is thrown, the calling job will set the associated status
+ * on the request object and report that this command is not enabled. The calling job also calls #done()
+ * on the request object after this method is called, and sets a cancel status on the progress monitor if
+ * the request is canceled. Enabled state is set to <code>false</code> if the request is canceled.
+ * <p>
+ * Handlers must override this method.
+ * </p>
+ * @param targets objects to check command enabled state for
+ * @param monitor progress monitor
+ * @param request can be used to cancel this update request
+ * @return whether this command can be executed for the given targets
+ */
+ protected abstract boolean isExecutable(Object[] targets, IProgressMonitor monitor, IEnabledStateRequest request) throws CoreException;
+
+ /**
+ * Returns the appropriate target for this command handler for the given object.
+ * This method is called to map each element in a command request to the target
+ * object that is used in {@link #doExecute(Object[], IProgressMonitor, IRequest)}
+ * and {@link #isExecutable(Object[], IProgressMonitor, IEnabledStateRequest)}.
+ * The target may be the element itself, or some other object. Allows for redirection.
+ * <p>
+ * Clients must override this method.
+ * </p>
+ * @param element element from a {@link IDebugCommandRequest}
+ * @return associated target object for execution or enabled state update. Cannot return <code>null</code>.
+ */
+ protected abstract Object getTarget(Object element);
+
+ /**
+ * Convenience method to return an adapter of the specified type for the given object or <code>null</code>
+ * if none.
+ *
+ * @param element element to retrieve adapter for
+ * @param type adapter type
+ * @return adapter or <code>null</code>
+ */
+ protected Object getAdapter(Object element, Class type) {
+ return DebugPlugin.getAdapter(element, type);
+ }
+
+ /**
+ * Returns a scheduling rule for this command's {@link IEnabledStateRequest} update job
+ * or <code>null</code> if none. By default a rule is created to serialize
+ * jobs on the first element in the request.
+ * <p>
+ * Clients may override this method as required.
+ * </p>
+ * @param request request that a scheduling rule is required for
+ * @return scheduling rule or <code>null</code>
+ */
+ protected ISchedulingRule getEnabledStateSchedulingRule(IDebugCommandRequest request) {
+ return new SerialPerObjectRule(request.getElements()[0]);
+ }
+
+ /**
+ * Returns a scheduling rule for this command's {@link IDebugCommandRequest} execute job
+ * or <code>null</code> if none. By default, execution jobs have no scheduling rule.
+ * <p>
+ * Clients may override this method as required.
+ * </p>
+ * @param request request that a scheduling rule is required for
+ * @return scheduling rule or <code>null</code>
+ */
+ protected ISchedulingRule getExecuteSchedulingRule(IDebugCommandRequest request) {
+ return null;
+ }
+
+ /**
+ * Returns the job family for the this command's {@link IEnabledStateRequest} update job
+ * or <code>null</code> if none. The default implementation returns <code>null</code>.
+ * <p>
+ * Clients may override this method as required.
+ * </p>
+ * @param request request the job family is required for
+ * @return job family object or <code>null</code> if none
+ */
+ protected Object getEnabledStateJobFamily(IDebugCommandRequest request) {
+ return null;
+ }
+
+ /**
+ * Returns the job family for the this command's {@link IDebugCommandRequest} execute job
+ * or <code>null</code> if none. The default implementation returns <code>null</code>.
+ * <p>
+ * Clients may override this method as required.
+ * </p>
+ * @param request request the job family is required for
+ * @return job family object or <code>null</code> if none
+ */
+ protected Object getExecuteJobFamily(IDebugCommandRequest request) {
+ return null;
+ }
+
+ /**
+ * Returns an array of objects with duplicates removed, if any.
+ *
+ * @param objects array of objects
+ * @return array of object in same order with duplicates removed, if any.
+ */
+ private Object[] coalesce(Object[] objects) {
+ if (objects.length == 1) {
+ return objects;
+ } else {
+ LinkedHashSet set = new LinkedHashSet(objects.length);
+ for (int i = 0; i < objects.length; i++) {
+ set.add(objects[i]);
+ }
+ return set.toArray();
+ }
+ }
+
+}

Back to the top