Attachment #118854 for bug #245446

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

View | Details | Raw Unified | Return to bug 245446
Collapse All | Expand All

Lines 9-16 Link Here

(-)src/org/eclipse/emf/workspace/tests/AbstractEMFOperationTest.java (-2 / +63 lines)
9	*	9	*
10	* Contributors:	10	* Contributors:
11	* IBM - Initial API and implementation	11	* IBM - Initial API and implementation
12	* Zeligsoft - Bugs 218276, 245419, 245393, 250253	12	* Zeligsoft - Bugs 218276, 245419, 245393, 250253, 247691 (restore method accessibility)
13	* IBM - Bug 245393	13	* IBM - Bugs 245393, 247691
14	*	14	*
15	* </copyright>	15	* </copyright>
16	*	16	*
Lines 18-23 Link Here
18	*/	18	*/
19	package org.eclipse.emf.workspace.tests;	19	package org.eclipse.emf.workspace.tests;
20		20
		21	import java.lang.reflect.Method;
		22	import java.util.Collections;
21	import java.util.Map;	23	import java.util.Map;
22		24
23	import junit.framework.Test;	25	import junit.framework.Test;
Lines 962-967 Link Here
962	l.uninstall(domain);	964	l.uninstall(domain);
963	}	965	}
964	}	966	}
		967
		968	/**
		969	* Tests that child operations reuse their parent's transaction when the parent
		970	* has the {@link Transaction#OPTION_VALIDATE_EDIT} option, but the child does not.
		971	*/
		972	public void test_inheritValidateEditOption_247691() {
		973
		974	final CompositeEMFOperation outer = new CompositeEMFOperation(domain,
		975	"outer", //$NON-NLS-1$
		976	Collections.singletonMap(Transaction.OPTION_VALIDATE_EDIT,
		977	Boolean.TRUE));
		978
		979	outer.setTransactionNestingEnabled(false);
		980
		981	AbstractEMFOperation inner = new AbstractEMFOperation(domain, "inner") { //$NON-NLS-1$
		982
		983	@Override
		984	public boolean canExecute() {
		985	return true;
		986	}
		987
		988	@Override
		989	protected IStatus doExecute(IProgressMonitor monitor,
		990	IAdaptable info)
		991	throws ExecutionException {
		992
		993	Method getTransactionMethod = null;
		994
		995	try {
		996	getTransactionMethod = AbstractEMFOperation.class
		997	.getDeclaredMethod("getTransaction", new Class[0]); //$NON-NLS-1$
		998	getTransactionMethod.setAccessible(true);
		999	Object outerTransaction = getTransactionMethod.invoke(
		1000	outer, new Object[0]);
		1001	Object innerTransaction = getTransactionMethod.invoke(this,
		1002	new Object[0]);
		1003	assertTrue("Should have reused the parent transaction", //$NON-NLS-1$
		1004	innerTransaction == null
		1005	\|\| innerTransaction == outerTransaction);
		1006	return Status.OK_STATUS;
		1007
		1008	} catch (Exception e) {
		1009	throw new ExecutionException(e.getMessage(), e);
		1010	} finally {
		1011	if (getTransactionMethod != null) {
		1012	getTransactionMethod.setAccessible(false);
		1013	}
		1014	}
		1015	}
		1016	};
		1017
		1018	outer.add(inner);
		1019
		1020	try {
		1021	outer.execute(new NullProgressMonitor(), null);
		1022	} catch (ExecutionException e) {
		1023	fail("Unexpected exception: " + e.getLocalizedMessage()); //$NON-NLS-1$
		1024	}
		1025	}
965		1026
966	//	1027	//
967	// Fixtures	1028	// Fixtures




/**
 * <copyright>
 *
 * Copyright (c) 2006, 2008 IBM Corporation, Zeligsoft Inc., 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

 *
 * Contributors:
 *   IBM - Initial API and implementation
 *   Zeligsoft - Bug 245446
 *
 * </copyright>
 *

    	
    	return (RunnableWithResult<T>) domain.createPrivilegedRunnable(runnable);
    }
    
	/**
	 * Gets the best transaction-option registry available for the specified
	 * editing <tt>domain</tt>. Usually, it will be a registry that is local to
	 * that domain, but it may be the
	 * {@linkplain Transaction.OptionMetadata.Registry#INSTANCE shared instance}
	 * under extreme circumstances.
	 * 
	 * @param domain
	 *            an editing domain
	 * @return its transaction options registry, never <code>null</code>
	 * 
	 * @since 1.3
	 */
	public static Transaction.OptionMetadata.Registry getTransactionOptionRegistry(
			TransactionalEditingDomain domain) {
		Transaction.OptionMetadata.Registry result = getAdapter(domain,
			Transaction.OptionMetadata.Registry.class);

		if (result == null) {
			result = Transaction.OptionMetadata.Registry.INSTANCE;
		}

		return result;
	}
}




 *
 * Contributors:
 *   IBM - Initial API and implementation
 *   Zeligsoft - Bugs 145877, 250253, 245446
 *
 * </copyright>
 *

	private void inheritOptions(Transaction parent) {
        
	    // if we have no parent transaction, then we are a root and we "inherit"
	    // the editing domain's default transaction options.  In the root case,
		// we don't consider whether an option is hereditary because, of course,
		// we aren't actually inheriting it from any other transaction
		final boolean isRoot = parent == null;
        Map<?, ?> parentOptions = isRoot ?
        	getDefaultOptions(getEditingDomain()) : parent.getOptions();
        
        if (parentOptions != null) {
			Transaction.OptionMetadata.Registry reg = TransactionUtil
				.getTransactionOptionRegistry(getEditingDomain());
			
            for (Object option : parentOptions.keySet()) {
				reg.getOptionMetadata(option).inherit(parentOptions,
					mutableOptions, isRoot);
                    if (!mutableOptions.containsKey(BLOCK_CHANGE_PROPAGATION)) {
                        mutableOptions.put(option, next.getValue());
                    }
                } else if (BLOCK_CHANGE_PROPAGATION.equals(option)) {
                    // don't inherit the block option!
                } else if (!mutableOptions.containsKey(option)) {
                    // overridden by child transaction options
                    mutableOptions.put(option, next.getValue());
                }
            }            
        }
	}




 *
 * Contributors:
 *   IBM - Initial API and implementation
 *   Zeligsoft - Bugs 177642, 145877, 245446
 *
 * </copyright>
 *

