plugins/org.eclipse.emf.edapt.history/src/org/eclipse/emf/edapt/history/recorder/ChangeRecorder.java - edapt/org.eclipse.emf.edapt - Git at Google

 /*******************************************************************************
  * Copyright (c) 2007, 2010 BMW Car IT, Technische Universitaet Muenchen, and others.
  * All rights reserved. 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:
  * BMW Car IT - Initial API and implementation
  * Technische Universitaet Muenchen - Major refactoring and extension
  *******************************************************************************/
 package org.eclipse.emf.edapt.history.recorder;

 import static org.eclipse.emf.common.notify.Notification.ADD;
 import static org.eclipse.emf.common.notify.Notification.ADD_MANY;
 import static org.eclipse.emf.common.notify.Notification.MOVE;
 import static org.eclipse.emf.common.notify.Notification.REMOVE;
 import static org.eclipse.emf.common.notify.Notification.REMOVE_MANY;
 import static org.eclipse.emf.common.notify.Notification.SET;

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.IdentityHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;

 import org.eclipse.emf.common.notify.Notification;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EReference;
 import org.eclipse.emf.ecore.EStructuralFeature;
 import org.eclipse.emf.ecore.util.EContentAdapter;
 import org.eclipse.emf.edapt.internal.common.LoggingUtils;
 import org.eclipse.emf.edapt.spi.history.Add;
 import org.eclipse.emf.edapt.spi.history.CompositeChange;
 import org.eclipse.emf.edapt.spi.history.Create;
 import org.eclipse.emf.edapt.spi.history.Delete;
 import org.eclipse.emf.edapt.spi.history.HistoryFactory;
 import org.eclipse.emf.edapt.spi.history.HistoryPlugin;
 import org.eclipse.emf.edapt.spi.history.Move;
 import org.eclipse.emf.edapt.spi.history.PrimitiveChange;
 import org.eclipse.emf.edapt.spi.history.Remove;
 import org.eclipse.emf.edapt.spi.history.Set;
 import org.eclipse.emf.edapt.spi.history.ValueChange;

 /**
  * Facility to record changes on a model
  *
  * @author herrmama
  * @author $Author$
  * @version $Rev$
  * @levd.rating RED Rev:
  */
 public class ChangeRecorder extends GeneratorBase {

 	/**
 	 * Resource for which changes should be recorded
 	 */
 	private final List<? extends EObject> elements;

 	/**
 	 * Cache for candidates of deleted elements, maps candidates to related
 	 * changes
 	 */
 	private Map<EObject, List<PrimitiveChange>> deleteCache;

 	/**
 	 * Adapter listening to the resource contents
 	 */
 	private final EContentAdapter adapter;

 	/**
 	 * Whether the recorder is currently recording
 	 */
 	private boolean recording;

 	/**
 	 * Whether the changes have been consolidated
 	 */
 	private boolean consolidated;

 	/**
 	 * Constructor
 	 */
 	public ChangeRecorder(List<? extends EObject> elements) {
 		this.elements = elements;

 		adapter = new EContentAdapter() {
 			@Override
 			public void notifyChanged(Notification notification) {
 				switch (notification.getEventType()) {
 				case SET:
 					handleSet(notification);
 					break;
 				case ADD:
 					handleAdd(notification);
 					break;
 				case ADD_MANY:
 					handleAddMany(notification);
 					break;
 				case REMOVE:
 					handleRemove(notification);
 					break;
 				case REMOVE_MANY:
 					handleRemoveMany(notification);
 					break;
 				case MOVE:
 					handleMove(notification);
 					break;
 				}
 				super.notifyChanged(notification);
 			}
 		};

 		beginRecording();
 	}

 	/**
 	 * Start the recorder, unless already started
 	 */
 	public void beginRecording() {
 		if (!isRecording()) {
 			doBeginRecording();
 		} else {
 			LoggingUtils.logInfo(HistoryPlugin.getPlugin(), "ChangeRecorder is already started"); //$NON-NLS-1$
 		}
 	}

 	/**
 	 * Start the recorder (can be overwritten by subclasses)
 	 */
 	protected void doBeginRecording() {
 		changeContainer = HistoryFactory.eINSTANCE.createCompositeChange();
 		deleteCache = new IdentityHashMap<EObject, List<PrimitiveChange>>();

 		for (final EObject element : elements) {
 			element.eAdapters().add(adapter);
 		}

 		recording = true;
 		consolidated = false;
 	}

 	/**
 	 * Stop the recorder, unless already stopped
 	 */
 	public void endRecording() {
 		if (isRecording()) {
 			doEndRecording();
 		} else {
 			throw new IllegalStateException("Recorder is already stopped"); //$NON-NLS-1$
 		}
 	}

 	/**
 	 * Get the recorded changes.
 	 */
 	public CompositeChange getChanges() {

 		if (!consolidated) {
 			inferDeletes();
 			inferCreateInitializers();

 			consolidated = true;
 		}

 		return changeContainer;
 	}

 	/**
 	 * Stop the recorder (can be overwritten by subclasses)
 	 */
 	protected void doEndRecording() {
 		for (final EObject element : elements) {
 			element.eAdapters().remove(adapter);
 		}

 		recording = false;
 	}

 	/** Returns recording. */
 	public boolean isRecording() {
 		return recording;
 	}

 	/**
 	 * Infer delete changes
 	 */
 	@SuppressWarnings("unchecked")
 	private void inferDeletes() {
 		for (final Entry<EObject, List<PrimitiveChange>> entry : deleteCache
 			.entrySet()) {
 			final List<PrimitiveChange> list = entry.getValue();
 			final Delete delete = (Delete) list.remove(0);
 			delete.setElement(entry.getKey());
 			delete.getChanges().addAll((List) list);
 		}
 	}

 	/**
 	 * Infer initializers of create changes
 	 */
 	private void inferCreateInitializers() {
 		Create create = null;
 		for (final PrimitiveChange change : new ArrayList<PrimitiveChange>(
 			changeContainer.getChanges())) {
 			if (change instanceof Create) {
 				create = (Create) change;
 			} else if (change instanceof ValueChange) {
 				if (create == null) {
 					continue;
 				}
 				final ValueChange valueChange = (ValueChange) change;
 				if (create.getElement() == valueChange.getElement()) {
 					create.getChanges().add(valueChange);
 				} else {
 					create = null;
 				}
 			} else {
 				create = null;
 			}
 		}
 	}

 	/**
 	 * Handle MOVE notification
 	 */
 	private void handleMove(Notification notification) {
 		// ignore
 	}

 	/**
 	 * Handle REMOVE_MANY notification
 	 */
 	@SuppressWarnings("unchecked")
 	private void handleRemoveMany(Notification notification) {
 		final EStructuralFeature feature = (EStructuralFeature) notification
 			.getFeature();
 		if (skipFeature(feature)) {
 			return;
 		}

 		final EObject element = (EObject) notification.getNotifier();

 		// containment
 		if (feature instanceof EReference
 			&& ((EReference) feature).isContainment()) {
 			for (final EObject oldValue : (List<EObject>) notification.getOldValue()) {
 				handleSingleDelete(element, (EReference) feature, oldValue);
 			}
 		}
 		// cross reference and attribute
 		else {
 			for (final Object oldValue : (List) notification.getOldValue()) {
 				handleSingleRemove(element, feature, oldValue);
 			}
 		}
 	}

 	/**
 	 * Handle REMOVE notification
 	 */
 	private void handleRemove(Notification notification) {
 		final EStructuralFeature feature = (EStructuralFeature) notification
 			.getFeature();
 		if (skipFeature(feature)) {
 			return;
 		}

 		final EObject element = (EObject) notification.getNotifier();

 		// containment
 		if (feature instanceof EReference
 			&& ((EReference) feature).isContainment()) {
 			final EObject oldValue = (EObject) notification.getOldValue();
 			handleSingleDelete(element, (EReference) feature, oldValue);
 		}
 		// cross reference and attribute
 		else {
 			final Object oldValue = notification.getOldValue();
 			handleSingleRemove(element, feature, oldValue);
 		}
 	}

 	/**
 	 * Handle a remove of a single element from a containment reference
 	 */
 	private void handleSingleDelete(EObject element, EReference reference,
 		EObject value) {
 		final Delete delete = delete(null, reference, element);
 		append(delete);
 		final ArrayList<PrimitiveChange> list = new ArrayList<PrimitiveChange>();
 		list.add(delete);
 		deleteCache.put(value, list);
 	}

 	/**
 	 * Handle a remove of a single element from a cross reference or attribute
 	 */
 	private void handleSingleRemove(EObject element,
 		EStructuralFeature feature, Object value) {
 		final Remove remove = remove(element, feature, value);
 		append(remove);

 		if (feature instanceof EReference) {
 			final EObject deleted = getDeleted((EObject) value);
 			if (deleted != null) {
 				deleteCache.get(deleted).add(remove);
 			}
 		}
 	}

 	/**
 	 * Handle ADD_MANY notification
 	 */
 	@SuppressWarnings("unchecked")
 	private void handleAddMany(Notification notification) {
 		final EStructuralFeature feature = (EStructuralFeature) notification
 			.getFeature();
 		if (skipFeature(feature)) {
 			return;
 		}

 		final EObject element = (EObject) notification.getNotifier();

 		// containment
 		if (feature instanceof EReference
 			&& ((EReference) feature).isContainment()) {
 			for (final EObject value : (List<EObject>) notification.getNewValue()) {
 				handleSingleCreate(feature, element, value);
 			}
 		}
 		// cross reference and attribute
 		else {
 			for (final Object value : (List) notification.getNewValue()) {
 				handleSingleAdd(feature, element, value);
 			}
 		}
 	}

 	/**
 	 * Handle ADD notification
 	 */
 	private void handleAdd(Notification notification) {
 		final EStructuralFeature feature = (EStructuralFeature) notification
 			.getFeature();
 		if (skipFeature(feature)) {
 			return;
 		}

 		final EObject element = (EObject) notification.getNotifier();

 		// containment
 		if (feature instanceof EReference
 			&& ((EReference) feature).isContainment()) {
 			final EObject newValue = (EObject) notification.getNewValue();
 			handleSingleCreate(feature, element, newValue);
 		}
 		// cross reference and attribute
 		else {
 			final Object newValue = notification.getNewValue();
 			handleSingleAdd(feature, element, newValue);
 		}
 	}

 	/**
 	 * Handle an addition of a single element to a cross reference or attribute
 	 */
 	private void handleSingleAdd(EStructuralFeature feature, EObject element,
 		Object value) {
 		final Add add = add(element, feature, value);
 		append(add);
 	}

 	/**
 	 * Handle an addition of a single element to a containment reference
 	 */
 	private void handleSingleCreate(EStructuralFeature feature,
 		EObject element, EObject value) {
 		if (deleteCache.containsKey(value)) {
 			final Delete delete = (Delete) deleteCache.remove(value).get(0);
 			final Move move = move(value, delete.getTarget(), (EReference) feature,
 				element);

 			replace(delete, move);
 		} else {
 			generateElements(Collections.singletonList(value));
 		}
 	}

 	/**
 	 * Handle SET notification
 	 */
 	private void handleSet(Notification notification) {
 		final EStructuralFeature feature = (EStructuralFeature) notification
 			.getFeature();
 		if (skipFeature(feature)) {
 			return;
 		}

 		// containment
 		if (feature instanceof EReference
 			&& ((EReference) feature).isContainment()) {
 			return;
 		}

 		// cross reference and attribute
 		if (notification.getOldValue() == notification.getNewValue()) {
 			// no change
 			return;
 		}

 		final EObject element = (EObject) notification.getNotifier();
 		final Object newValue = notification.getNewValue();
 		final Set set = set(element, notification.getOldValue(), feature, newValue);
 		append(set);

 		if (feature instanceof EReference) {
 			final EObject oldValue = (EObject) notification.getOldValue();
 			final EObject deleted = getDeleted(oldValue);
 			if (deleted != null) {
 				deleteCache.get(deleted).add(set);
 			}
 		}
 	}

 	/**
 	 * Replace a primitive change by another one in the changes
 	 */
 	protected void replace(PrimitiveChange toReplace, PrimitiveChange replaceBy) {
 		final List<PrimitiveChange> changes = changeContainer.getChanges();
 		final int index = changes.indexOf(toReplace);
 		changes.set(index, replaceBy);
 	}

 	/**
 	 * Get parent element which was deleted
 	 */
 	private EObject getDeleted(EObject element) {
 		while (element != null) {
 			if (deleteCache.containsKey(element)) {
 				return element;
 			}
 			element = element.eContainer();
 		}
 		return null;
 	}

 	/** Returns elements. */
 	public List<? extends EObject> getElements() {
 		return elements;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2007, 2010 BMW Car IT, Technische Universitaet Muenchen, and others.
	* All rights reserved. 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:
	* BMW Car IT - Initial API and implementation
	* Technische Universitaet Muenchen - Major refactoring and extension
	*******************************************************************************/
	package org.eclipse.emf.edapt.history.recorder;

	import static org.eclipse.emf.common.notify.Notification.ADD;
	import static org.eclipse.emf.common.notify.Notification.ADD_MANY;
	import static org.eclipse.emf.common.notify.Notification.MOVE;
	import static org.eclipse.emf.common.notify.Notification.REMOVE;
	import static org.eclipse.emf.common.notify.Notification.REMOVE_MANY;
	import static org.eclipse.emf.common.notify.Notification.SET;

	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.IdentityHashMap;
	import java.util.List;
	import java.util.Map;
	import java.util.Map.Entry;

	import org.eclipse.emf.common.notify.Notification;
	import org.eclipse.emf.ecore.EObject;
	import org.eclipse.emf.ecore.EReference;
	import org.eclipse.emf.ecore.EStructuralFeature;
	import org.eclipse.emf.ecore.util.EContentAdapter;
	import org.eclipse.emf.edapt.internal.common.LoggingUtils;
	import org.eclipse.emf.edapt.spi.history.Add;
	import org.eclipse.emf.edapt.spi.history.CompositeChange;
	import org.eclipse.emf.edapt.spi.history.Create;
	import org.eclipse.emf.edapt.spi.history.Delete;
	import org.eclipse.emf.edapt.spi.history.HistoryFactory;
	import org.eclipse.emf.edapt.spi.history.HistoryPlugin;
	import org.eclipse.emf.edapt.spi.history.Move;
	import org.eclipse.emf.edapt.spi.history.PrimitiveChange;
	import org.eclipse.emf.edapt.spi.history.Remove;
	import org.eclipse.emf.edapt.spi.history.Set;
	import org.eclipse.emf.edapt.spi.history.ValueChange;

	/**
	* Facility to record changes on a model
	*
	* @author herrmama
	* @author $Author$
	* @version $Rev$
	* @levd.rating RED Rev:
	*/
	public class ChangeRecorder extends GeneratorBase {

	/**
	* Resource for which changes should be recorded
	*/
	private final List<? extends EObject> elements;

	/**
	* Cache for candidates of deleted elements, maps candidates to related
	* changes
	*/
	private Map<EObject, List<PrimitiveChange>> deleteCache;

	/**
	* Adapter listening to the resource contents
	*/
	private final EContentAdapter adapter;

	/**
	* Whether the recorder is currently recording
	*/
	private boolean recording;

	/**
	* Whether the changes have been consolidated
	*/
	private boolean consolidated;

	/**
	* Constructor
	*/
	public ChangeRecorder(List<? extends EObject> elements) {
	this.elements = elements;

	adapter = new EContentAdapter() {
	@Override
	public void notifyChanged(Notification notification) {
	switch (notification.getEventType()) {
	case SET:
	handleSet(notification);
	break;
	case ADD:
	handleAdd(notification);
	break;
	case ADD_MANY:
	handleAddMany(notification);
	break;
	case REMOVE:
	handleRemove(notification);
	break;
	case REMOVE_MANY:
	handleRemoveMany(notification);
	break;
	case MOVE:
	handleMove(notification);
	break;
	}
	super.notifyChanged(notification);
	}
	};

	beginRecording();
	}

	/**
	* Start the recorder, unless already started
	*/
	public void beginRecording() {
	if (!isRecording()) {
	doBeginRecording();
	} else {
	LoggingUtils.logInfo(HistoryPlugin.getPlugin(), "ChangeRecorder is already started"); //$NON-NLS-1$
	}
	}

	/**
	* Start the recorder (can be overwritten by subclasses)
	*/
	protected void doBeginRecording() {
	changeContainer = HistoryFactory.eINSTANCE.createCompositeChange();
	deleteCache = new IdentityHashMap<EObject, List<PrimitiveChange>>();

	for (final EObject element : elements) {
	element.eAdapters().add(adapter);
	}

	recording = true;
	consolidated = false;
	}

	/**
	* Stop the recorder, unless already stopped
	*/
	public void endRecording() {
	if (isRecording()) {
	doEndRecording();
	} else {
	throw new IllegalStateException("Recorder is already stopped"); //$NON-NLS-1$
	}
	}

	/**
	* Get the recorded changes.
	*/
	public CompositeChange getChanges() {

	if (!consolidated) {
	inferDeletes();
	inferCreateInitializers();

	consolidated = true;
	}

	return changeContainer;
	}

	/**
	* Stop the recorder (can be overwritten by subclasses)
	*/
	protected void doEndRecording() {
	for (final EObject element : elements) {
	element.eAdapters().remove(adapter);
	}

	recording = false;
	}

	/** Returns recording. */
	public boolean isRecording() {
	return recording;
	}

	/**
	* Infer delete changes
	*/
	@SuppressWarnings("unchecked")
	private void inferDeletes() {
	for (final Entry<EObject, List<PrimitiveChange>> entry : deleteCache
	.entrySet()) {
	final List<PrimitiveChange> list = entry.getValue();
	final Delete delete = (Delete) list.remove(0);
	delete.setElement(entry.getKey());
	delete.getChanges().addAll((List) list);
	}
	}

	/**
	* Infer initializers of create changes
	*/
	private void inferCreateInitializers() {
	Create create = null;
	for (final PrimitiveChange change : new ArrayList<PrimitiveChange>(
	changeContainer.getChanges())) {
	if (change instanceof Create) {
	create = (Create) change;
	} else if (change instanceof ValueChange) {
	if (create == null) {
	continue;
	}
	final ValueChange valueChange = (ValueChange) change;
	if (create.getElement() == valueChange.getElement()) {
	create.getChanges().add(valueChange);
	} else {
	create = null;
	}
	} else {
	create = null;
	}
	}
	}

	/**
	* Handle MOVE notification
	*/
	private void handleMove(Notification notification) {
	// ignore
	}

	/**
	* Handle REMOVE_MANY notification
	*/
	@SuppressWarnings("unchecked")
	private void handleRemoveMany(Notification notification) {
	final EStructuralFeature feature = (EStructuralFeature) notification
	.getFeature();
	if (skipFeature(feature)) {
	return;
	}

	final EObject element = (EObject) notification.getNotifier();

	// containment
	if (feature instanceof EReference
	&& ((EReference) feature).isContainment()) {
	for (final EObject oldValue : (List<EObject>) notification.getOldValue()) {
	handleSingleDelete(element, (EReference) feature, oldValue);
	}
	}
	// cross reference and attribute
	else {
	for (final Object oldValue : (List) notification.getOldValue()) {
	handleSingleRemove(element, feature, oldValue);
	}
	}
	}

	/**
	* Handle REMOVE notification
	*/
	private void handleRemove(Notification notification) {
	final EStructuralFeature feature = (EStructuralFeature) notification
	.getFeature();
	if (skipFeature(feature)) {
	return;
	}

	final EObject element = (EObject) notification.getNotifier();

	// containment
	if (feature instanceof EReference
	&& ((EReference) feature).isContainment()) {
	final EObject oldValue = (EObject) notification.getOldValue();
	handleSingleDelete(element, (EReference) feature, oldValue);
	}
	// cross reference and attribute
	else {
	final Object oldValue = notification.getOldValue();
	handleSingleRemove(element, feature, oldValue);
	}
	}

	/**
	* Handle a remove of a single element from a containment reference
	*/
	private void handleSingleDelete(EObject element, EReference reference,
	EObject value) {
	final Delete delete = delete(null, reference, element);
	append(delete);
	final ArrayList<PrimitiveChange> list = new ArrayList<PrimitiveChange>();
	list.add(delete);
	deleteCache.put(value, list);
	}

	/**
	* Handle a remove of a single element from a cross reference or attribute
	*/
	private void handleSingleRemove(EObject element,
	EStructuralFeature feature, Object value) {
	final Remove remove = remove(element, feature, value);
	append(remove);

	if (feature instanceof EReference) {
	final EObject deleted = getDeleted((EObject) value);
	if (deleted != null) {
	deleteCache.get(deleted).add(remove);
	}
	}
	}

	/**
	* Handle ADD_MANY notification
	*/
	@SuppressWarnings("unchecked")
	private void handleAddMany(Notification notification) {
	final EStructuralFeature feature = (EStructuralFeature) notification
	.getFeature();
	if (skipFeature(feature)) {
	return;
	}

	final EObject element = (EObject) notification.getNotifier();

	// containment
	if (feature instanceof EReference
	&& ((EReference) feature).isContainment()) {
	for (final EObject value : (List<EObject>) notification.getNewValue()) {
	handleSingleCreate(feature, element, value);
	}
	}
	// cross reference and attribute
	else {
	for (final Object value : (List) notification.getNewValue()) {
	handleSingleAdd(feature, element, value);
	}
	}
	}

	/**
	* Handle ADD notification
	*/
	private void handleAdd(Notification notification) {
	final EStructuralFeature feature = (EStructuralFeature) notification
	.getFeature();
	if (skipFeature(feature)) {
	return;
	}

	final EObject element = (EObject) notification.getNotifier();

	// containment
	if (feature instanceof EReference
	&& ((EReference) feature).isContainment()) {
	final EObject newValue = (EObject) notification.getNewValue();
	handleSingleCreate(feature, element, newValue);
	}
	// cross reference and attribute
	else {
	final Object newValue = notification.getNewValue();
	handleSingleAdd(feature, element, newValue);
	}
	}

	/**
	* Handle an addition of a single element to a cross reference or attribute
	*/
	private void handleSingleAdd(EStructuralFeature feature, EObject element,
	Object value) {
	final Add add = add(element, feature, value);
	append(add);
	}

	/**
	* Handle an addition of a single element to a containment reference
	*/
	private void handleSingleCreate(EStructuralFeature feature,
	EObject element, EObject value) {
	if (deleteCache.containsKey(value)) {
	final Delete delete = (Delete) deleteCache.remove(value).get(0);
	final Move move = move(value, delete.getTarget(), (EReference) feature,
	element);

	replace(delete, move);
	} else {
	generateElements(Collections.singletonList(value));
	}
	}

	/**
	* Handle SET notification
	*/
	private void handleSet(Notification notification) {
	final EStructuralFeature feature = (EStructuralFeature) notification
	.getFeature();
	if (skipFeature(feature)) {
	return;
	}

	// containment
	if (feature instanceof EReference
	&& ((EReference) feature).isContainment()) {
	return;
	}

	// cross reference and attribute
	if (notification.getOldValue() == notification.getNewValue()) {
	// no change
	return;
	}

	final EObject element = (EObject) notification.getNotifier();
	final Object newValue = notification.getNewValue();
	final Set set = set(element, notification.getOldValue(), feature, newValue);
	append(set);

	if (feature instanceof EReference) {
	final EObject oldValue = (EObject) notification.getOldValue();
	final EObject deleted = getDeleted(oldValue);
	if (deleted != null) {
	deleteCache.get(deleted).add(set);
	}
	}
	}

	/**
	* Replace a primitive change by another one in the changes
	*/
	protected void replace(PrimitiveChange toReplace, PrimitiveChange replaceBy) {
	final List<PrimitiveChange> changes = changeContainer.getChanges();
	final int index = changes.indexOf(toReplace);
	changes.set(index, replaceBy);
	}

	/**
	* Get parent element which was deleted
	*/
	private EObject getDeleted(EObject element) {
	while (element != null) {
	if (deleteCache.containsKey(element)) {
	return element;
	}
	element = element.eContainer();
	}
	return null;
	}

	/** Returns elements. */
	public List<? extends EObject> getElements() {
	return elements;
	}
	}