/*******************************************************************************
 * 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.spi.migration.impl;

import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.NotificationChain;
import org.eclipse.emf.common.util.BasicDiagnostic;
import org.eclipse.emf.common.util.BasicEList;
import org.eclipse.emf.common.util.DiagnosticChain;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EAttribute;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EClassifier;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.InternalEObject;
import org.eclipse.emf.ecore.impl.EClassImpl;
import org.eclipse.emf.ecore.impl.ENotificationImpl;
import org.eclipse.emf.ecore.impl.EObjectImpl;
import org.eclipse.emf.ecore.util.Diagnostician;
import org.eclipse.emf.ecore.util.EContentsEList;
import org.eclipse.emf.ecore.util.EObjectContainmentWithInverseEList;
import org.eclipse.emf.ecore.util.EObjectWithInverseResolvingEList;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.ecore.util.InternalEList;
import org.eclipse.emf.edapt.internal.migration.impl.ModelValidator;
import org.eclipse.emf.edapt.internal.migration.impl.UpdatingList;
import org.eclipse.emf.edapt.migration.MigrationException;
import org.eclipse.emf.edapt.spi.migration.AttributeSlot;
import org.eclipse.emf.edapt.spi.migration.Instance;
import org.eclipse.emf.edapt.spi.migration.Metamodel;
import org.eclipse.emf.edapt.spi.migration.MigrationFactory;
import org.eclipse.emf.edapt.spi.migration.MigrationPackage;
import org.eclipse.emf.edapt.spi.migration.Model;
import org.eclipse.emf.edapt.spi.migration.ModelResource;
import org.eclipse.emf.edapt.spi.migration.ReferenceSlot;
import org.eclipse.emf.edapt.spi.migration.Slot;
import org.eclipse.emf.edapt.spi.migration.Type;
import org.eclipse.ocl.OCL;
import org.eclipse.ocl.ParserException;
import org.eclipse.ocl.Query;
import org.eclipse.ocl.ecore.Constraint;
import org.eclipse.ocl.ecore.EcoreEnvironmentFactory;
import org.eclipse.ocl.expressions.OCLExpression;
import org.eclipse.ocl.helper.OCLHelper;

/**
 * <!-- begin-user-doc --> An implementation of the model object ' <em><b>Instance</b></em>'. <!-- end-user-doc -->
 * <p>
 * The following features are implemented:
 * <ul>
 * <li>{@link org.eclipse.emf.edapt.spi.migration.impl.InstanceImpl#getSlots <em>Slots</em>}</li>
 * <li>{@link org.eclipse.emf.edapt.spi.migration.impl.InstanceImpl#getType <em>Type</em>}</li>
 * <li>{@link org.eclipse.emf.edapt.spi.migration.impl.InstanceImpl#getReferences <em>References</em>}</li>
 * <li>{@link org.eclipse.emf.edapt.spi.migration.impl.InstanceImpl#getUri <em>Uri</em>}</li>
 * <li>{@link org.eclipse.emf.edapt.spi.migration.impl.InstanceImpl#getUuid <em>Uuid</em>}</li>
 * </ul>
 * </p>
 *
 * @generated
 */
public class InstanceImpl extends EObjectImpl implements Instance {
	/**
	 * The cached value of the '{@link #getSlots() <em>Slots</em>}' containment reference list.
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @see #getSlots()
	 * @generated
	 * @ordered
	 */
	protected EList<Slot> slots;

	/**
	 * The cached value of the '{@link #getReferences() <em>References</em>}' reference list.
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @see #getReferences()
	 * @generated
	 * @ordered
	 */
	protected EList<ReferenceSlot> references;

	/**
	 * The default value of the '{@link #getUri() <em>Uri</em>}' attribute. <!--
	 * begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @see #getUri()
	 * @generated
	 * @ordered
	 */
	protected static final URI URI_EDEFAULT = null;

	/**
	 * The cached value of the '{@link #getUri() <em>Uri</em>}' attribute. <!--
	 * begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @see #getUri()
	 * @generated
	 * @ordered
	 */
	protected URI uri = URI_EDEFAULT;

