Attachment #170325 for bug #314628

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




	/**
	 * @since 3.0
	 */
	public void executeWithTargetAvailable(IDMContext ctx, Sequence.Step[] steps, final RequestMonitor rm) {
		Vector<Step> totalStepsVector = new Vector<Step>();
		totalStepsVector.add(new IsTargetAvailableStep(ctx));
		totalStepsVector.add(new MakeTargetAvailableStep());
		for (Step step : steps) {
			totalStepsVector.add(step);
		}
		
		RequestMonitor cleanupRm = new RequestMonitor(getExecutor(), rm) {
			@Override
			protected void handleCompleted() {
				rm.setStatus(getStatus());
				RestoreTargetState(new RequestMonitor(getExecutor(), rm) {
					@Override
					protected void handleCompleted() {
						rm.done();					
					}
				});
			}
		};
		
		final Step[] totalSteps = totalStepsVector.toArray(new Step[totalStepsVector.size()]);
		getExecutor().execute(new Sequence(getExecutor(), cleanupRm) {
			@Override public Step[] getSteps() { return totalSteps; }
		});
	}

	 * ******************************************************************************/
	private IContainerDMContext fContainerDmc  = null;
	private boolean fTargetAvailable = false;
	private boolean fMustResumeTarget = false;

	/**
	 * Returns whether the target is available to perform operations

				suspend(getContextToSuspend(), 
						new RequestMonitor(getExecutor(), rm) {
					@Override
					protected void handleSuccess() {
						fMustResumeTarget = true;
						super.handleSuccess();
					}
					@Override
					protected void handleFailure() {
						// We weren't able to suspend, so abort the operation
						fDisableNextSignalEvent = false;

	/**
	 * @since 3.0
	 */
	protected void RestoreTargetState(RequestMonitor rm) {
			if (fMustResumeTarget) {
		public void execute(final RequestMonitor rm) {
			if (!isTargetAvailable()) {
				assert fDisableNextRunningEvent == false;
				fDisableNextRunningEvent = true;
				

						new DataRequestMonitor<MIInfo>(getExecutor(), rm) {
							@Override
							protected void handleSuccess() {
								fMustResumeTarget = false;
								fSilencedSignalEvent = null;
								super.handleSuccess();
							}

							protected void handleFailure() {
								// Darn, we're unable to restart the target.  Must cleanup!
								fDisableNextRunningEvent = false;
								fMustResumeTarget = false;

								// We must also sent the Stopped event that we had kept silent
								if (fSilencedSignalEvent != null) {
									eventDispatched(fSilencedSignalEvent);

				rm.done();
			}
		}
	 };

	/**
	 * {@inheritDoc}

Return to bug 314628

Lines 908-924 Link Here

(-)src/org/eclipse/cdt/dsf/mi/service/MIRunControl.java (-9 / +26 lines)
908	/**	908	/**
909	* @since 3.0	909	* @since 3.0
910	*/	910	*/
911	public void executeWithTargetAvailable(IDMContext ctx, Sequence.Step[] steps, RequestMonitor rm) {	911	public void executeWithTargetAvailable(IDMContext ctx, Sequence.Step[] steps, final RequestMonitor rm) {
912	Vector<Step> totalStepsVector = new Vector<Step>();	912	Vector<Step> totalStepsVector = new Vector<Step>();
913	totalStepsVector.add(new IsTargetAvailableStep(ctx));	913	totalStepsVector.add(new IsTargetAvailableStep(ctx));
914	totalStepsVector.add(new MakeTargetAvailableStep());	914	totalStepsVector.add(new MakeTargetAvailableStep());
915	for (Step step : steps) {	915	for (Step step : steps) {
916	totalStepsVector.add(step);	916	totalStepsVector.add(step);
917	}	917	}
918	totalStepsVector.add(new RestoreTargetStateStep());	918
		919	RequestMonitor cleanupRm = new RequestMonitor(getExecutor(), rm) {
		920	@Override
		921	protected void handleCompleted() {
		922	rm.setStatus(getStatus());
		923	RestoreTargetState(new RequestMonitor(getExecutor(), rm) {
		924	@Override
		925	protected void handleCompleted() {
		926	rm.done();
		927	}
		928	});
		929	}
		930	};
919		931
920	final Step[] totalSteps = totalStepsVector.toArray(new Step[totalStepsVector.size()]);	932	final Step[] totalSteps = totalStepsVector.toArray(new Step[totalStepsVector.size()]);
921	getExecutor().execute(new Sequence(getExecutor(), rm) {	933	getExecutor().execute(new Sequence(getExecutor(), cleanupRm) {
922	@Override public Step[] getSteps() { return totalSteps; }	934	@Override public Step[] getSteps() { return totalSteps; }
923	});	935	});
924	}	936	}
Lines 936-941 Link Here
936	* ******************************************************************************/	948	* ******************************************************************************/
937	private IContainerDMContext fContainerDmc = null;	949	private IContainerDMContext fContainerDmc = null;
938	private boolean fTargetAvailable = false;	950	private boolean fTargetAvailable = false;
		951	private boolean fMustResumeTarget = false;
939		952
940	/**	953	/**
941	* Returns whether the target is available to perform operations	954	* Returns whether the target is available to perform operations
Lines 1002-1007 Link Here
1002	suspend(getContextToSuspend(),	1015	suspend(getContextToSuspend(),
1003	new RequestMonitor(getExecutor(), rm) {	1016	new RequestMonitor(getExecutor(), rm) {
1004	@Override	1017	@Override
		1018	protected void handleSuccess() {
		1019	fMustResumeTarget = true;
		1020	super.handleSuccess();
		1021	}
		1022	@Override
1005	protected void handleFailure() {	1023	protected void handleFailure() {
1006	// We weren't able to suspend, so abort the operation	1024	// We weren't able to suspend, so abort the operation
1007	fDisableNextSignalEvent = false;	1025	fDisableNextSignalEvent = false;
Lines 1017-1026 Link Here
1017	/**	1035	/**
1018	* @since 3.0	1036	* @since 3.0
1019	*/	1037	*/
1020	protected class RestoreTargetStateStep extends Sequence.Step {	1038	protected void RestoreTargetState(RequestMonitor rm) {
1021	@Override	1039	if (fMustResumeTarget) {
1022	public void execute(final RequestMonitor rm) {
1023	if (!isTargetAvailable()) {
1024	assert fDisableNextRunningEvent == false;	1040	assert fDisableNextRunningEvent == false;
1025	fDisableNextRunningEvent = true;	1041	fDisableNextRunningEvent = true;
1026		1042
Lines 1031-1036 Link Here
1031	new DataRequestMonitor<MIInfo>(getExecutor(), rm) {	1047	new DataRequestMonitor<MIInfo>(getExecutor(), rm) {
1032	@Override	1048	@Override
1033	protected void handleSuccess() {	1049	protected void handleSuccess() {
		1050	fMustResumeTarget = false;
1034	fSilencedSignalEvent = null;	1051	fSilencedSignalEvent = null;
1035	super.handleSuccess();	1052	super.handleSuccess();
1036	}	1053	}
Lines 1039-1045 Link Here
1039	protected void handleFailure() {	1056	protected void handleFailure() {
1040	// Darn, we're unable to restart the target. Must cleanup!	1057	// Darn, we're unable to restart the target. Must cleanup!
1041	fDisableNextRunningEvent = false;	1058	fDisableNextRunningEvent = false;
1042		1059	fMustResumeTarget = false;
		1060
1043	// We must also sent the Stopped event that we had kept silent	1061	// We must also sent the Stopped event that we had kept silent
1044	if (fSilencedSignalEvent != null) {	1062	if (fSilencedSignalEvent != null) {
1045	eventDispatched(fSilencedSignalEvent);	1063	eventDispatched(fSilencedSignalEvent);
Lines 1058-1064 Link Here
1058	rm.done();	1076	rm.done();
1059	}	1077	}
1060	}	1078	}
1061	};
1062		1079
1063	/**	1080	/**
1064	* {@inheritDoc}	1081	* {@inheritDoc}