import org.eclipse.emf.transaction.internal.Tracing;
import org.eclipse.emf.transaction.internal.l10n.Messages;
import org.eclipse.emf.transaction.util.Adaptable;
import org.eclipse.emf.transaction.util.BasicTransactionOptionMetadataRegistry;
import org.eclipse.emf.transaction.util.Lock;
import org.eclipse.emf.transaction.util.TransactionUtil;


 * <ul>
 *   <li>{@link TransactionalEditingDomain.DefaultOptions}</li>
 *   <li>{@link TransactionalEditingDomain.Lifecycle} (since 1.3)</li>
 *   <li>{@link Transaction.Option.Registry} (since 1.3)</li>
 * </ul>
 *
 * @author Christian W. Damus (cdamus)

	    TransactionImpl.DEFAULT_UNDO_REDO_OPTIONS);
	
	private LifecycleImpl lifecycle;
	private Transaction.OptionMetadata.Registry optionMetadata;
	
	/**
	 * Initializes me with my adapter factory, command stack, and resource set.

	public <T> T getAdapter(Class<? extends T> adapterType) {
	    T result;
	    
	    if (adapterType == Transaction.OptionMetadata.Registry.class) {
	        result = (T) getOptionMetadata();
	    } else if (adapterType == DefaultOptions.class) {
	        result = (T) this;
	    } else if (adapterType == Lifecycle.class) {
	        result = (T) getLifecycle();

		return new LifecycleImpl();
	}
	
	/**
	 * Obtains my lazily-created transaction option metadata registry.
	 * 
	 * @return my option metadata registry
	 * 
	 * @since 1.3
	 */
	protected synchronized final Transaction.OptionMetadata.Registry getOptionMetadata() {
		if (optionMetadata == null) {
			optionMetadata = createOptionMetadataRegistry();
		}

		return optionMetadata;
	}

	/**
	 * Creates a new transaction option metadata registry.
	 * Subclasses may override to create their own implementation, although it
	 * would hardly seem interesting to do so.
	 * 
	 * @return a new option metadata registry
	 * 
	 * @since 1.3
	 */
	protected Transaction.OptionMetadata.Registry createOptionMetadataRegistry() {
		return new BasicTransactionOptionMetadataRegistry();
	}
	
	//
	// Nested classes
	//

Lines 1-7 Link Here

