path: root/dsf/org.eclipse.cdt.dsf.ui/src/org/eclipse/cdt/dsf/debug/internal/ui/actions/AbstractDsfRegisterGroupActions.java

/*******************************************************************************
 * Copyright (c) 2014 Ericsson AB and others.
 *
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     Alvaro Sanchez-Leon (Ericsson) - First Implementation and API (Bug 235747)
 *******************************************************************************/
package org.eclipse.cdt.dsf.debug.internal.ui.actions;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.RejectedExecutionException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.eclipse.cdt.debug.core.model.IRegisterDescriptor;
import org.eclipse.cdt.debug.internal.core.model.IRegisterGroupDescriptor;
import org.eclipse.cdt.debug.internal.ui.actions.RegisterGroupDialog;
import org.eclipse.cdt.dsf.concurrent.ConfinedToDsfExecutor;
import org.eclipse.cdt.dsf.concurrent.CountingRequestMonitor;
import org.eclipse.cdt.dsf.concurrent.DataRequestMonitor;
import org.eclipse.cdt.dsf.concurrent.DsfExecutor;
import org.eclipse.cdt.dsf.concurrent.DsfRunnable;
import org.eclipse.cdt.dsf.concurrent.IDsfStatusConstants;
import org.eclipse.cdt.dsf.concurrent.Query;
import org.eclipse.cdt.dsf.concurrent.RequestMonitor;
import org.eclipse.cdt.dsf.datamodel.DMContexts;
import org.eclipse.cdt.dsf.datamodel.IDMContext;
import org.eclipse.cdt.dsf.debug.internal.ui.Messages;
import org.eclipse.cdt.dsf.debug.service.IRegisters;
import org.eclipse.cdt.dsf.debug.service.IRegisters.IRegisterDMContext;
import org.eclipse.cdt.dsf.debug.service.IRegisters.IRegisterDMData;
import org.eclipse.cdt.dsf.debug.service.IRegisters.IRegisterGroupDMContext;
import org.eclipse.cdt.dsf.debug.service.IRegisters.IRegisterGroupDMData;
import org.eclipse.cdt.dsf.debug.service.IRegisters2;
import org.eclipse.cdt.dsf.debug.service.IRunControl.IContainerDMContext;
import org.eclipse.cdt.dsf.internal.ui.DsfUIPlugin;
import org.eclipse.cdt.dsf.service.DsfServicesTracker;
import org.eclipse.cdt.dsf.service.DsfSession;
import org.eclipse.cdt.dsf.ui.viewmodel.datamodel.IDMVMContext;
import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.debug.core.DebugException;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.window.Window;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IWorkbenchPart;

public abstract class AbstractDsfRegisterGroupActions extends AbstractHandler {
	private static final String BLANK_STRING = ""; //$NON-NLS-1$
	private static final String REG_GROUP_ACTION_FAILED = "Register Group Action failed\n"; //$NON-NLS-1$

	private class RegisterGroupDialogRunnable implements Runnable {
		private String fGroupName = BLANK_STRING;
		private IRegisterDescriptor[] fSelectedRegisters = null;
		private final IRegisterDescriptor[] fallRegisters;
		private final Shell fShell;
		private final DataRequestMonitor<IRegisterGroupDescriptor> fMonitor;

		private RegisterGroupDialogRunnable(Shell shell, String groupName, IRegisterDescriptor[] allRegisters,
				IRegisterDescriptor[] selectedRegisters, DataRequestMonitor<IRegisterGroupDescriptor> rm) {
			fallRegisters = allRegisters;
			fSelectedRegisters = selectedRegisters;
			fShell = shell;
			fGroupName = groupName;
			fMonitor = rm;
		}

		@Override
		public void run() {
			RegisterGroupDialog dialog = new RegisterGroupDialog(fShell, fGroupName, fallRegisters, fSelectedRegisters);
			if (dialog.open() == Window.OK) {
				String groupName = dialog.getName();
				IRegisterDescriptor[] iSelectedRegisters = dialog.getDescriptors();
				IRegisterGroupDescriptor groupDescriptor = createGroupDescriptor(groupName, iSelectedRegisters);

				fMonitor.setData(groupDescriptor);
			} else {
				fMonitor.cancel();
				return;
			}

			fMonitor.done();
		}
	}

	private class RegisterDescriptor implements IRegisterDescriptor {
		private final IRegisterDMContext fRegContext;
		private String fOriginalGroupName = BLANK_STRING;
		private String fName = BLANK_STRING;

