import org.eclipse.emf.transaction.impl.TransactionalEditingDomainImpl; //导入依赖的package包/类
protected void testRefactoring(String pathToInitialSct, String pathToExpectedSct, String contextElementName) {
	Statechart initial = models
			.loadStatechartFromResource(pathToInitialSct);

	TransactionalEditingDomainImpl.FactoryImpl.INSTANCE.createEditingDomain(initial.eResource().getResourceSet());
	
	View contextView = getViewForState(initial, contextElementName);

	AbstractRefactoring<View> refactoring = getRefactoring();
	refactoring.setContextObjects(Collections.singletonList(contextView));
	
	AbstractSCTResource initialRes = (AbstractSCTResource) initial.eResource();
	initialRes.setSerializerEnabled(true);
	refactoring.execute();
	initialRes.setSerializerEnabled(false);

	Statechart expected = models
			.loadStatechartFromResource(pathToExpectedSct);
	
	compareStatecharts(initial, expected);
}
 

import org.eclipse.emf.transaction.impl.TransactionalEditingDomainImpl; //导入依赖的package包/类
private void performIssueValidationFixingTransactional(Collection<TransactionalEditingDomain> domains,
        Resource documentResource) throws OperationCanceledError {

    final Collection<Issue> detectedIssues = new ArrayList<>();

    domains.stream().filter(TransactionalEditingDomainImpl.class::isInstance)
            .map(TransactionalEditingDomainImpl.class::cast).forEach(d -> setValidatorFactory(d, detectedIssues));

    Runnable lastCommandStackAction = null;
    for (TransactionalEditingDomain domain : domains) {
        if (lastCommandStackAction == null) {
            lastCommandStackAction = createFixingRecordingCommand(domain, documentResource, detectedIssues);
        } else {
            lastCommandStackAction = createDelegatingRecordingCommand(domain, lastCommandStackAction);
        }

    }

    Optional.ofNullable(lastCommandStackAction).ifPresent(Runnable::run);
}
 

import org.eclipse.emf.transaction.impl.TransactionalEditingDomainImpl; //导入依赖的package包/类
private static void setValidatorFactory(TransactionalEditingDomainImpl domainImpl,
        final Collection<Issue> detectedIssues) {
    domainImpl.setValidatorFactory(new DelegatingValidatorFactory() {
        @Override
        public TransactionValidator createReadWriteValidator() {
            return new DelegatingTransactionValidator(super.createReadWriteValidator()) {
                @Override
                public IStatus validate(Transaction tx) {
                    IStatus result = super.validate(tx);
                    if (result.isOK() && !detectedIssues.isEmpty()) {
                        return new Status(IStatus.ERROR, result.getPlugin(), "There are unfixed issues remaining.");
                    }
                    return result;
                }

            };
        }
    });
}
 

import org.eclipse.emf.transaction.impl.TransactionalEditingDomainImpl; //导入依赖的package包/类
public static <T> T checkedWriting(Object object, final RunnableWithResult<T> runnable, Map<Object, Object> options) throws InterruptedException, RollbackException {

		final EditingDomain domain = EMFUtils.getAnyDomain(object);
		if (domain instanceof TransactionalEditingDomain) {
			TransactionalEditingDomain transactionDomain = (TransactionalEditingDomain) domain;
			checkForDeadlock(transactionDomain);
			InternalTransaction transaction = ((TransactionalEditingDomainImpl) transactionDomain).getActiveTransaction();
			if ((transaction != null) && (transaction.getOwner() == Thread.currentThread()) && !transaction.isReadOnly()) {
				// nested writing
				runnable.run();
				return runnable.getResult();
			}
			TransactionalCommandStack stack = (TransactionalCommandStack) domain.getCommandStack();
			if (stack != null) {
				Map writingOptions = getWritingOptions(domain);
				Map newOptions = new HashMap();
				if (options != null) {
					newOptions.putAll(options);
				}
				if (writingOptions != null) {
					newOptions.putAll(writingOptions);
				}
				writingOptions = newOptions;
				stack.execute(new RunnableRecordingCommand("writing", runnable), writingOptions);
			} else {
				runnable.run();
			}
		} else {
			runnable.run();
		}
		return runnable.getResult();
	}
 

import org.eclipse.emf.transaction.impl.TransactionalEditingDomainImpl; //导入依赖的package包/类
/**
 * {@inheritDoc}
 * 
 * @see org.eclipse.emf.emfstore.client.provider.ESEditingDomainProvider#getEditingDomain(org.eclipse.emf.ecore.resource.ResourceSet)
 */