(-)src/org/eclipse/emf/transaction/Transaction.java (-2 / +224 lines)
1	/**	1	/**
2	* <copyright>	2	* <copyright>
3	*	3	*
4	* Copyright (c) 2005, 2007 IBM Corporation and others.	4	* Copyright (c) 2005, 2008 IBM Corporation, Zeligsoft Inc., and others.
5	* All rights reserved. This program and the accompanying materials	5	* All rights reserved. This program and the accompanying materials
6	* are made available under the terms of the Eclipse Public License v1.0	6	* are made available under the terms of the Eclipse Public License v1.0
7	* which accompanies this distribution, and is available at	7	* which accompanies this distribution, and is available at
Lines 9-14 Link Here
9	*	9	*
10	* Contributors:	10	* Contributors:
11	* IBM - Initial API and implementation	11	* IBM - Initial API and implementation
		12	* Zeligsoft - Bug 245446
12	*	13	*
13	* </copyright>	14	* </copyright>
14	*	15	*
Lines 19-24 Link Here
19	import java.util.Map;	20	import java.util.Map;
20		21
21	import org.eclipse.core.runtime.IStatus;	22	import org.eclipse.core.runtime.IStatus;
		23	import org.eclipse.emf.transaction.impl.TransactionImpl;
		24	import org.eclipse.emf.transaction.internal.AllowChangePropagationBlockingOption;
		25	import org.eclipse.emf.transaction.internal.BlockChangePropagationOption;
		26	import org.eclipse.emf.transaction.internal.ValidateEditOption;
		27	import org.eclipse.emf.transaction.util.BasicTransactionOptionMetadata;
		28	import org.eclipse.emf.transaction.util.BasicTransactionOptionMetadataRegistry;
22	import org.eclipse.emf.transaction.util.ValidateEditSupport;	29	import org.eclipse.emf.transaction.util.ValidateEditSupport;
23		30
24		31
Lines 187-193 Link Here
187		194
188	/**	195	/**
189	* Obtains the special options with which I was created. The options	196	* Obtains the special options with which I was created. The options
190	* (map keys) are defined by the {@link TransactionalEditingDomain} interface.	197	* (map keys) are defined by the {@link #OPTION_NO_NOTIFICATIONS Transaction}
		198	* interface.
191	*	199	*
192	* @return an unmodifiable view of my options	200	* @return an unmodifiable view of my options
193	*/	201	*/
Lines 310-313 Link Here
310	* @return my status, most interesting after I have closed	318	* @return my status, most interesting after I have closed
311	*/	319	*/
312	public IStatus getStatus();	320	public IStatus getStatus();
		321
		322	//
		323	// Nested types
		324	//
		325
		326	/**
		327	* <p>
		328	* An optional interface that allows clients to query certain meta-data
		329	* about transaction options.
		330	* </p>
		331	* <p>
		332	* This interface is not intended to be implemented by clients. Extend the
		333	* {@link BasicTransactionOptionMetadata} class, instead.
		334	* </p>
		335	*
		336	* @noimplement This interface is not intended to be implemented by clients.
		337	*
		338	* @author Christian W. Damus (cdamus)
		339	*
		340	* @since 1.3
		341	*
		342	* @see BasicTransactionOptionMetadata
		343	*/
		344	interface OptionMetadata {
		345
		346	/**
		347	* Obtains the key of the option that I describe. This is the key that
		348	* would be used in the options map of a transaction.
		349	*
		350	* @return my option
		351	*/
		352	Object getOption();
		353
		354	/**
		355	* <p>
		356	* Queries whether the specified option is a tag, meaning that it adorns
		357	* a transaction with client-specific information but that it does not
		358	* otherwise affect the semantics (or behaviour) of the transaction.
		359	* </p>
		360	* <p>
		361	* Unrecognized options are assumed to be tags, because a transaction
		362	* would not be able to interpret their meaning.
		363	* </p>
		364	*
		365	* @return <code>true</code> if the option key is a tag option or if it
		366	* is not recognized by this meta-data instance;
		367	* <code>false</code> if it is recognized and is known not to be
		368	* a tag
		369	*/
		370	boolean isTag();
		371
		372	/**
		373	* <p>
		374	* Queries whether the specified option is inherited by nested
		375	* transactions.
		376	* </p>
		377	* <p>
		378	* Unrecognized options are assumed to be inherited.
		379	* </p>
		380	*
		381	* @return <code>true</code> if the option is inherited or if it is not
		382	* recognized; <code>false</code> if it is not inherited
		383	*/
		384	boolean isHereditary();
385
386	/**
387	* <p>
388	* Obtains the type value of an option.
389	* </p>
390	* <p>
391	* The type of an unrecognized option is assumed to be {@link Object}.
392	* </p>
393	*
394	* @return the default value of the option, or <code>Object</code> if it
395	* is not known
396	*/
397	Class<?> getType();
398
399	/**
400	* <p>
401	* Obtains the default value of an option.
402	* </p>
403	* <p>
404	* The default value of an unrecognized option is assumed to be
405	* <code>null</code>.
406	* </p>
407	*
408	* @return the default value of the option, or <code>null</code> if it
409	* is not known
410	*/
411	Object getDefaultValue();
412
413	/**
414	* Gets the value (implicit/default or explicit) of my option in the
415	* specified map.
416	*
417	* @param options
418	* an options map
419	*
420	* @return my value in the map
421	*/
422	Object getValue(Map<?, ?> options);
423
424	/**
425	* Queries whether the specified map has a setting for my option.
426	*
427	* @param options
428	* an options map
429	* @return whether it has a setting for my option
430	*/
431	boolean isSet(Map<?, ?> options);
432
433	/**
434	* Queries whether the specified options maps have the same value of my
435	* option, whether that be implicit or explicit. That is, this method
436	* accounts for default values and such complex cases as the
437	* {@link Transaction#OPTION_VALIDATE_EDIT} in which values of two
438	* different types may mean the same thing.
439	*
440	* @param options1
441	* an options map
442	* @param options2
443	* another options map
444	*
445	* @return whether the two maps have the same setting of my option
446	*/
447	boolean sameSetting(Map<?, ?> options1, Map<?, ?> options2);
448
449	/**
450	* Updates the options map of a child transaction to inherit the setting
451	* in a parent transaction, if it is a hereditary option and the child
452	* does not already have a setting for it.
453	*
454	* @param parentOptions
455	* the options map to inherit a value from. It is conceivable
456	* that inheritance of an option may depend on more than one
457	* option in this parent map
458	* @param childOptions
459	* the map that is to inherit the option setting
460	* @param force
461	* whether to inherit the option anyway despite that it is
462	* not hereditary. This is used for application of default
463	* options, and can be ignored by the implementor if
464	* necessary. Also, clients must not use this parameter to
465	* attempt to override an existing child setting; a
466	* well-behaved option will not do that
467	*/
468	void inherit(Map<?, ?> parentOptions, Map<Object, Object> childOptions,
469	boolean force);
470
471	/**
472	* <p>
473	* A registry of metadata describing transaction options. The default
474	* implementation of the {@link TransactionalEditingDomain} interface
475	* provides a transaction option registry as an adapter.
476	* </p>
477	* <p>
478	* This interface is not intended to be implemented by clients.
479	* </p>
480	*
481	* @noimplement This interface is not intended to be implemented by
482	* clients.
483	* @author Christian W. Damus (cdamus)
484	*
485	* @since 1.3
486	*/
487	interface Registry {
488
489	/**
490	* The shared transaction option metadata registry.
491	*/
492	Registry INSTANCE = new BasicTransactionOptionMetadataRegistry(null) {
493
494	private static final long serialVersionUID = 1L;
495
496	{
497	// the options that we know
498	register(BasicTransactionOptionMetadata.newBoolean(
499	Transaction.OPTION_NO_NOTIFICATIONS, false));
500	register(BasicTransactionOptionMetadata.newBoolean(
501	Transaction.OPTION_NO_TRIGGERS, false));
502	register(BasicTransactionOptionMetadata.newBoolean(
503	Transaction.OPTION_NO_VALIDATION, false));
504	register(BasicTransactionOptionMetadata.newBoolean(
505	Transaction.OPTION_NO_UNDO, false));
506	register(BasicTransactionOptionMetadata.newBoolean(
507	Transaction.OPTION_UNPROTECTED, false));
508	register(BasicTransactionOptionMetadata.newBoolean(
509	Transaction.OPTION_IS_UNDO_REDO_TRANSACTION, false));
510
511	register(new ValidateEditOption());
512	register(new BasicTransactionOptionMetadata(
513	Transaction.OPTION_VALIDATE_EDIT_CONTEXT));
514
515	register(BasicTransactionOptionMetadata.newBoolean(
516	TransactionImpl.OPTION_IS_TRIGGER_TRANSACTION, false));
517	register(new AllowChangePropagationBlockingOption());
518	register(new BlockChangePropagationOption());
519	}
520	};
521
522	/**
523	* Obtains a metadata object describing the specified transaction
524	* option. For unrecognized options, a default meta-data is provided
525	* that gives reasonable answers.
526	*
527	* @param option
528	* an option key
529	* @return the option meta-data (never <code>null</code>)
530	*/
531	Transaction.OptionMetadata getOptionMetadata(Object option);
532	}
533
534	}
313	}	535	}