		private RegisterDescriptor(String groupName, IRegisterDMContext regContext, String name) {
			fRegContext = regContext;
			fName = name;
			// initial group Name
			fOriginalGroupName = groupName;
		}

		@Override
		public String getName() {
			return fName;
		}

		@Override
		public String getGroupName() {
			return fOriginalGroupName;
		}
	}

	private class SelectionDMContext {
		private final IDMContext fcontext;
		private final DsfSession fsession;

		private SelectionDMContext(IStructuredSelection selection) throws DebugException {
			if (!(selection.getFirstElement() instanceof IDMVMContext)) {
				abort("Unrecognized element from the provided register selection"); //$NON-NLS-1$
			}

			// Resolve the context
			IDMVMContext context = (IDMVMContext) selection.getFirstElement();
			fcontext = context.getDMContext();

			// Resolve the session
			String sessionId = fcontext.getSessionId();
			fsession = DsfSession.getSession(sessionId);

			if (fsession == null || !(fsession.isActive())) {
				abort("Sesssion inactive"); //$NON-NLS-1$
			}
		}

		/**
		 * This method has to be called under the executor's thread
		 */
		public IRegisters2 resolveService() throws DebugException {
			// Resolve the registers service
			DsfServicesTracker tracker = new DsfServicesTracker(DsfUIPlugin.getBundleContext(), fsession.getId());
			IRegisters service = tracker.getService(IRegisters.class, null);

			tracker.dispose();

			if (!(service instanceof IRegisters2)) {
				abort("Unable to resolve IRegisters2 service"); //$NON-NLS-1$
			}

			return (IRegisters2) service;
		}

		private void abort(String message) throws DebugException {
			// Interrupt on error
			IStatus status = new Status(IStatus.ERROR, DsfUIPlugin.PLUGIN_ID, IStatus.ERROR, message, null);
			throw new DebugException(status);
		}

	}

	private interface DialogRegisterProvider {
		public IRegisterDescriptor[] getAllRegisters();

		public IRegisterDescriptor[] getcheckedRegisters();
	}

	protected void addRegisterGroup(final IWorkbenchPart part, final IStructuredSelection selection) {
		try {
			final SelectionDMContext selectionContext = new SelectionDMContext(selection);
			selectionContext.fsession.getExecutor().execute(new DsfRunnable() {

				@Override
				public void run() {
					final IRegisters2 registersService;
					try {
						registersService = selectionContext.resolveService();
					} catch (CoreException e) {
						failed(e);
						return;
					}

					// continue to process
					processAddRegisterGroup(part.getSite().getShell(), selectionContext,
							resolveSelectedRegisters(selection), registersService);
				}
			});

		} catch (DebugException e) {
		}
	}

	protected boolean canAddRegisterGroup(IWorkbenchPart part, IStructuredSelection selection) {
		try {
			final SelectionDMContext selectionContext = new SelectionDMContext(selection);
			Query<Boolean> query = new Query<Boolean>() {
				@Override
				protected void execute(DataRequestMonitor<Boolean> rm) {
					IRegisters2 registersService;
					try {
						registersService = selectionContext.resolveService();
					} catch (DebugException e) {
						rm.setData(false);
						rm.done();
						return;
					}

					if (registersService != null) {
						registersService.canAddRegisterGroup(selectionContext.fcontext, rm);
					} else {
						rm.setData(false);
						rm.done();
					}
				}
			};
			selectionContext.fsession.getExecutor().execute(query);
			return query.get();
		} catch (RejectedExecutionException e) {
		} catch (InterruptedException e) {
		} catch (ExecutionException e) {
		} catch (DebugException e1) {
		}

		return false;
	}

	protected void editRegisterGroup(final IWorkbenchPart part, IStructuredSelection selection) {
		try {
			final SelectionDMContext selectionContext = new SelectionDMContext(selection);

			selectionContext.fsession.getExecutor().execute(new DsfRunnable() {
				@Override
				public void run() {
					// Create a services tracker
					final IRegisters2 registersService;
					try {
						registersService = selectionContext.resolveService();
					} catch (CoreException e) {
						failed(e);
						return;
					}

					processEditRegisterGroup(part.getSite().getShell(), selectionContext, registersService);
				}

			});
		} catch (DebugException e) {
		}
	}