public EditingDomain getEditingDomain(ResourceSet resourceSet) {
	final TransactionalEditingDomain domain = new TransactionalEditingDomainImpl(new ComposedAdapterFactory(
		ComposedAdapterFactory.Descriptor.Registry.INSTANCE), new EMFStoreTransactionalCommandStack(), resourceSet);
	((FactoryImpl) TransactionalEditingDomain.Factory.INSTANCE).mapResourceSet(domain);
	TransactionalEditingDomain.Registry.INSTANCE.add(TRANSACTIONAL_EDITINGDOMAIN_ID, domain);
	domain.setID(TRANSACTIONAL_EDITINGDOMAIN_ID);
	return domain;
}
 

import org.eclipse.emf.transaction.impl.TransactionalEditingDomainImpl; //导入依赖的package包/类
/**
 * This sets up the editing domain for the model editor.
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
protected void initializeEditingDomain() {
	// Create an adapter factory that yields item providers.
	//
	adapterFactory = new ComposedAdapterFactory(ComposedAdapterFactory.Descriptor.Registry.INSTANCE);

	adapterFactory.addAdapterFactory(new ResourceItemProviderAdapterFactory());
	adapterFactory.addAdapterFactory(new EcoreItemProviderAdapterFactory());
	adapterFactory.addAdapterFactory(new ReflectiveItemProviderAdapterFactory());

	// Create the command stack that will notify this editor as commands are executed.
	//
	TransactionalCommandStack commandStack = new TransactionalCommandStackImpl();

	// Add a listener to set the most recent command's affected objects to be the selection of the viewer with focus.
	//
	commandStack.addCommandStackListener
		(new CommandStackListener() {
			 public void commandStackChanged(final EventObject event) {
				 getContainer().getDisplay().asyncExec
					 (new Runnable() {
						  public void run() {
							  firePropertyChange(IEditorPart.PROP_DIRTY);

							  // Try to select the affected objects.
							  //
							  Command mostRecentCommand = ((CommandStack)event.getSource()).getMostRecentCommand();
							  if (mostRecentCommand != null) {
								  setSelectionToViewer(mostRecentCommand.getAffectedObjects());
							  }
							  for (Iterator<PropertySheetPage> i = propertySheetPages.iterator(); i.hasNext(); ) {
								  PropertySheetPage propertySheetPage = i.next();
								  if (propertySheetPage.getControl().isDisposed()) {
									  i.remove();
								  }
								  else {
									  propertySheetPage.refresh();
								  }
							  }
						  }
					  });
			 }
		 });

	// Create the editing domain with a special command stack.
	//
	editingDomain = new TransactionalEditingDomainImpl(adapterFactory, commandStack);//, new HashMap<Resource, Boolean>());
}
 

import org.eclipse.emf.transaction.impl.TransactionalEditingDomainImpl; //导入依赖的package包/类
/**
 * This sets up the editing domain for the model editor.
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * 
 * @generated NOT
 * @deprecated
 */
protected void initializeEditingDomain() {
    // Create an adapter factory that yields item providers.
    //
    adapterFactory = new ComposedAdapterFactory(ComposedAdapterFactory.Descriptor.Registry.INSTANCE);

    adapterFactory.addAdapterFactory(new ResourceItemProviderAdapterFactory());
    adapterFactory.addAdapterFactory(new GenconfItemProviderAdapterFactory());
    adapterFactory.addAdapterFactory(new ReflectiveItemProviderAdapterFactory());

    // Create the command stack that will notify this editor as commands are executed.
    //
    TransactionalCommandStack commandStack = new TransactionalCommandStackImpl();

    // Add a listener to set the most recent command's affected objects to be the selection of the viewer with focus.
    //
    commandStack.addCommandStackListener(new CommandStackListener() {
        public void commandStackChanged(final EventObject event) {
            getContainer().getDisplay().asyncExec(new Runnable() {
                public void run() {
                    firePropertyChange(IEditorPart.PROP_DIRTY);

                    // Try to select the affected objects.
                    //
                    Command mostRecentCommand = ((CommandStack) event.getSource()).getMostRecentCommand();
                    if (mostRecentCommand != null) {
                        setSelectionToViewer(mostRecentCommand.getAffectedObjects());
                    }
                    for (Iterator<PropertySheetPage> i = propertySheetPages.iterator(); i.hasNext();) {
                        PropertySheetPage propertySheetPage = i.next();
                        if (propertySheetPage.getControl().isDisposed()) {
                            i.remove();
                        } else {
                            propertySheetPage.refresh();
                        }
                    }
                }
            });
        }
    });

    // Create the editing domain with a special command stack.
    //
    editingDomain = new TransactionalEditingDomainImpl(adapterFactory, commandStack);
}
 