/**
 * <copyright>
 * 
 * Copyright (c) 2008 Zeligsoft Inc. 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:
 *   Zeligsoft - Initial API and implementation
 * 
 * </copyright>
 *
 * $Id$
 */

package org.eclipse.emf.transaction.internal;

import java.util.Map;

import org.eclipse.emf.transaction.impl.TransactionImpl;
import org.eclipse.emf.transaction.util.BasicTransactionOptionMetadata;


/**
 * Metadata implementation for the non-trivial complexity of the
 * {@link TransactionImpl#ALLOW_CHANGE_PROPAGATION_BLOCKING} transaction option.
 * 
 * @author Christian W. Damus (cdamus)
 * 
 * @since 1.3
 */
public class AllowChangePropagationBlockingOption
		extends BasicTransactionOptionMetadata {

	/**
	 * Initializes me.
	 */
	public AllowChangePropagationBlockingOption() {
		super(TransactionImpl.ALLOW_CHANGE_PROPAGATION_BLOCKING, false, true,
			Boolean.class, Boolean.FALSE);
	}

	@Override
	public void inherit(Map<?, ?> parentOptions,
			Map<Object, Object> childOptions, boolean force) {

        // do not inherit the allow block option if the block option is
        // already applied
        if (!childOptions.containsKey(TransactionImpl.BLOCK_CHANGE_PROPAGATION)) {
            childOptions.put(getOption(), getValue(parentOptions));
        }
	}

}




/**
 * <copyright>
 * 
 * Copyright (c) 2008 Zeligsoft Inc. 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:
 *   Zeligsoft - Initial API and implementation
 * 
 * </copyright>
 *
 * $Id$
 */

package org.eclipse.emf.transaction.util;

import java.util.Map;

import org.eclipse.emf.transaction.Transaction;

/**
 * A simple implementation of the {@link Transaction.OptionMetadata} interface.
 * 
 * @author Christian W. Damus (cdamus)
 * 
 * @since 1.3
 */
public class BasicTransactionOptionMetadata
		implements Transaction.OptionMetadata {

	private final Object option;

	private boolean isTag;

	private boolean isHereditary;

	private Class<?> type;

	private Object defaultValue;

	/**
	 * Initializes me with my option key.
	 * 
	 * @param option
	 *            my option key
	 */
	public BasicTransactionOptionMetadata(Object option) {
		this(option, true, true, Object.class, null);
	}

	/**
	 * Initializes me with my option key and other details.
	 * 
	 * @param option
	 *            my option key
	 * @param isTag
	 *            whether the option is a tag
	 * @param isHereditary
	 *            whether the option is inherited
	 * @param type
	 *            the option type
	 * @param defaultValue
	 *            the option's defaul value
	 */
	public BasicTransactionOptionMetadata(Object option, boolean isTag,
			boolean isHereditary, Class<?> type, Object defaultValue) {
		this.option = option;
		this.isTag = isTag;
		this.isHereditary = isHereditary;
		this.type = type;
		this.defaultValue = defaultValue;
	}

	public Object getDefaultValue() {
		return defaultValue;
	}

	public final Object getOption() {
		return option;
	}

	public Class<?> getType() {
		return type;
	}

	public boolean isHereditary() {
		return isHereditary;
	}

	public boolean isTag() {
		return isTag;
	}
	
	public Object getValue(Map<?, ?> options) {
		return options.containsKey(option)
			? options.get(option)
			: getDefaultValue();
	}
	
	public boolean isSet(Map<?, ?> options) {
		return options.containsKey(option);
	}
	
	public boolean sameSetting(Map<?, ?> options1, Map<?, ?> options2) {
		return safeEquals(getValue(options1), getValue(options2));
	}
	
	public void inherit(Map<?, ?> parentOptions,
			Map<Object, Object> childOptions, boolean force) {

		if ((force || isHereditary()) && !isSet(childOptions)) {
			childOptions.put(option, getValue(parentOptions));
		}
	}
	
	protected boolean safeEquals(Object a, Object b) {
		return (a == null)
			? b == null
			: a.equals(b);
	}
	
	protected Class<?> safeClass(Object o) {
		return (o == null)
			? Void.class
			: o.getClass();
	}
	
	/**
	 * Creates a new transaction option meta-data for an heritary, non-tag,
	 * boolean-valued option.
	 * 
	 * @param option
	 *            the option key
	 * @param defaultValue
	 *            the option's default value
	 * 
	 * @return the option meta-data
	 */
	public static Transaction.OptionMetadata newBoolean(Object option,
			boolean defaultValue) {
		
		return new BasicTransactionOptionMetadata(option, false, true,
			Boolean.class, Boolean.valueOf(defaultValue));
	}
	
	@Override
	public String toString() {
		return "Option[key=" + getOption() //$NON-NLS-1$
			+ ", isTag=" + isTag() //$NON-NLS-1$
			+ ", isHereditary=" + isHereditary() //$NON-NLS-1$
			+ ", type=" + getType().getName() //$NON-NLS-1$
			+ ", default=" + getDefaultValue() + ']'; //$NON-NLS-1$
	}
}