	/**
	 * The default value of the '{@link #getUuid() <em>Uuid</em>}' attribute.
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @see #getUuid()
	 * @generated
	 * @ordered
	 */
	protected static final String UUID_EDEFAULT = null;

	/**
	 * The cached value of the '{@link #getUuid() <em>Uuid</em>}' attribute.
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @see #getUuid()
	 * @generated
	 * @ordered
	 */
	protected String uuid = UUID_EDEFAULT;

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated
	 */
	protected InstanceImpl() {
		super();
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated
	 */
	@Override
	protected EClass eStaticClass() {
		return MigrationPackage.Literals.INSTANCE;
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated
	 */
	@Override
	public EList<Slot> getSlots() {
		if (slots == null) {
			slots = new EObjectContainmentWithInverseEList<Slot>(Slot.class, this, MigrationPackage.INSTANCE__SLOTS,
				MigrationPackage.SLOT__INSTANCE);
		}
		return slots;
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated
	 */
	@Override
	public Type getType() {
		if (eContainerFeatureID() != MigrationPackage.INSTANCE__TYPE) {
			return null;
		}
		return (Type) eContainer();
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated
	 */
	public NotificationChain basicSetType(Type newType, NotificationChain msgs) {
		msgs = eBasicSetContainer((InternalEObject) newType, MigrationPackage.INSTANCE__TYPE, msgs);
		return msgs;
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated
	 */
	@Override
	public void setType(Type newType) {
		if (newType != eInternalContainer()
			|| eContainerFeatureID() != MigrationPackage.INSTANCE__TYPE && newType != null) {
			if (EcoreUtil.isAncestor(this, (EObject) newType)) {
				throw new IllegalArgumentException("Recursive containment not allowed for " + toString()); //$NON-NLS-1$
			}
			NotificationChain msgs = null;
			if (eInternalContainer() != null) {
				msgs = eBasicRemoveFromContainer(msgs);
			}
			if (newType != null) {
				msgs = ((InternalEObject) newType)
					.eInverseAdd(this, MigrationPackage.TYPE__INSTANCES, Type.class, msgs);
			}
			msgs = basicSetType(newType, msgs);
			if (msgs != null) {
				msgs.dispatch();
			}
		} else if (eNotificationRequired()) {
			eNotify(new ENotificationImpl(this, Notification.SET, MigrationPackage.INSTANCE__TYPE, newType, newType));
		}
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated
	 */
	@Override
	public EList<ReferenceSlot> getReferences() {
		if (references == null) {
			references = new EObjectWithInverseResolvingEList.ManyInverse<ReferenceSlot>(ReferenceSlot.class, this,
				MigrationPackage.INSTANCE__REFERENCES, MigrationPackage.REFERENCE_SLOT__VALUES);
		}
		return references;
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated
	 */
	@Override
	public URI getUri() {
		return uri;
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated
	 */
	@Override
	public void setUri(URI newUri) {
		final URI oldUri = uri;
		uri = newUri;
		if (eNotificationRequired()) {
			eNotify(new ENotificationImpl(this, Notification.SET, MigrationPackage.INSTANCE__URI, oldUri, uri));
		}
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated
	 */
	@Override
	public String getUuid() {
		return uuid;
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated
	 */
	@Override
	public void setUuid(String newUuid) {
		final String oldUuid = uuid;
		uuid = newUuid;
		if (eNotificationRequired()) {
			eNotify(new ENotificationImpl(this, Notification.SET, MigrationPackage.INSTANCE__UUID, oldUuid, uuid));
		}
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@Override
	public <V> V get(EStructuralFeature feature) {
		if (feature instanceof EAttribute) {
			return this.getAttributeValue((EAttribute) feature);
		} else if (feature instanceof EReference) {
			return this.getReferenceValue((EReference) feature);
		}
		return null;
	}

	/**
	 * Get the value of an instance's attribute
	 *
	 * @param <V>
	 * @param attribute
	 * @return Value
	 */
	@SuppressWarnings("unchecked")
	private <V> V getAttributeValue(EAttribute attribute) {
		final Slot slot = getSlot(attribute);
		if (slot == null) {
			if (attribute.isMany()) {
				return (V) new UpdatingList(this, attribute);
			} else if (attribute.getDefaultValue() != null) {
				return (V) attribute.getDefaultValue();
			}
			return null;
		}
		final EList<Object> values = new UpdatingList(this, attribute,
			((AttributeSlot) slot).getValues());
		if (attribute.isMany()) {
			return (V) values;
		} else if (!values.isEmpty()) {
			return (V) values.get(0);
		}
		return null;
	}

	/**
	 * Get the value of an instance's reference
	 *
	 * @param <V>
	 * @param reference
	 * @return Value
	 */
	@SuppressWarnings("unchecked")
	<V> V getReferenceValue(EReference reference) {
		final Slot slot = getSlot(reference);
		if (slot == null) {
			if (reference.isMany()) {
				return (V) new UpdatingList(this, reference);
			} else if (reference.getDefaultValue() != null) {
				return (V) reference.getDefaultValue();
			}
			return null;
		}
		final EList<Instance> values = new UpdatingList(this, reference,
			((ReferenceSlot) slot).getValues());
		if (reference.isMany()) {
			return (V) values;
		} else if (!values.isEmpty()) {
			return (V) values.get(0);
		}
		return null;
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@Override
	public void set(EStructuralFeature feature, Object newValue) {
		if (feature.isMany()) {
			final Collection<?> oldValues = (Collection<?>) this.get(feature);
			for (final Object value : oldValues) {
				this.remove(feature, value);
			}
			final Collection<?> newValues = (Collection<?>) newValue;
			for (final Object value : newValues) {
				this.add(feature, value);
			}
		} else {
			if (newValue instanceof List<?>) {
				throw new IllegalArgumentException("Single value expected, but list found"); //$NON-NLS-1$
			}
			final Object oldValue = this.get(feature);
			if (oldValue != newValue || feature.isUnsettable()) {
				if (isSet(feature) && oldValue != null) {
					this.remove(feature, oldValue);
				}
				if (newValue != null || feature.isUnsettable()) {
					this.add(feature, newValue);
				}
			}
		}

	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@Override
	public Slot getSlot(EStructuralFeature feature) {
		for (final Slot slot : getSlots()) {
			if (feature == slot.getEFeature()) {
				return slot;
			}
		}
		return null;
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@Override
	@SuppressWarnings("unchecked")
	public <V> V evaluate(String expression) throws MigrationException {
		final Model model = getType().getModel();
		enableReflection();

		OCL<?, EClassifier, ?, ?, ?, ?, ?, ?, ?, Constraint, EClass, EObject> ocl;
		ocl = OCL.newInstance(EcoreEnvironmentFactory.INSTANCE);
		final OCLHelper<EClassifier, ?, ?, Constraint> helper = ocl.createOCLHelper();

		helper.setContext(eClass());
		OCLExpression<EClassifier> query;
		try {
			query = helper.createQuery(expression);
		} catch (final ParserException e) {
			throw new MigrationException("OCL expression '" + expression //$NON-NLS-1$
				+ "' could not be parsed", e); //$NON-NLS-1$
		}
		ocl.setExtentMap((Map) model.createExtentMap());

		// create a Query to evaluate our query expression
		final Query<EClassifier, EClass, EObject> queryEval = ocl.createQuery(query);
		final Object result = queryEval.evaluate(this);

		disableReflection();
		return (V) result;
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@Override
	public EReference getContainerReference() {
		for (final ReferenceSlot slot : getReferences()) {
			if (slot.getEReference().isContainment()) {
				return slot.getEReference();
			}
		}
		return null;
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@Override
	public ModelResource getResource() {
		final Model model = getType().getModel();
		Instance instance = this;
		while (instance.getContainer() != null) {
			for (final ModelResource resource : model.getResources()) {
				if (resource.getRootInstances().contains(instance)) {
					return resource;
				}
			}
			instance = instance.getContainer();
		}
		for (final ModelResource resource : model.getResources()) {
			if (resource.getRootInstances().contains(instance)) {
				return resource;
			}
		}
		return null;
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@Override
	public boolean isProxy() {
		return getUri() != null;
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@Override
	public void migrate(String className) {
		final EClass eClass = checkAndGetClass(className);
		migrate(eClass);
	}

	private EClass checkAndGetClass(String className) {
		final Metamodel metamodel = getType().getModel().getMetamodel();
		final EClass eClass = metamodel.getEClass(className);
		if (eClass == null) {
			throw new IllegalArgumentException("Class " + className + " not found."); //$NON-NLS-1$ //$NON-NLS-2$
		}
		return eClass;
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@Override
	public EList<Instance> getInverse(String referenceName) {
		final EReference reference = checkAndGetReference(referenceName);
		return getInverse(reference);
	}

	private EReference checkAndGetReference(String referenceName) {
		final EReference reference = getType().getModel().getMetamodel()
			.getEReference(referenceName);
		if (reference == null) {
			throw new IllegalArgumentException("Reference " + referenceName + " not found."); //$NON-NLS-1$ //$NON-NLS-2$
		}
		return reference;
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@Override
	public Instance getLink(String referenceName) {
		return (Instance) get(referenceName);
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@SuppressWarnings("unchecked")
	@Override
	public EList<Instance> getLinks(String referenceName) {
		return (EList<Instance>) get(referenceName);
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@Override
	public boolean instanceOf(String className) {
		final EClass eClass = checkAndGetClass(className);
		return instanceOf(eClass);
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@Override
	public void add(String featureName, Object value) {
		final EStructuralFeature feature = checkAndGetFeature(featureName);
		add(feature, value);
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@Override
	public void remove(String featureName, Object value) {
		final EStructuralFeature feature = checkAndGetFeature(featureName);
		remove(feature, value);
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@Override
	public void add(String featureName, int index, Object value) {
		final EStructuralFeature feature = checkAndGetFeature(featureName);
		add(feature, index, value);
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@Override
	public Instance getLink(EReference reference) {
		return (Instance) get(reference);
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@SuppressWarnings("unchecked")
	@Override
	public EList<Instance> getLinks(EReference reference) {
		return (EList<Instance>) get(reference);
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@Override
	public Instance copy() {

		// mapping of originals to copies
		final Map<Instance, Instance> map = new HashMap<Instance, Instance>();

		// copy tree structure
		final Instance copy = copyTree(this, map);
		// copy cross references
		copyReferences(this, map);

		return copy;
	}

	/** Copy the tree structure with an instance as root. */
	private Instance copyTree(Instance original, Map<Instance, Instance> map) {
		final EClass eClass = original.getEClass();
		final Instance copi = getType().getModel().newInstance(eClass);
		for (final EReference reference : eClass.getEAllReferences()) {
			if (reference.isContainment()) {
				if (reference.isMany()) {
					for (final Instance child : original.getLinks(reference)) {
						copi.add(reference, copyTree(child, map));
					}
				} else {
					final Instance child = original.get(reference);
					if (child != null) {
						copi.set(reference, copyTree(child, map));
					}
				}
			}
		}
		for (final EAttribute attribute : eClass.getEAllAttributes()) {
			copi.set(attribute, original.get(attribute));
		}
		map.put(original, copi);
		return copi;
	}

	/** Copy cross references of an instance. */
	private void copyReferences(Instance original, Map<Instance, Instance> map) {
		final EClass eClass = original.getEClass();
		final Instance copi = map.get(original);
		for (final EReference reference : eClass.getEAllReferences()) {
			if (!reference.isContainment()) {
				if (reference.isMany()) {
					if (reference.getEOpposite() == null
						|| reference.getEOpposite().isMany()) {
						for (Instance ref : original.getLinks(reference)) {
							if (map.get(ref) != null) {
								ref = map.get(ref);
							}
							copi.add(reference, ref);
						}
					}
				} else {
					if (reference.getEOpposite() == null
						|| !reference.getEOpposite().isContainment()) {
						Instance ref = original.get(reference);
						if (ref != null) {
							if (map.get(ref) != null) {
								ref = map.get(ref);
							}
							copi.set(reference, ref);
						}
					}
				}
			}
		}
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@Override
	public EList<Instance> getInverse(EReference reference) {
		final List<ReferenceSlot> slots = getReferences();
		final EList<Instance> instances = new BasicEList<Instance>();
		for (final ReferenceSlot slot : slots) {
			if (reference == slot.getEReference()) {
				instances.add(slot.getInstance());
			}
		}
		return instances;
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@Override
	public void migrate(EClass eClass) {
		final Type oldType = getType();
		if (eClass != oldType.getEClass()) {
			final ModelImpl model = (ModelImpl) oldType.getModel();
			model.removeDeleteType(oldType, this);
			final Type type = model.getCreateType(eClass);
			type.getInstances().add(this);
		}
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@Override
	public <V> V unset(EStructuralFeature feature) {
		final V value = this.get(feature);
		if (isSet(feature)) {
			if (feature.isMany()) {
				this.set(feature, Collections.EMPTY_LIST);
			} else {
				this.set(feature, null);
			}
		}
		return value;
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@Override
	public void add(EStructuralFeature feature, int index, Object value) {
		if (feature instanceof EAttribute) {
			final EAttribute attribute = (EAttribute) feature;
			final AttributeSlot attributeSlot = getCreateAttributeSlot(attribute);
			if (!attribute.isUnique()
				|| !attributeSlot.getValues().contains(value)) {
				attributeSlot.getValues().add(index, value);
			}
		} else {
			final EReference reference = (EReference) feature;
			final Instance target = (Instance) value;
			if (reference.isUnique() && contains(reference, target)) {
				return;
			}
			final EReference opposite = reference.getEOpposite();
			if (opposite != null && reference.eContainer() != null) {
				// if opposite is single-valued, unset it before
				if (!opposite.isMany()) {
					target.unset(opposite);
				}
				final ReferenceSlot oppositeSlot = ((InstanceImpl) target)
					.getCreateReferenceSlot(opposite);
				oppositeSlot.getValues().add(this);
			}
			final ReferenceSlot referenceSlot = getCreateReferenceSlot(reference);
			referenceSlot.getValues().add(index, target);
		}
	}

	/**
	 * Get the slot for an instance's attribute (create one if there is none)
	 *
	 * @param attribute
	 * @return Slot
	 */
	private AttributeSlot getCreateAttributeSlot(EAttribute attribute) {

		AttributeSlot attributeSlot = (AttributeSlot) getSlot(attribute);
		if (attributeSlot == null) {
			attributeSlot = MigrationFactory.eINSTANCE.createAttributeSlot();
			attributeSlot.setEAttribute(attribute);
			getSlots().add(attributeSlot);
		}
		return attributeSlot;
	}

	/**
	 * Get the slot for an instance's reference (create one if there is none)
	 *
	 * @param reference
	 * @return Slot
	 */
	ReferenceSlot getCreateReferenceSlot(EReference reference) {

		ReferenceSlot referenceSlot = (ReferenceSlot) getSlot(reference);
		if (referenceSlot == null) {
			referenceSlot = MigrationFactory.eINSTANCE.createReferenceSlot();
			referenceSlot.setEReference(reference);
			getSlots().add(referenceSlot);
		}
		return referenceSlot;
	}

	/**
	 * Determine whether a value is contained in an instance's reference
	 *
	 * @param reference
	 * @param value
	 * @return true if it is contained, false otherwise
	 */
	private boolean contains(EReference reference, Instance value) {
		final ReferenceSlot referenceSlot = (ReferenceSlot) getSlot(reference);
		if (referenceSlot != null) {
			return referenceSlot.getValues().contains(value);
		}
		return false;
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@Override
	public void remove(EStructuralFeature feature, Object value) {
		final SlotImpl slot = (SlotImpl) getSlot(feature);
		final int index = slot != null ? slot.getValues().indexOf(value) : 0;
		if (index >= 0) {
			this.remove(feature, index);
		}
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@Override
	public EClass getEClass() {
		return ((Instance) this).getType().getEClass();
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@Override
	public void validate() {
		final BasicDiagnostic chain = new BasicDiagnostic();
		this.validate(chain);
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@Override
	public boolean validate(DiagnosticChain chain) {
		final ModelValidator validator = new ModelValidator(getType()
			.getModel());
		final Diagnostician diagnostician = new Diagnostician() {
			@Override
			public String getObjectLabel(EObject eObject) {
				final EClass eClass = eObject.eClass();
				final StringBuffer result = new StringBuffer(eClass.getName());
				if (eClass.getInstanceClassName() == null) {
					result.append('/');
					result.append(eClass.getEPackage().getNsURI());
					result.append('#');
					result.append(eClass.getName());
				}
				result.append('@');
				result.append(Integer.toHexString(eObject.hashCode()));

				return result.toString();
			}

			@Override
			public boolean validate(EClass eClass, EObject eObject,
				DiagnosticChain diagnostics, Map<Object, Object> context) {
				boolean result = validator.validate(eClass, eObject,
					diagnostics, context);
				if (result || diagnostics != null) {
					result &= doValidateContents(eObject, diagnostics, context);
				}
				return result;
			}

			@Override
			protected boolean doValidateContents(EObject eObject, DiagnosticChain diagnostics,
				Map<Object, Object> context) {
				return super.doValidateContents(eObject, diagnostics, context);
			}
		};
		enableReflection();
		final boolean result = diagnostician.validate(this, chain);
		disableReflection();
		return result;
	}

	/**
	 * Disable reflection
	 */
	private void disableReflection() {
		getType().getModel().setReflection(false);
	}

	/**
	 * Enable reflection
	 */
	private void enableReflection() {
		getType().getModel().setReflection(true);
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@Override
	public <V> V get(String featureName) {
		final EStructuralFeature feature = checkAndGetFeature(featureName);
		return this.get(feature);
	}

	private EStructuralFeature checkAndGetFeature(String featureName) {
		final EStructuralFeature feature = getEClass().getEStructuralFeature(
			featureName);
		if (feature == null) {
			throw new IllegalArgumentException("Feature " + featureName + " not found."); //$NON-NLS-1$ //$NON-NLS-2$
		}
		return feature;
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@Override
	public void set(String featureName, Object value) {
		final EStructuralFeature feature = checkAndGetFeature(featureName);
		this.set(feature, value);
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@Override
	public boolean isSet(EStructuralFeature feature) {
		return getSlot(feature) != null;
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@Override
	public boolean instanceOf(EClass eClass) {
		return getEClass() == eClass
			|| getEClass().getEAllSuperTypes().contains(eClass);
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@Override
	public Instance getContainer() {
		for (final ReferenceSlot slot : getReferences()) {
			if (slot.getEReference().isContainment()) {
				return slot.getInstance();
			}
		}
		return null;
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@Override
	public EList<Instance> getContents() {
		final EList<Instance> contents = new BasicEList<Instance>();
		for (final Slot slot : getSlots()) {
			if (slot instanceof ReferenceSlot) {
				final ReferenceSlot referenceSlot = (ReferenceSlot) slot;
				if (referenceSlot.getEReference().isContainment()) {
					contents.addAll(referenceSlot.getValues());
				}
			}
		}
		return contents;
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@Override
	public void add(EStructuralFeature feature, Object value) {
		final SlotImpl slot = (SlotImpl) getSlot(feature);
		final int index = slot != null ? slot.getValues().size() : 0;
		this.add(feature, index, value);
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@Override
	public void remove(EStructuralFeature feature, int index) {
		if (feature instanceof EAttribute) {
			final EAttribute attribute = (EAttribute) feature;
			removeDeleteAttribute(attribute, index);
		} else {
			final EReference reference = (EReference) feature;
			final EReference opposite = reference.getEOpposite();
			if (opposite != null && reference.eContainer() != null) {
				final ReferenceSlot referenceSlot = (ReferenceSlot) getSlot(reference);
				final Instance target = referenceSlot.getValues().get(index);
				final int oppositeIndex = ((ReferenceSlot) target.getSlot(opposite))
					.getValues().indexOf(this);
				((InstanceImpl) target).removeDeleteReference(opposite,
					oppositeIndex);
			}
			removeDeleteReference(reference, index);
		}
	}

	/**
	 * Remove a value from an instance's attribute (delete slot if it is empty)
	 *
	 * @param attribute
	 * @param index
	 */
	private void removeDeleteAttribute(EAttribute attribute, int index) {
		final AttributeSlot attributeSlot = (AttributeSlot) getSlot(attribute);
		attributeSlot.getValues().remove(index);
		if (attributeSlot.getValues().isEmpty()) {
			getSlots().remove(attributeSlot);
		}
	}

	/**
	 * Remove a value from an instance's reference (delete slot if it is empty)
	 *
	 * @param reference
	 * @param index
	 */
	void removeDeleteReference(EReference reference, int index) {

		final ReferenceSlot referenceSlot = (ReferenceSlot) getSlot(reference);
		referenceSlot.getValues().remove(index);
		if (referenceSlot.getValues().isEmpty()) {
			getSlots().remove(referenceSlot);
		}
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated
	 */
	@SuppressWarnings("unchecked")
	@Override
	public NotificationChain eInverseAdd(InternalEObject otherEnd,
		int featureID, NotificationChain msgs) {
		switch (featureID) {
		case MigrationPackage.INSTANCE__SLOTS:
			return ((InternalEList<InternalEObject>) (InternalEList<?>) getSlots()).basicAdd(otherEnd, msgs);
		case MigrationPackage.INSTANCE__TYPE:
			if (eInternalContainer() != null) {
				msgs = eBasicRemoveFromContainer(msgs);
			}
			return basicSetType((Type) otherEnd, msgs);
		case MigrationPackage.INSTANCE__REFERENCES:
			return ((InternalEList<InternalEObject>) (InternalEList<?>) getReferences()).basicAdd(otherEnd, msgs);
		}
		return super.eInverseAdd(otherEnd, featureID, msgs);
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated
	 */
	@Override
	public NotificationChain eInverseRemove(InternalEObject otherEnd,
		int featureID, NotificationChain msgs) {
		switch (featureID) {
		case MigrationPackage.INSTANCE__SLOTS:
			return ((InternalEList<?>) getSlots()).basicRemove(otherEnd, msgs);
		case MigrationPackage.INSTANCE__TYPE:
			return basicSetType(null, msgs);
		case MigrationPackage.INSTANCE__REFERENCES:
			return ((InternalEList<?>) getReferences()).basicRemove(otherEnd, msgs);
		}
		return super.eInverseRemove(otherEnd, featureID, msgs);
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated
	 */
	@Override
	public NotificationChain eBasicRemoveFromContainerFeature(
		NotificationChain msgs) {
		switch (eContainerFeatureID()) {
		case MigrationPackage.INSTANCE__TYPE:
			return eInternalContainer().eInverseRemove(this, MigrationPackage.TYPE__INSTANCES, Type.class, msgs);
		}
		return super.eBasicRemoveFromContainerFeature(msgs);
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated
	 */
	@Override
	public Object eGet(int featureID, boolean resolve, boolean coreType) {
		switch (featureID) {
		case MigrationPackage.INSTANCE__SLOTS:
			return getSlots();
		case MigrationPackage.INSTANCE__TYPE:
			return getType();
		case MigrationPackage.INSTANCE__REFERENCES:
			return getReferences();
		case MigrationPackage.INSTANCE__URI:
			return getUri();
		case MigrationPackage.INSTANCE__UUID:
			return getUuid();
		}
		return super.eGet(featureID, resolve, coreType);
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated
	 */
	@SuppressWarnings("unchecked")
	@Override
	public void eSet(int featureID, Object newValue) {
		switch (featureID) {
		case MigrationPackage.INSTANCE__SLOTS:
			getSlots().clear();
			getSlots().addAll((Collection<? extends Slot>) newValue);
			return;
		case MigrationPackage.INSTANCE__TYPE:
			setType((Type) newValue);
			return;
		case MigrationPackage.INSTANCE__REFERENCES:
			getReferences().clear();
			getReferences().addAll((Collection<? extends ReferenceSlot>) newValue);
			return;
		case MigrationPackage.INSTANCE__URI:
			setUri((URI) newValue);
			return;
		case MigrationPackage.INSTANCE__UUID:
			setUuid((String) newValue);
			return;
		}
		super.eSet(featureID, newValue);
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated
	 */
	@Override
	public void eUnset(int featureID) {
		switch (featureID) {
		case MigrationPackage.INSTANCE__SLOTS:
			getSlots().clear();
			return;
		case MigrationPackage.INSTANCE__TYPE:
			setType((Type) null);
			return;
		case MigrationPackage.INSTANCE__REFERENCES:
			getReferences().clear();
			return;
		case MigrationPackage.INSTANCE__URI:
			setUri(URI_EDEFAULT);
			return;
		case MigrationPackage.INSTANCE__UUID:
			setUuid(UUID_EDEFAULT);
			return;
		}
		super.eUnset(featureID);
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated
	 */
	@Override
	public boolean eIsSet(int featureID) {
		switch (featureID) {
		case MigrationPackage.INSTANCE__SLOTS:
			return slots != null && !slots.isEmpty();
		case MigrationPackage.INSTANCE__TYPE:
			return getType() != null;
		case MigrationPackage.INSTANCE__REFERENCES:
			return references != null && !references.isEmpty();
		case MigrationPackage.INSTANCE__URI:
			return URI_EDEFAULT == null ? uri != null : !URI_EDEFAULT.equals(uri);
		case MigrationPackage.INSTANCE__UUID:
			return UUID_EDEFAULT == null ? uuid != null : !UUID_EDEFAULT.equals(uuid);
		}
		return super.eIsSet(featureID);
	}

	/**
	 * <!-- begin-user-doc --> <!-- end-user-doc -->
	 *
	 * @generated NOT
	 */
	@Override
	public String toString() {
		if (eIsProxy()) {
			return super.toString();
		}

		final StringBuffer result = new StringBuffer();
		result.append("Instance of "); //$NON-NLS-1$
		result.append(getType().getEClass().getName());
		if (getUri() != null) {
			result.append(" (proxy: " + getUri() + ")"); //$NON-NLS-1$ //$NON-NLS-2$
		} else if (getUuid() != null) {
			result.append(" (uuid: " + getUuid() + ")"); //$NON-NLS-1$ //$NON-NLS-2$
		}
		return result.toString();
	}

	// overwritten

	/**
	 * {@inheritDoc}
	 */
	@Override
	public EClass eClass() {
		if (getType().getModel().isReflection()) {
			return getEClass();
		}
		return super.eClass();
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	public Object eGet(EStructuralFeature feature, boolean resolve,
		boolean coreType) {
		if (getType().getModel().isReflection()) {
			return get(feature);
		}
		return super.eGet(feature, resolve, coreType);
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	public boolean eIsSet(EStructuralFeature feature) {
		if (getType().getModel().isReflection()) {
			return getSlot(feature) != null;
		}
		return super.eIsSet(feature);
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	public EList<EObject> eContents() {
		if (getType().getModel().isReflection()) {
			final EStructuralFeature[] features = ((EClassImpl.FeatureSubsetSupplier) getEClass()
				.getEAllStructuralFeatures()).containments();
			return new EContentsEList<EObject>(this, features);
		}
		return super.eContents();
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	public EList<EObject> eCrossReferences() {
		if (getType().getModel().isReflection()) {
			final EStructuralFeature[] features = ((EClassImpl.FeatureSubsetSupplier) getEClass()
				.getEAllStructuralFeatures()).crossReferences();
			return new EContentsEList<EObject>(this, features);
		}
		return super.eCrossReferences();
	}
} // InstanceImpl