import org.eclipse.emf.transaction.impl.TransactionalEditingDomainImpl; //导入依赖的package包/类
private static Map<?, ?> getWritingOptions(EditingDomain domain) {
	if (domain instanceof TransactionalEditingDomainImpl)
		return ((TransactionalEditingDomainImpl) domain).getDefaultTransactionOptions();
	return WRITING_OPTIONS;
}
 

import org.eclipse.emf.transaction.impl.TransactionalEditingDomainImpl; //导入依赖的package包/类
public static <T> T runExclusive(TransactionalEditingDomain d, Runnable read) throws InterruptedException {
	InternalTransactionalEditingDomain domain = (InternalTransactionalEditingDomain) d;
	Transaction active = domain.getActiveTransaction();
	Transaction tx = null;
	long start = -1;
	if ((active == null) || !(active.isActive() && active.isReadOnly() && (active.getOwner() == Thread.currentThread()))) {
		start = System.currentTimeMillis();
		// only need to start a new transaction if we don't already have
		// exclusive read-only access
		tx = domain.startTransaction(true, getWritingOptions(domain));
	}
	final RunnableWithResult<?> rwr = (read instanceof RunnableWithResult) ? (RunnableWithResult<?>) read : null;
	try {
		read.run();
	} finally {
		if ((tx != null) && (tx.isActive())) {
			// commit the transaction now
			try {
				tx.commit();
				if (rwr != null) {
					rwr.setStatus(Status.OK_STATUS);
				}
			} catch (RollbackException e) {
				Tracing.catching(TransactionalEditingDomainImpl.class, "runExclusive", e); //$NON-NLS-1$
				EMFTransactionPlugin.INSTANCE.log(new MultiStatus(EMFTransactionPlugin.getPluginId(), EMFTransactionStatusCodes.READ_ROLLED_BACK, new IStatus[] { e.getStatus() }, Messages.readTxRollback, null));
				if (rwr != null) {
					rwr.setStatus(e.getStatus());
				}
			}
		}
	}
	if (start != -1) {
		long duration = System.currentTimeMillis() - start;
		if (duration > 2 * 1000) {
			LogUtil.warn("runnable " + read + " held transaction for " + (duration / 1000.0) + " seconds");
		}
	}
	if (rwr != null) {
		@SuppressWarnings("unchecked")
		T result = (T) rwr.getResult();
		return result;
	}
	return null;
}
 

import org.eclipse.emf.transaction.impl.TransactionalEditingDomainImpl; //导入依赖的package包/类
@Override
protected void doExecute(Command command, Map<?, ?> options) throws InterruptedException, RollbackException {
	// default the transaction options to not perform EMF validation or allow undo 
	if (options == null) {
		options = DEFAULT_TRANSACTION_OPTIONS;
	}
	InternalTransaction tx = createTransaction(command, options);
	boolean completed = false;
	
	try {
		basicExecute(command);
		
		// new in EMF 2.4:  AbortExecutionException can cause the
		// command not to be added to the undo stack
		completed = mostRecentCommand == command;
		
		// commit the transaction now
		TransactionalEditingDomainImpl domain = (TransactionalEditingDomainImpl)tx.getEditingDomain();
		if (domain != null && domain.getChangeRecorder() != null) {
			tx.commit();
		} else {
			tx = null;
		}
	} catch (OperationCanceledException e) {
		// snuff the exception, because this is expected (user asked to
		//    cancel the model change).  We will rollback, below
	} finally {
		if (tx != null) {
			if (tx.isActive()) {
				// roll back (some exception, possibly being thrown now or
				//    an operation cancel, has occurred)
				rollback(tx);
                handleRollback(command, null);
			} else {
				// the transaction has already incorporated the triggers
				//    into its change description, so the recording command
				//    doesn't need them again
				if (!(command instanceof RecordingCommand) && completed) {
					Command triggerCommand = tx.getTriggers();
					if (triggerCommand != null) {
						// replace the executed command by a compound of the
						//    original and the trigger commands
						CompoundCommand compound = new ConditionalRedoCommand.Compound();
						compound.append(mostRecentCommand);
						compound.append(triggerCommand);
						mostRecentCommand = compound;
					}
				}
			}
		}
	}
       clearStack(command);
}