/**
 * <copyright>
 * 
 * Copyright (c) 2008 Zeligsoft Inc. 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:
 *   Zeligsoft - Initial API and implementation
 * 
 * </copyright>
 *
 * $Id$
 */

package org.eclipse.emf.transaction.internal;

import java.util.Map;

import org.eclipse.emf.transaction.impl.TransactionImpl;
import org.eclipse.emf.transaction.util.BasicTransactionOptionMetadata;


/**
 * Metadata implementation for the non-trivial complexity of the
 * {@link TransactionImpl#BLOCK_CHANGE_PROPAGATION} transaction option.
 * 
 * @author Christian W. Damus (cdamus)
 * 
 * @since 1.3
 */
public class BlockChangePropagationOption
		extends BasicTransactionOptionMetadata {

	/**
	 * Initializes me.
	 */
	public BlockChangePropagationOption() {
		super(TransactionImpl.BLOCK_CHANGE_PROPAGATION, false, false,
			Boolean.class, Boolean.FALSE);
	}

	@Override
	public void inherit(Map<?, ?> parentOptions,
			Map<Object, Object> childOptions, boolean force) {

        // never inherit this option, even when requested to force
	}

}




/**
 * <copyright>
 * 
 * Copyright (c) 2008 Zeligsoft Inc. 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:
 *   Zeligsoft - Initial API and implementation
 * 
 * </copyright>
 *
 * $Id$
 */

package org.eclipse.emf.transaction.util;

import org.eclipse.emf.transaction.Transaction;

/**
 * A simple implementation of the transaction option metadata registry API.
 * 
 * @author Christian W. Damus (cdamus)
 * 
 * @since 1.3
 */
public class BasicTransactionOptionMetadataRegistry
		extends java.util.HashMap<Object, Transaction.OptionMetadata>
		implements Transaction.OptionMetadata.Registry {

	private static final long serialVersionUID = 1L;

	private final Transaction.OptionMetadata.Registry delegate;

	/**
	 * Initializes me with the shared registry instance as my delegate.
	 */
	public BasicTransactionOptionMetadataRegistry() {
		this(Transaction.OptionMetadata.Registry.INSTANCE);
	}

	/**
	 * Initializes me with a registry to which I delegate options that I do not
	 * provide for.
	 * 
	 * @param delegate
	 *            my delegate
	 */
	protected BasicTransactionOptionMetadataRegistry(
			Transaction.OptionMetadata.Registry delegate) {
		this.delegate = delegate;
	}

	public Transaction.OptionMetadata getOptionMetadata(Object option) {
		Transaction.OptionMetadata result = get(option);

		if (result == null) {
			result = delegatedGetOptionMetadata(option);
		}
		
		if (result == null) {
			// create an ephemeral default metadata
			result = new BasicTransactionOptionMetadata(option);
		}

		return result;
	}

	protected Transaction.OptionMetadata delegatedGetOptionMetadata(
			Object option) {
		
		return (delegate == null)
			? null
			: delegate.getOptionMetadata(option);
	}

	/**
	 * Registers an option metadata descriptor.
	 * 
	 * @param metadata
	 *            the option metadata to register
	 * @return the metadata displaced by the new object, if previously we had a
	 *         descriptor for the same option, otherwise <code>null</code>
	 */
	public Transaction.OptionMetadata register(
			Transaction.OptionMetadata metadata) {
		return put(metadata.getOption(), metadata);
	}
}




/**
 * <copyright>
 * 
 * Copyright (c) 2008 Zeligsoft Inc. 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:
 *   Zeligsoft - Initial API and implementation
 * 
 * </copyright>
 *
 * $Id$
 */

package org.eclipse.emf.transaction.internal;

import java.util.Map;

import org.eclipse.emf.transaction.Transaction;
import org.eclipse.emf.transaction.util.BasicTransactionOptionMetadata;
import org.eclipse.emf.transaction.util.ValidateEditSupport;

/**
 * Metadata implementation for the non-trivial complexity of the
 * {@link Transaction#OPTION_VALIDATE_EDIT} transaction option.
 * 
 * @author Christian W. Damus (cdamus)
 * 
 * @since 1.3
 */
public class ValidateEditOption
		extends BasicTransactionOptionMetadata {

	/**
	 * Initializes me.
	 */
	public ValidateEditOption() {
		super(Transaction.OPTION_VALIDATE_EDIT, true, false, Object.class,
			Boolean.FALSE);
	}

	@Override
	public boolean sameSetting(Map<?, ?> options1, Map<?, ?> options2) {

		Object value1 = getValue(options1);
		Object value2 = getValue(options2);
		boolean result = safeEquals(value1, value2);

		if (!result) {
			// they may, yet, be equivalent

			final Class<?> vesd = ValidateEditSupport.Default.class;

			if (value1 instanceof Boolean) {
				if ((Boolean) value1) {
					// TRUE === new
					// ValidateEditSupport.Default
					result = safeClass(value2) == vesd;
				}
			} else if (safeClass(value1) == vesd) {
				result = Boolean.TRUE.equals(value2)
					|| (safeClass(value2) == vesd);
			}
		}

		return result;
	}

}