	protected boolean canEditRegisterGroup(IWorkbenchPart part, IStructuredSelection selection) {
		try {
			final SelectionDMContext selectionContext = new SelectionDMContext(selection);
			final IDMContext context = selectionContext.fcontext;

			// The group to be edited needs to be selected
			if (!(context instanceof IRegisterGroupDMContext)) {
				return false;
			}

			Query<Boolean> query = new Query<Boolean>() {
				@Override
				protected void execute(final DataRequestMonitor<Boolean> rm) {
					IRegisters2 registersService;
					try {
						registersService = selectionContext.resolveService();
					} catch (DebugException e) {
						rm.setData(false);
						rm.done();
						return;
					}

					if (registersService != null) {
						registersService.canEditRegisterGroup((IRegisterGroupDMContext) context, rm);
					} else {
						rm.setData(false);
						rm.done();
					}
				}
			};
			selectionContext.fsession.getExecutor().execute(query);
			return query.get();

		} catch (RejectedExecutionException e) {
		} catch (InterruptedException e) {
		} catch (ExecutionException e) {
		} catch (DebugException e1) {
		}

		return false;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.cdt.debug.internal.ui.actions.IRegisterGroupActionsTarget#removeRegisterGroups(org.eclipse.ui.IWorkbenchPart, org.eclipse.jface.viewers.IStructuredSelection)
	 */
	protected void removeRegisterGroups(IWorkbenchPart part, IStructuredSelection selection) {
		try {
			final SelectionDMContext selectionContext = new SelectionDMContext(selection);

			final IRegisterGroupDMContext[] groups = resolveSelectedGroups(selection);
			selectionContext.fsession.getExecutor().execute(new DsfRunnable() {
				@Override
				public void run() {
					IRegisters2 registersService;
					try {
						registersService = selectionContext.resolveService();
					} catch (CoreException e) {
						failed(e);
						return;
					}

					registersService.removeRegisterGroups(groups,
							new RequestMonitor(registersService.getExecutor(), null) {
							});
				}
			});
		} catch (DebugException e) {
		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.cdt.debug.internal.ui.actions.IRegisterGroupActionsTarget#canRemoveRegisterGroups(org.eclipse.ui.IWorkbenchPart, org.eclipse.jface.viewers.IStructuredSelection)
	 */
	protected boolean canRemoveRegisterGroups(IWorkbenchPart part, IStructuredSelection selection) {
		final SelectionDMContext selectionContext;
		try {
			selectionContext = new SelectionDMContext(selection);
		} catch (DebugException e) {
			// No DM context present or group registers service found in the selection
			return false;
		}

		//resolve the selected groups
		final IRegisterGroupDMContext[] groups = resolveSelectedGroups(selection);
		if (groups == null || groups.length < 1) {
			return false;
		}

		//Prepare to Query the service and check if the selected groups can be removed
		Query<Boolean> query = new Query<Boolean>() {
			@Override
			protected void execute(DataRequestMonitor<Boolean> rm) {
				IRegisters2 regService;
				try {
					regService = selectionContext.resolveService();
				} catch (DebugException e) {
					// Unable to resolve the registers service
					rm.setData(false);
					rm.done();
					return;
				}

				regService.canRemoveRegisterGroups(groups, rm);
			}
		};

		//Execute the query
		selectionContext.fsession.getExecutor().execute(query);

		try {
			// return the answer from the service
			return query.get();
		} catch (InterruptedException e) {
		} catch (ExecutionException e) {
		}

		// No positive answer from the service
		return false;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.cdt.debug.internal.ui.actions.IRegisterGroupActionsTarget#restoreDefaultGroups(org.eclipse.ui.IWorkbenchPart, org.eclipse.jface.viewers.IStructuredSelection)
	 */
	protected void restoreDefaultGroups(IWorkbenchPart part, IStructuredSelection selection) {
		if (!restoreConfirmed()) {
			return;
		}

		try {
			final SelectionDMContext selectionContext = new SelectionDMContext(selection);

			selectionContext.fsession.getExecutor().execute(new DsfRunnable() {
				@Override
				public void run() {
					IRegisters2 registersService;
					try {
						registersService = selectionContext.resolveService();
					} catch (CoreException e) {
						failed(e);
						return;
					}

					// no success handler needed
					registersService.restoreDefaultGroups(null,
							new RequestMonitor(registersService.getExecutor(), null));
				}
			});
		} catch (DebugException e) {
			failed(e);
		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.cdt.debug.internal.ui.actions.IRegisterGroupActionsTarget#canRestoreDefaultGroups(org.eclipse.ui.IWorkbenchPart, org.eclipse.jface.viewers.IStructuredSelection)
	 */
	protected boolean canRestoreDefaultGroups(IWorkbenchPart part, IStructuredSelection selection) {
		final SelectionDMContext selectionContext;
		try {
			selectionContext = new SelectionDMContext(selection);
		} catch (DebugException e) {
			// No DM context present or group registers service found in the selection
			return false;
		}

		//Prepare to Query the service
		Query<Boolean> query = new Query<Boolean>() {
			@Override
			protected void execute(DataRequestMonitor<Boolean> rm) {
				IRegisters2 regService;
				try {
					regService = selectionContext.resolveService();
				} catch (DebugException e) {
					// Unable to resolve the registers service
					rm.setData(false);
					rm.done();
					return;
				}

				regService.canRestoreDefaultGroups(selectionContext.fcontext, rm);
			}
		};

		//Execute the query
		selectionContext.fsession.getExecutor().execute(query);

		try {
			// return the answer from the service
			return query.get();
		} catch (InterruptedException e) {
		} catch (ExecutionException e) {
		}

		// No positive answer from the service
		return false;
	}

	@ConfinedToDsfExecutor("selectionContext.fsession.getExecutor()")
	private void processAddRegisterGroup(final Shell shell, final SelectionDMContext selectionContext,
			final IRegisterDMContext[] selectedRegisters, final IRegisters2 regServiceManager) {

		final DsfSession session = selectionContext.fsession;
		final DsfExecutor executor = session.getExecutor();

		final IContainerDMContext contDmc = DMContexts.getAncestorOfType(selectionContext.fcontext,
				IContainerDMContext.class);
		// Using the container context to get all existing registers from the target instead of a limited set of registers for a selected group
		regServiceManager.getRegisters(contDmc, new DataRequestMonitor<IRegisterDMContext[]>(executor, null) {

			@Override
			protected void handleSuccess() {
				// Get Register Contexts
				final IRegisterDMContext[] rootRegisters = getData();

				if (rootRegisters.length < 1) {
					//The target is expected to have registers, an error has happened !
					assert false;
					noRegisterGroupFoundErr("Add Register Group", this); //$NON-NLS-1$
					return;
				}

				//Find the root register group, containing all the registers associated to a target, from any of the root registers
				final IRegisterGroupDMContext rootGroupDmc = DMContexts.getAncestorOfType(rootRegisters[0],
						IRegisterGroupDMContext.class);

				// Get data for all available registers
				getRegistersData(rootRegisters, regServiceManager,
						new DataRequestMonitor<IRegisterDMData[]>(executor, null) {
							@Override
							protected void handleSuccess() {
								final IRegisterDMData[] rootRegistersData = getData();

								getRegistersData(selectedRegisters, regServiceManager,
										new DataRequestMonitor<IRegisterDMData[]>(executor, null) {
											@Override
											protected void handleSuccess() {
												// Get data for all selected registers i.e. selected for the new group
												final IRegisterDMData[] selectedRegistersData = getData();

												//Need the root group name to build register descriptors
												regServiceManager.getRegisterGroupData(rootGroupDmc,
														new DataRequestMonitor<IRegisterGroupDMData>(executor, null) {
															@Override
															protected void handleSuccess() {
																final IRegisterGroupDMData rootGroupData = getData();
																// request for the next unused group name to propose it to the user
																proposeGroupName(rootRegisters, regServiceManager,
																		new DataRequestMonitor<String>(executor, null) {
																			@Override
																			protected void handleSuccess() {
																				String proposedGroupName = getData();

																				String rootGroupName = (rootGroupData == null)
																						? BLANK_STRING
																						: rootGroupData.getName();
																				// Create the Register descriptors
																				DialogRegisterProvider descriptors = buildDescriptors(
																						rootGroupName, rootRegisters,
																						rootRegistersData,
																						selectedRegistersData);
																				// Create Dialog Resolve selection to DSF
																				// Registers
																				getDialogSelection(shell,
																						proposedGroupName,
																						descriptors.getAllRegisters(),
																						descriptors
																								.getcheckedRegisters(),
																						new DataRequestMonitor<IRegisterGroupDescriptor>(
																								executor, null) {
																							@Override
																							protected void handleSuccess() {
																								try {
																									addRegisterGroup(
																											regServiceManager,
																											getData(),
																											contDmc);
																								} catch (CoreException e) {
																									failed(e);
																								}
																							};
																						});
																			}
																		});

															}
														});
											}
										});
							}
						});
			}

		});
	}

	private void noRegisterGroupFoundErr(String msgOrigin, RequestMonitor rm) {
		String message = msgOrigin + ": Unable to resolve root Group"; //$NON-NLS-1$
		IStatus status = new Status(IStatus.ERROR, DsfUIPlugin.PLUGIN_ID, IDsfStatusConstants.REQUEST_FAILED,
				REG_GROUP_ACTION_FAILED + message, new Exception(message));
		DsfUIPlugin.log(status);
		rm.setStatus(status);
		rm.done();
	}

	private void proposeGroupName(IRegisterDMContext[] registers, final IRegisters2 regServiceManager,
			final DataRequestMonitor<String> rm) {
		assert (registers != null && registers.length > 0);

		final DsfExecutor executor = regServiceManager.getExecutor();
		if (registers != null && registers.length > 0) {
			//First get all register group contexts, any register context can be used to resolve the container context
			regServiceManager.getRegisterGroups(registers[0],
					new DataRequestMonitor<IRegisterGroupDMContext[]>(executor, null) {
						@Override
						protected void handleSuccess() {
							IRegisterGroupDMContext[] groupsCtx = getData();
							assert (groupsCtx != null);

							final IRegisterGroupDMData[] groupsData = new IRegisterGroupDMData[groupsCtx.length];

							final CountingRequestMonitor crm = new CountingRequestMonitor(executor, rm) {
								@Override
								protected void handleCompleted() {
									//GroupsData is resolved now
									//Select an unused name
									String unusedGroupName = Messages.ProposeGroupNameRoot
											+ (resolveGroupNameWaterMark(groupsData) + 1);
									rm.setData(unusedGroupName);
									rm.done();
								}
							};

							//Resolve all register group data
							for (int i = 0; i < groupsCtx.length; i++) {
								final int index = i;
								regServiceManager.getRegisterGroupData(groupsCtx[index],
										new DataRequestMonitor<IRegisterGroupDMData>(executor, crm) {
											@Override
											protected void handleSuccess() {
												groupsData[index] = getData();
												crm.done();
											}
										});
							}

							crm.setDoneCount(groupsCtx.length);
						}
					});
		} else {
			//Should not happen
			rm.setData(Messages.DefaultRegistersGroupName);
			rm.done();
		}
	}

	// Adjust water mark suffix used to suggest register group names
	private Integer resolveGroupNameWaterMark(IRegisterGroupDMData[] groupsData) {
		// check only for this name pattern
		Pattern pattern = Pattern.compile("^group_(\\d*)$"); //$NON-NLS-1$
		Matcher matcher = pattern.matcher(""); //$NON-NLS-1$
		int water_mark = 0;
		for (IRegisterGroupDMData groupData : groupsData) {
			// Normalize the name to lower case comparison
			String name = groupData.getName().trim().toLowerCase();
			// tracking proposed group names e.d. Group_1, Group_2, etc..,
			// otherwise no need to update the water mark
			if (matcher.reset(name).matches()) {
				// Obtain the numerical suffix
				String number = matcher.replaceAll("$1"); //$NON-NLS-1$
				try {
					int nameSequence = Integer.valueOf(number).intValue();
					if (nameSequence > water_mark) {
						// The new value is bigger so lets move up the water mark
						water_mark = nameSequence;
					}
				} catch (NumberFormatException e) {
					// Quite unlikely and only causing a possibility to
					// propose a group name that already exists.
				}
			}
		}

		return Integer.valueOf(water_mark);
	}

	@ConfinedToDsfExecutor("selectionContext.fsession.getExecutor()")
	private void processEditRegisterGroup(final Shell shell, final SelectionDMContext selectionContext,
			final IRegisters2 regServiceManager) {

		final DsfSession session = selectionContext.fsession;
		final DsfExecutor executor = session.getExecutor();

		// Get a handle to the context of the group being edited
		final IRegisterGroupDMContext groupDmc = DMContexts.getAncestorOfType(selectionContext.fcontext,
				IRegisterGroupDMContext.class);

		// Getting the children of the selected group
		regServiceManager.getRegisters(selectionContext.fcontext,
				new DataRequestMonitor<IRegisterDMContext[]>(executor, null) {
					@Override
					protected void handleSuccess() {
						// Get children Register Contexts
						final IRegisterDMContext[] childRegisters = getData();

						final IContainerDMContext contDmc = DMContexts.getAncestorOfType(selectionContext.fcontext,
								IContainerDMContext.class);
						// Using the container context to get all existing registers from the target instead of a limited set of registers for a selected group
						// This is needed to populate the dialog with all available registers to pick from
						regServiceManager.getRegisters(contDmc,
								new DataRequestMonitor<IRegisterDMContext[]>(executor, null) {
									@Override
									protected void handleSuccess() {
										final IRegisterDMContext[] rootRegisters = getData();

										if (rootRegisters.length < 1) {
											//The target is expected to have a root register group and associated registers, an error has happened !
											assert false;
											noRegisterGroupFoundErr("Edit Register Group", this); //$NON-NLS-1$
											return;
										}

										// We need to resolve the names for all root registers
										getRegistersData(rootRegisters, regServiceManager,
												new DataRequestMonitor<IRegisterDMData[]>(executor, null) {
													@Override
													protected void handleSuccess() {
														final IRegisterDMData[] rootRegistersData = getData();

														getRegistersData(childRegisters, regServiceManager,
																new DataRequestMonitor<IRegisterDMData[]>(executor,
																		null) {
																	@Override
																	protected void handleSuccess() {
																		// Get register data for all selected registers i.e. selected for the new group
																		final IRegisterDMData[] childRegisterData = getData();

																		// Need to get the parent group name. Used on the register descriptors
																		final IRegisterGroupDMContext rootGroupDmc = DMContexts
																				.getAncestorOfType(rootRegisters[0],
																						IRegisterGroupDMContext.class);
																		regServiceManager.getRegisterGroupData(
																				rootGroupDmc,
																				new DataRequestMonitor<IRegisterGroupDMData>(
																						executor, null) {
																					@Override
																					protected void handleSuccess() {
																						IRegisterGroupDMData rootGroupData = getData();
																						final String rootGroupName = (rootGroupData == null)
																								? BLANK_STRING
																								: rootGroupData
																										.getName();

																						regServiceManager
																								.getRegisterGroupData(
																										groupDmc,
																										new DataRequestMonitor<IRegisterGroupDMData>(
																												executor,
																												null) {
																											@Override
																											protected void handleSuccess() {
																												// Resolve the name of the selected group being edited
																												String selGroupName = getData()
																														.getName();
																												// Create the Register descriptors to
																												// access all children registers
																												DialogRegisterProvider descriptors = buildDescriptors(
																														rootGroupName,
																														rootRegisters,
																														rootRegistersData,
																														childRegisterData);

																												// Create Dialog to Resolve new user
																												// selection of group name and registers
																												getDialogSelection(
																														shell,
																														selGroupName,
																														descriptors
																																.getAllRegisters(),
																														descriptors
																																.getcheckedRegisters(),
																														new DataRequestMonitor<IRegisterGroupDescriptor>(
																																executor,
																																null) {
																															@Override
																															protected void handleSuccess() {
																																try {
																																	editRegisterGroup(
																																			groupDmc,
																																			regServiceManager,
																																			getData());
																																} catch (CoreException e) {
																																	failed(e);
																																}
																															};
																														});
																											}
																										});
																					};

																				});
																	}
																});

													}
												});
									}
								});
					}
				});
	}

	private IRegisterGroupDMContext[] resolveSelectedGroups(IStructuredSelection selection) {
		IRegisterGroupDMContext[] selectedGroups = null;
		List<IRegisterGroupDMContext> groupList = new ArrayList<>();
		if (selection != null && !selection.isEmpty()) {
			for (Iterator<?> iterator = selection.iterator(); iterator.hasNext();) {
				Object element = iterator.next();
				if (element instanceof IDMVMContext) {
					IDMContext dmContext = ((IDMVMContext) element).getDMContext();
					// Make sure this selection is a group
					if (dmContext instanceof IRegisterGroupDMContext) {
						IRegisterGroupDMContext groupDmc = (IRegisterGroupDMContext) dmContext;
						groupList.add(groupDmc);
					}
				}
			}

		}

		selectedGroups = groupList.toArray(new IRegisterGroupDMContext[groupList.size()]);
		return selectedGroups;
	}

	@ConfinedToDsfExecutor("selectionContext.fsession.getExecutor()")
	private IRegisterDMContext[] resolveSelectedRegisters(IStructuredSelection selection) {
		List<IRegisterDMContext> selectedRegistersList = new ArrayList<>();
		for (Iterator<?> iterator = selection.iterator(); iterator.hasNext();) {
			Object element = iterator.next();
			IDMVMContext regContext = null;
			if (element instanceof IDMVMContext) {
				regContext = (IDMVMContext) element;
				IRegisterDMContext registerDmc = DMContexts.getAncestorOfType(regContext.getDMContext(),
						IRegisterDMContext.class);
				if (registerDmc != null) {
					selectedRegistersList.add(registerDmc);
				}
			}
		}

		IRegisterDMContext[] selectedRegisters = selectedRegistersList
				.toArray(new IRegisterDMContext[selectedRegistersList.size()]);
		return selectedRegisters;
	}

	@ConfinedToDsfExecutor("selectionContext.fsession.getExecutor()")
	private IRegisterDMContext[] getRegisterContexts(IRegisterDescriptor[] registerDescriptors) throws CoreException {
		IRegisterDMContext[] regContexts = new IRegisterDMContext[registerDescriptors.length];
		for (int i = 0; i < registerDescriptors.length; i++) {
			if (registerDescriptors[i] instanceof RegisterDescriptor) {
				regContexts[i] = ((RegisterDescriptor) registerDescriptors[i]).fRegContext;
			} else {
				// Interrupt on error
				IStatus status = new Status(IStatus.ERROR, DsfUIPlugin.PLUGIN_ID, IStatus.ERROR,
						"Unexpected IRegisterDescription instance type", null); //$NON-NLS-1$
				throw new CoreException(status);
			}
		}

		return regContexts;
	}

	@ConfinedToDsfExecutor("selectionContext.fsession.getExecutor()")
	private void getDialogSelection(Shell shell, String originalGroupName, IRegisterDescriptor[] allRegisters,
			IRegisterDescriptor[] checkedRegisters, DataRequestMonitor<IRegisterGroupDescriptor> rm) {
		RegisterGroupDialogRunnable dialog = new RegisterGroupDialogRunnable(shell, originalGroupName, allRegisters,
				checkedRegisters, rm);
		shell.getDisplay().asyncExec(dialog);
	}

	private IRegisterGroupDescriptor createGroupDescriptor(final String groupName,
			final IRegisterDescriptor[] iSelectedRegisters) {
		IRegisterGroupDescriptor groupDescriptor = new IRegisterGroupDescriptor() {

			@Override
			public boolean isEnabled() {
				return true;
			}

			@Override
			public String getName() {
				return groupName;
			}

			@Override
			public IRegisterDescriptor[] getChildren() throws CoreException {
				return iSelectedRegisters;
			}
		};

		return groupDescriptor;
	}

	/**
	 * Build descriptor adapters to dialog interface both all registers as well as registers to be pre-selected on the
	 * dialog
	 *
	 * @param checkedRegistersData
	 */
	@ConfinedToDsfExecutor("selectionContext.fsession.getExecutor()")
	private DialogRegisterProvider buildDescriptors(String groupName, IRegisterDMContext[] registers,
			IRegisterDMData[] registerData, IRegisterDMData[] checkedRegistersData) {
		assert (registers.length == registerData.length);

		List<RegisterDescriptor> checkedDescriptorsList = new ArrayList<>();

		final RegisterDescriptor[] regDescriptors = new RegisterDescriptor[registers.length];

		Map<String, RegisterDescriptor> mapNameToRegDescriptor = new HashMap<>();

		for (int i = 0; i < registers.length; i++) {
			regDescriptors[i] = new RegisterDescriptor(groupName, registers[i], registerData[i].getName());
			mapNameToRegDescriptor.put(regDescriptors[i].getName(), regDescriptors[i]);
		}

		for (int i = 0; i < checkedRegistersData.length; i++) {
			// Resolve the descriptor by name
			RegisterDescriptor descriptor = mapNameToRegDescriptor.get(checkedRegistersData[i].getName());

			// All checked registers are expected to be part of the complete list
			assert (descriptor != null);

			// prevent duplicates or null values, duplicates are possible since the selected registers
			// may come from different groups
			if (descriptor != null && !checkedDescriptorsList.contains(descriptor)) {
				checkedDescriptorsList.add(descriptor);
			}
		}

		final RegisterDescriptor[] checkedRegDescriptors = checkedDescriptorsList
				.toArray(new RegisterDescriptor[checkedDescriptorsList.size()]);

		DialogRegisterProvider provider = new DialogRegisterProvider() {
			@Override
			public IRegisterDescriptor[] getcheckedRegisters() {
				return checkedRegDescriptors;
			}

			@Override
			public IRegisterDescriptor[] getAllRegisters() {
				return regDescriptors;
			}
		};

		return provider;
	}

	@ConfinedToDsfExecutor("selectionContext.fsession.getExecutor()")
	private void addRegisterGroup(IRegisters2 regServiceManager, IRegisterGroupDescriptor groupDescriptor,
			IContainerDMContext contDmc) throws CoreException {
		IRegisterDescriptor[] selectedRegisters = groupDescriptor.getChildren();
		if (selectedRegisters != null) {
			String groupName = groupDescriptor.getName();
			// Register the addition of the group and notify the change
			IRegisterDMContext[] registers = getRegisterContexts(selectedRegisters);
			regServiceManager.addRegisterGroup(contDmc, groupName, registers,
					new RequestMonitor(regServiceManager.getSession().getExecutor(), null) {
						@Override
						protected void handleCompleted() {
							if (getStatus() != null && getStatus().getCode() == IDsfStatusConstants.NOT_SUPPORTED) {
								// This user request is not supported, notify the user
								notifyUser(getStatus().getMessage());
							}

						};
					});
		}
	}

	@ConfinedToDsfExecutor("selectionContext.fsession.getExecutor()")
	private void editRegisterGroup(IRegisterGroupDMContext group, IRegisters2 regServiceManager,
			IRegisterGroupDescriptor groupDescriptor) throws CoreException {
		IRegisterDescriptor[] selectedRegisters = groupDescriptor.getChildren();
		if (selectedRegisters != null) {
			String groupName = groupDescriptor.getName();
			// Register the addition of the group and notify the change
			regServiceManager.editRegisterGroup(group, groupName, getRegisterContexts(selectedRegisters),
					new RequestMonitor(regServiceManager.getSession().getExecutor(), null) {
						@Override
						protected void handleCompleted() {
							if (getStatus() != null && getStatus().getCode() == IDsfStatusConstants.NOT_SUPPORTED) {
								// This user request is not supported, notify the user
								notifyUser(getStatus().getMessage());
							}

						};
					});
		}
	}

	private void failed(Throwable e) {
		IStatus status = new Status(IStatus.ERROR, DsfUIPlugin.PLUGIN_ID, IDsfStatusConstants.REQUEST_FAILED,
				REG_GROUP_ACTION_FAILED + e.getMessage(), e);
		DsfUIPlugin.log(status);
	}

	private void notifyUser(final String message) {

		Runnable runnable = new Runnable() {
			@Override
			public void run() {
				Shell parent = DsfUIPlugin.getActiveWorkbenchShell();
				if (parent != null) {
					MessageDialog.openInformation(parent, Messages.Information,
							Messages.RegisterGroupInfo + ": " + message); //$NON-NLS-1$
				}
			}
		};

		Display.getDefault().asyncExec(runnable);
	}

	/**
	 * @return true - OK to restore
	 */
	private boolean restoreConfirmed() {
		ConfirmRestoreDialog restoreDialog = new ConfirmRestoreDialog();
		Display.getDefault().syncExec(restoreDialog);

		return restoreDialog.fRestore;
	}

	private class ConfirmRestoreDialog implements Runnable {

		private Boolean fRestore = false;

		@Override
		public void run() {
			Shell parent = DsfUIPlugin.getActiveWorkbenchShell();
			if (parent != null) {

				String title = Messages.RegisterGroupConfirmRestoreTitle;
				String message = Messages.RegisterGroupConfirmRestoreMessage;
				String[] buttonLabels = new String[] { Messages.RegisterGroupRestore,
						Messages.RegisterGroupRestoreCancel, };
				MessageDialog dialog = new MessageDialog(parent, title, null, message, MessageDialog.QUESTION,
						buttonLabels, 0);
				int res = dialog.open();
				if (res == 0) { // RESTORE
					fRestore = true;
				} else if (res == 1) { // CANCEL
					fRestore = false;
				}
			}
		}

	}

	private void getRegistersData(IRegisterDMContext[] regDMCs, IRegisters2 regService,
			final DataRequestMonitor<IRegisterDMData[]> rm) {
		final IRegisterDMData[] regDataArray = new IRegisterDMData[regDMCs.length];
		final DsfExecutor executor = regService.getExecutor();

		final CountingRequestMonitor crm = new CountingRequestMonitor(executor, rm) {
			@Override
			protected void handleSuccess() {
				rm.setData(regDataArray);
				rm.done();
			}
		};

		for (int i = 0; i < regDMCs.length; i++) {
			final int index = i;
			regService.getRegisterData(regDMCs[index], new DataRequestMonitor<IRegisterDMData>(executor, crm) {
				@Override
				protected void handleSuccess() {
					regDataArray[index] = getData();
					crm.done();
				}
			});
		}

		crm.setDoneCount(regDMCs.length);
	}
}