/**
 * <copyright>
 *
 * Copyright (c) 2005, 2008 IBM Corporation, Zeligsoft Inc., 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

 *
 * Contributors:
 *   IBM - Initial API and implementation
 *   Zeligsoft - Bugs 240775, 245446
 *
 * </copyright>
 *

package org.eclipse.emf.workspace;

import org.eclipse.core.commands.operations.IOperationHistory;
import org.eclipse.core.commands.operations.IUndoableOperation;
import org.eclipse.core.commands.operations.OperationHistoryFactory;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
import org.eclipse.emf.transaction.Transaction;
import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.emf.transaction.impl.TransactionalEditingDomainImpl;
import org.eclipse.emf.transaction.util.BasicTransactionOptionMetadata;
import org.eclipse.emf.transaction.util.BasicTransactionOptionMetadataRegistry;
import org.eclipse.emf.workspace.impl.WorkspaceCommandStackImpl;
import org.eclipse.emf.workspace.internal.EMFWorkspacePlugin;

/**
 * <p>

	public static final WorkspaceEditingDomainFactory INSTANCE =
		new WorkspaceEditingDomainFactory();
	
	static {
		BasicTransactionOptionMetadataRegistry reg = (BasicTransactionOptionMetadataRegistry) Transaction.OptionMetadata.Registry.INSTANCE;

		reg.register(new BasicTransactionOptionMetadata(
			EMFWorkspacePlugin.OPTION_OWNING_OPERATION, true, true,
			IUndoableOperation.class, null));
	}
	
	/**
	 * Initializes me.
	 */

	 * 
	 * @return the new editing domain
	 */
	public synchronized TransactionalEditingDomain createEditingDomain(IOperationHistory history) {
		WorkspaceCommandStackImpl stack = new WorkspaceCommandStackImpl(history);
		stack.setResourceUndoContextPolicy(getResourceUndoContextPolicy());
		

	 * 
	 * @return the new editing domain
	 */
	public synchronized TransactionalEditingDomain createEditingDomain(ResourceSet rset, IOperationHistory history) {
		WorkspaceCommandStackImpl stack = new WorkspaceCommandStackImpl(history);
		stack.setResourceUndoContextPolicy(getResourceUndoContextPolicy());
		




	 */
	private boolean optionsDiffer(Map<?, ?> options) {
		boolean result = true;

		Transaction active = ((InternalTransactionalEditingDomain) getEditingDomain())
			.getActiveTransaction();
		if ((active != null) && !active.isReadOnly()) {
			Transaction.OptionMetadata.Registry reg = TransactionUtil
				.getTransactionOptionRegistry(getEditingDomain());

			result = false; // let's look for a difference
			Map<?, ?> activeOptions = active.getOptions();

			// iterate the options passed in that would be applied to the
			// nested transaction, because if the active (to-be parent)
			// specifies more options, then they would be inherited, anyway
			for (Map.Entry<?, ?> next : options.entrySet()) {
				Object option = next.getKey();

				Transaction.OptionMetadata metadata = reg
					.getOptionMetadata(option);

				// tags don't force child transactions. Clients would have
				// to disable nesting if it really matters to them, or else
				// override the option meta-data in their editing domain's
				// local registry
				if (!metadata.isTag()
					&& !metadata.sameSetting(options, activeOptions)) {

					result = true;
					break;
				}
			}
		}

		return result;
	}
    

Return to bug 245446

Lines 9-15 Link Here

(-)src/org/eclipse/emf/transaction/impl/TransactionImpl.java (-18 / +12 lines)
9	*	9	*
10	* Contributors:	10	* Contributors:
11	* IBM - Initial API and implementation	11	* IBM - Initial API and implementation
12	* Zeligsoft - Bugs 145877, 250253	12	* Zeligsoft - Bugs 145877, 250253, 245446
13	*	13	*
14	* </copyright>	14	* </copyright>
15	*	15	*
Lines 832-857 Link Here
832	private void inheritOptions(Transaction parent) {	832	private void inheritOptions(Transaction parent) {
833		833
834	// if we have no parent transaction, then we are a root and we "inherit"	834	// if we have no parent transaction, then we are a root and we "inherit"
835	// the editing domain's default transaction options	835	// the editing domain's default transaction options. In the root case,
836	Map<?, ?> parentOptions = (parent == null) ?	836	// we don't consider whether an option is hereditary because, of course,
		837	// we aren't actually inheriting it from any other transaction
		838	final boolean isRoot = parent == null;
		839	Map<?, ?> parentOptions = isRoot ?
837	getDefaultOptions(getEditingDomain()) : parent.getOptions();	840	getDefaultOptions(getEditingDomain()) : parent.getOptions();
838		841
839	if (parentOptions != null) {	842	if (parentOptions != null) {
840	for (Map.Entry<?, ?> next : parentOptions.entrySet()) {	843	Transaction.OptionMetadata.Registry reg = TransactionUtil
841	Object option = next.getKey();	844	.getTransactionOptionRegistry(getEditingDomain());
842		845
843	if (ALLOW_CHANGE_PROPAGATION_BLOCKING.equals(option)) {	846	for (Object option : parentOptions.keySet()) {
844	// Do not inherit the allow block option if we have the	847	reg.getOptionMetadata(option).inherit(parentOptions,
845	// block option applied	848	mutableOptions, isRoot);
846	if (!mutableOptions.containsKey(BLOCK_CHANGE_PROPAGATION)) {
847	mutableOptions.put(option, next.getValue());
848	}
849	} else if (BLOCK_CHANGE_PROPAGATION.equals(option)) {
850	// don't inherit the block option!
851	} else if (!mutableOptions.containsKey(option)) {
852	// overridden by child transaction options
853	mutableOptions.put(option, next.getValue());
854	}
855	}	849	}
856	}	850	}
857	}	851	}

Lines 203-215 Link Here

(-)src/org/eclipse/emf/workspace/AbstractEMFOperation.java (-5 / +30 lines)
203	*/	203	*/
204	private boolean optionsDiffer(Map<?, ?> options) {	204	private boolean optionsDiffer(Map<?, ?> options) {
205	boolean result = true;	205	boolean result = true;
206		206
207	Transaction active =	207	Transaction active = ((InternalTransactionalEditingDomain) getEditingDomain())
208	((InternalTransactionalEditingDomain) getEditingDomain()).getActiveTransaction();	208	.getActiveTransaction();
209	if ((active != null) && !active.isReadOnly()) {	209	if ((active != null) && !active.isReadOnly()) {
210	result = !active.getOptions().equals(options);	210	Transaction.OptionMetadata.Registry reg = TransactionUtil
		211	.getTransactionOptionRegistry(getEditingDomain());
		212
		213	result = false; // let's look for a difference
		214	Map<?, ?> activeOptions = active.getOptions();
		215
		216	// iterate the options passed in that would be applied to the
		217	// nested transaction, because if the active (to-be parent)
		218	// specifies more options, then they would be inherited, anyway
		219	for (Map.Entry<?, ?> next : options.entrySet()) {
		220	Object option = next.getKey();
		221
		222	Transaction.OptionMetadata metadata = reg
		223	.getOptionMetadata(option);
		224
		225	// tags don't force child transactions. Clients would have
		226	// to disable nesting if it really matters to them, or else
		227	// override the option meta-data in their editing domain's
		228	// local registry
		229	if (!metadata.isTag()
		230	&& !metadata.sameSetting(options, activeOptions)) {
		231
		232	result = true;
		233	break;
		234	}
		235	}
211	}	236	}
212		237
213	return result;	238	return result;
214	}	239	}
215		240

Lines 1-7 Link Here

(-)src/org/eclipse/emf/transaction/util/TransactionUtil.java (-1 / +27 lines)
1	/**	1	/**
2	* <copyright>	2	* <copyright>
3	*	3	*
4	* Copyright (c) 2006, 2007 IBM Corporation and others.	4	* Copyright (c) 2006, 2008 IBM Corporation, Zeligsoft Inc., and others.
5	* All rights reserved. This program and the accompanying materials	5	* All rights reserved. This program and the accompanying materials
6	* are made available under the terms of the Eclipse Public License v1.0	6	* are made available under the terms of the Eclipse Public License v1.0
7	* which accompanies this distribution, and is available at	7	* which accompanies this distribution, and is available at
Lines 9-14 Link Here
9	*	9	*
10	* Contributors:	10	* Contributors:
11	* IBM - Initial API and implementation	11	* IBM - Initial API and implementation
		12	* Zeligsoft - Bug 245446
12	*	13	*
13	* </copyright>	14	* </copyright>
14	*	15	*
Lines 352-355 Link Here
352		353
353	return (RunnableWithResult<T>) domain.createPrivilegedRunnable(runnable);	354	return (RunnableWithResult<T>) domain.createPrivilegedRunnable(runnable);
354	}	355	}
		356
		357	/**
		358	* Gets the best transaction-option registry available for the specified
		359	* editing <tt>domain</tt>. Usually, it will be a registry that is local to
		360	* that domain, but it may be the
		361	* {@linkplain Transaction.OptionMetadata.Registry#INSTANCE shared instance}
		362	* under extreme circumstances.
		363	*
		364	* @param domain
		365	* an editing domain
		366	* @return its transaction options registry, never <code>null</code>
		367	*
		368	* @since 1.3
		369	*/
		370	public static Transaction.OptionMetadata.Registry getTransactionOptionRegistry(
		371	TransactionalEditingDomain domain) {
		372	Transaction.OptionMetadata.Registry result = getAdapter(domain,
		373	Transaction.OptionMetadata.Registry.class);
		374
		375	if (result == null) {
		376	result = Transaction.OptionMetadata.Registry.INSTANCE;
		377	}
		378
		379	return result;
		380	}
355	}	381	}

Added Link Here

(-)src/org/eclipse/emf/transaction/internal/AllowChangePropagationBlockingOption.java (+56 lines)
1	/**
2	* <copyright>
3	*
4	* Copyright (c) 2008 Zeligsoft Inc. and others.
5	* All rights reserved. This program and the accompanying materials
6	* are made available under the terms of the Eclipse Public License v1.0
7	* which accompanies this distribution, and is available at
8	* http://www.eclipse.org/legal/epl-v10.html
9	*
10	* Contributors:
11	* Zeligsoft - Initial API and implementation
12	*
13	* </copyright>
14	*
15	* $Id$
16	*/
17
18	package org.eclipse.emf.transaction.internal;
19
20	import java.util.Map;
21
22	import org.eclipse.emf.transaction.impl.TransactionImpl;
23	import org.eclipse.emf.transaction.util.BasicTransactionOptionMetadata;
24
25
26	/**
27	* Metadata implementation for the non-trivial complexity of the
28	* {@link TransactionImpl#ALLOW_CHANGE_PROPAGATION_BLOCKING} transaction option.
29	*
30	* @author Christian W. Damus (cdamus)
31	*
32	* @since 1.3
33	*/
34	public class AllowChangePropagationBlockingOption
35	extends BasicTransactionOptionMetadata {
36
37	/**
38	* Initializes me.
39	*/
40	public AllowChangePropagationBlockingOption() {
41	super(TransactionImpl.ALLOW_CHANGE_PROPAGATION_BLOCKING, false, true,
42	Boolean.class, Boolean.FALSE);
43	}
44
45	@Override
46	public void inherit(Map<?, ?> parentOptions,
47	Map<Object, Object> childOptions, boolean force) {
48
49	// do not inherit the allow block option if the block option is
50	// already applied
51	if (!childOptions.containsKey(TransactionImpl.BLOCK_CHANGE_PROPAGATION)) {
52	childOptions.put(getOption(), getValue(parentOptions));
53	}
54	}
55
56	}

Lines 1-7 Link Here

(-)src/org/eclipse/emf/workspace/WorkspaceEditingDomainFactory.java (-4 / +17 lines)
1	/**	1	/**
2	* <copyright>	2	* <copyright>
3	*	3	*
4	* Copyright (c) 2005, 2008 IBM Corporation, Zeligoft Inc., and others.	4	* Copyright (c) 2005, 2008 IBM Corporation, Zeligsoft Inc., and others.
5	* All rights reserved. This program and the accompanying materials	5	* All rights reserved. This program and the accompanying materials
6	* are made available under the terms of the Eclipse Public License v1.0	6	* are made available under the terms of the Eclipse Public License v1.0
7	* which accompanies this distribution, and is available at	7	* which accompanies this distribution, and is available at
Lines 9-15 Link Here
9	*	9	*
10	* Contributors:	10	* Contributors:
11	* IBM - Initial API and implementation	11	* IBM - Initial API and implementation
12	* Zeligsoft - Bug 240775	12	* Zeligsoft - Bugs 240775, 245446
13	*	13	*
14	* </copyright>	14	* </copyright>
15	*	15	*
Lines 18-29 Link Here
18	package org.eclipse.emf.workspace;	18	package org.eclipse.emf.workspace;
19		19
20	import org.eclipse.core.commands.operations.IOperationHistory;	20	import org.eclipse.core.commands.operations.IOperationHistory;
		21	import org.eclipse.core.commands.operations.IUndoableOperation;
21	import org.eclipse.core.commands.operations.OperationHistoryFactory;	22	import org.eclipse.core.commands.operations.OperationHistoryFactory;
22	import org.eclipse.emf.ecore.resource.ResourceSet;	23	import org.eclipse.emf.ecore.resource.ResourceSet;
23	import org.eclipse.emf.edit.provider.ComposedAdapterFactory;	24	import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
		25	import org.eclipse.emf.transaction.Transaction;
24	import org.eclipse.emf.transaction.TransactionalEditingDomain;	26	import org.eclipse.emf.transaction.TransactionalEditingDomain;
25	import org.eclipse.emf.transaction.impl.TransactionalEditingDomainImpl;	27	import org.eclipse.emf.transaction.impl.TransactionalEditingDomainImpl;
		28	import org.eclipse.emf.transaction.util.BasicTransactionOptionMetadata;
		29	import org.eclipse.emf.transaction.util.BasicTransactionOptionMetadataRegistry;
26	import org.eclipse.emf.workspace.impl.WorkspaceCommandStackImpl;	30	import org.eclipse.emf.workspace.impl.WorkspaceCommandStackImpl;
		31	import org.eclipse.emf.workspace.internal.EMFWorkspacePlugin;
27		32
28	/**	33	/**
29	* <p>	34	* <p>
Lines 47-52 Link Here
47	public static final WorkspaceEditingDomainFactory INSTANCE =	52	public static final WorkspaceEditingDomainFactory INSTANCE =
48	new WorkspaceEditingDomainFactory();	53	new WorkspaceEditingDomainFactory();
49		54
		55	static {
		56	BasicTransactionOptionMetadataRegistry reg = (BasicTransactionOptionMetadataRegistry) Transaction.OptionMetadata.Registry.INSTANCE;
		57
		58	reg.register(new BasicTransactionOptionMetadata(
		59	EMFWorkspacePlugin.OPTION_OWNING_OPERATION, true, true,
		60	IUndoableOperation.class, null));
		61	}
		62
50	/**	63	/**
51	* Initializes me.	64	* Initializes me.
52	*/	65	*/
Lines 88-94 Link Here
88	*	101	*
89	* @return the new editing domain	102	* @return the new editing domain
90	*/	103	*/
91	public TransactionalEditingDomain createEditingDomain(IOperationHistory history) {	104	public synchronized TransactionalEditingDomain createEditingDomain(IOperationHistory history) {
92	WorkspaceCommandStackImpl stack = new WorkspaceCommandStackImpl(history);	105	WorkspaceCommandStackImpl stack = new WorkspaceCommandStackImpl(history);
93	stack.setResourceUndoContextPolicy(getResourceUndoContextPolicy());	106	stack.setResourceUndoContextPolicy(getResourceUndoContextPolicy());
94		107
Lines 111-117 Link Here
111	*	124	*
112	* @return the new editing domain	125	* @return the new editing domain
113	*/	126	*/
114	public TransactionalEditingDomain createEditingDomain(ResourceSet rset, IOperationHistory history) {	127	public synchronized TransactionalEditingDomain createEditingDomain(ResourceSet rset, IOperationHistory history) {
115	WorkspaceCommandStackImpl stack = new WorkspaceCommandStackImpl(history);	128	WorkspaceCommandStackImpl stack = new WorkspaceCommandStackImpl(history);
116	stack.setResourceUndoContextPolicy(getResourceUndoContextPolicy());	129	stack.setResourceUndoContextPolicy(getResourceUndoContextPolicy());
117		130