/**
* Copyright (c) 2006-2013 IBM Corporation 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:
* IBM - Initial API and implementation
*/
package org.eclipse.emf.ecore.impl;
import java.lang.reflect.InvocationTargetException;
import java.util.Collection;
import java.util.Set;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.NotificationChain;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EAttribute;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EClassifier;
import org.eclipse.emf.ecore.EDataType;
import org.eclipse.emf.ecore.EGenericType;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EOperation;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.ETypeParameter;
import org.eclipse.emf.ecore.EcorePackage;
import org.eclipse.emf.ecore.InternalEObject;
import org.eclipse.emf.ecore.util.EObjectContainmentEList;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.ecore.util.InternalEList;
/**
* <!-- begin-user-doc -->
* An implementation of the model object '<em><b>EGeneric Type</b></em>'.
* <!-- end-user-doc -->
* <p>
* The following features are implemented:
* <ul>
* <li>{@link org.eclipse.emf.ecore.impl.EGenericTypeImpl#getEUpperBound <em>EUpper Bound</em>}</li>
* <li>{@link org.eclipse.emf.ecore.impl.EGenericTypeImpl#getETypeArguments <em>EType Arguments</em>}</li>
* <li>{@link org.eclipse.emf.ecore.impl.EGenericTypeImpl#getERawType <em>ERaw Type</em>}</li>
* <li>{@link org.eclipse.emf.ecore.impl.EGenericTypeImpl#getELowerBound <em>ELower Bound</em>}</li>
* <li>{@link org.eclipse.emf.ecore.impl.EGenericTypeImpl#getETypeParameter <em>EType Parameter</em>}</li>
* <li>{@link org.eclipse.emf.ecore.impl.EGenericTypeImpl#getEClassifier <em>EClassifier</em>}</li>
* </ul>
* </p>
*
* @generated not
*/
public class EGenericTypeImpl extends MinimalEObjectImpl.Container implements EGenericType
{
/**
* The cached value of the '{@link #getEUpperBound() <em>EUpper Bound</em>}' containment reference.
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @see #getEUpperBound()
* @generated
* @ordered
*/
protected EGenericType eUpperBound;
/**
* The cached value of the '{@link #getETypeArguments() <em>EType Arguments</em>}' containment reference list.
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @see #getETypeArguments()
* @generated
* @ordered
*/
protected EList<EGenericType> eTypeArguments;
/**
* The cached default value for the {@link #eRawType eRawType} field.
* It needs to be set to {@link org.eclipse.emf.ecore.EcorePackage.Literals#EJAVA_OBJECT}
* but due to bootstrap delays initializing that field,
* it needs to be set after the Ecore package has been initialized.
* @see org.eclipse.emf.ecore.impl.EcorePackageImpl#internalBootstrap()
* @see #eRawType
*/
static EDataType eJavaObject;
/**
* The cached value of the '{@link #getERawType() <em>ERaw Type</em>}' reference.
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @see #getERawType()
* @generated NOT
* @ordered
*/
protected EClassifier eRawType = eJavaObject;
/**
* The cached value of the '{@link #getELowerBound() <em>ELower Bound</em>}' containment reference.
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @see #getELowerBound()
* @generated
* @ordered
*/
protected EGenericType eLowerBound;
/**
* The cached value of the '{@link #getETypeParameter() <em>EType Parameter</em>}' reference.
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @see #getETypeParameter()
* @generated
* @ordered
*/
protected ETypeParameter eTypeParameter;
/**
* The cached value of the '{@link #getEClassifier() <em>EClassifier</em>}' reference.
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @see #getEClassifier()
* @generated
* @ordered
*/
protected EClassifier eClassifier;
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
protected EGenericTypeImpl()
{
super();
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
@Override
protected EClass eStaticClass()
{
return EcorePackage.Literals.EGENERIC_TYPE;
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
public EGenericType getEUpperBound()
{
return eUpperBound;
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
public NotificationChain basicSetEUpperBound(EGenericType newEUpperBound, NotificationChain msgs)
{
EGenericType oldEUpperBound = eUpperBound;
eUpperBound = newEUpperBound;
if (eNotificationRequired())
{
ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, EcorePackage.EGENERIC_TYPE__EUPPER_BOUND, oldEUpperBound, newEUpperBound);
if (msgs == null) msgs = notification; else msgs.add(notification);
}
return msgs;
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
public void setEUpperBound(EGenericType newEUpperBound)
{
if (newEUpperBound != eUpperBound)
{
NotificationChain msgs = null;
if (eUpperBound != null)
msgs = ((InternalEObject)eUpperBound).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - EcorePackage.EGENERIC_TYPE__EUPPER_BOUND, null, msgs);
if (newEUpperBound != null)
msgs = ((InternalEObject)newEUpperBound).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - EcorePackage.EGENERIC_TYPE__EUPPER_BOUND, null, msgs);
msgs = basicSetEUpperBound(newEUpperBound, msgs);
if (msgs != null) msgs.dispatch();
}
else if (eNotificationRequired())
eNotify(new ENotificationImpl(this, Notification.SET, EcorePackage.EGENERIC_TYPE__EUPPER_BOUND, newEUpperBound, newEUpperBound));
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
public EList<EGenericType> getETypeArguments()
{
if (eTypeArguments == null)
{
eTypeArguments = new EObjectContainmentEList<EGenericType>(EGenericType.class, this, EcorePackage.EGENERIC_TYPE__ETYPE_ARGUMENTS);
}
return eTypeArguments;
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated NOT
*/
public EClassifier getERawType()
{
if (eRawType != null && eRawType.eIsProxy())
{
InternalEObject oldERawType = (InternalEObject)eRawType;
eRawType = (EClassifier)eResolveProxy(oldERawType);
if (eRawType != oldERawType)
{
if (eNotificationRequired())
eNotify(new ENotificationImpl(this, Notification.RESOLVE, EcorePackage.EGENERIC_TYPE__ERAW_TYPE, oldERawType, eRawType));
if (eContainer instanceof EOperation)
{
if (eContainerFeatureID() == (EOPPOSITE_FEATURE_BASE - EcorePackage.EOPERATION__EGENERIC_EXCEPTIONS) && eContainer.eNotificationRequired())
{
new ENotificationImpl
(eContainer,
Notification.RESOLVE,
EcorePackage.EOPERATION__EEXCEPTIONS,
oldERawType,
eRawType,
((EOperation)eContainer).getEGenericExceptions().indexOf(this)).dispatch();
}
}
else if (eContainer instanceof EClass)
{
if (eContainerFeatureID() == (EOPPOSITE_FEATURE_BASE - EcorePackage.ECLASS__EGENERIC_SUPER_TYPES) && eContainer.eNotificationRequired())
{
EClassifier newERawType = eRawType;
if (!(newERawType instanceof EClass))
{
newERawType = EcorePackage.Literals.EOBJECT;
}
if (!(oldERawType instanceof EClass))
{
oldERawType = (InternalEObject)EcorePackage.Literals.EOBJECT;
}
new ENotificationImpl
(eContainer,
Notification.RESOLVE,
EcorePackage.ECLASS__ESUPER_TYPES,
oldERawType,
newERawType,
((EClass)eContainer).getEGenericSuperTypes().indexOf(this)).dispatch();
}
}
}
}
return eRawType;
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
public EClassifier basicGetERawType()
{
return eRawType;
}
public NotificationChain setERawType(EClassifier newERawType, NotificationChain msgs)
{
EClassifier oldERawType = eRawType;
if (newERawType == null)
{
newERawType = eJavaObject;
}
eRawType = newERawType;
if (eNotificationRequired())
{
ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, EcorePackage.EGENERIC_TYPE__ERAW_TYPE, oldERawType, eRawType);
if (msgs == null)
{
msgs = notification;
}
else
{
msgs.add(notification);
}
}
if (oldERawType != newERawType)
{
if (eContainer instanceof ETypedElementImpl)
{
if (eContainerFeatureID() == (EOPPOSITE_FEATURE_BASE - EcorePackage.ETYPED_ELEMENT__EGENERIC_TYPE))
{
msgs = ((ETypedElementImpl)eContainer).setEType(newERawType, msgs);
}
else if (eContainerFeatureID() == (EOPPOSITE_FEATURE_BASE - EcorePackage.EOPERATION__EGENERIC_EXCEPTIONS))
{
if (newERawType == null)
{
newERawType = EcorePackage.Literals.EJAVA_OBJECT;
}
if (oldERawType == null)
{
oldERawType = EcorePackage.Literals.EJAVA_OBJECT;
}
if (eContainer.eNotificationRequired())
{
ENotificationImpl notification =
new ENotificationImpl
(eContainer,
Notification.SET,
EcorePackage.EOPERATION__EEXCEPTIONS,
oldERawType,
newERawType,
((EOperation)eContainer).getEGenericExceptions().indexOf(this),
false);
if (msgs == null)
{
msgs = notification;
}
else
{
msgs.add(notification);
}
}
}
}
else if (eContainer instanceof EClass)
{
if (eContainerFeatureID() == (EOPPOSITE_FEATURE_BASE - EcorePackage.ECLASS__EGENERIC_SUPER_TYPES))
{
if (!(newERawType instanceof EClass))
{
newERawType = EcorePackage.Literals.EOBJECT;
}
if (!(oldERawType instanceof EClass))
{
oldERawType = EcorePackage.Literals.EOBJECT;
}
if (eContainer.eNotificationRequired())
{
ENotificationImpl notification =
new ENotificationImpl
(eContainer,
Notification.SET,
EcorePackage.ECLASS__ESUPER_TYPES,
oldERawType,
newERawType,
((EClass)eContainer).getEGenericSuperTypes().indexOf(this),
false);
if (msgs == null)
{
msgs = notification;
}
else
{
msgs.add(notification);
}
}
}
}
else if (eContainer instanceof ETypeParameter)
{
ETypeParameter eTypeParameter = (ETypeParameter)eContainer;
synchronized (eTypeParameter)
{
@SuppressWarnings("unchecked")
Set<EGenericTypeImpl> eGenericTypes = (Set<EGenericTypeImpl>)(Set<?>)((ETypeParameterImpl)eTypeParameter).getEGenericTypes();
for (EGenericTypeImpl eGenericType : eGenericTypes)
{
msgs = eGenericType.setERawType(eGenericType.getErasure(eTypeParameter), msgs);
}
}
}
}
return msgs;
}
@Override
public NotificationChain eBasicSetContainer(InternalEObject newContainer, int newContainerFeatureID, NotificationChain msgs)
{
msgs = super.eBasicSetContainer(newContainer, newContainerFeatureID, msgs);
if (eTypeParameter != null && newContainer instanceof EStructuralFeature)
{
// When we attached we have to recompute the erasure of the type parameter.
//
EClassifier newERawType = getErasure(eTypeParameter);
if (newERawType != eRawType)
{
msgs = setERawType(newERawType, msgs);
}
}
return msgs;
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
public EGenericType getELowerBound()
{
return eLowerBound;
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
public NotificationChain basicSetELowerBound(EGenericType newELowerBound, NotificationChain msgs)
{
EGenericType oldELowerBound = eLowerBound;
eLowerBound = newELowerBound;
if (eNotificationRequired())
{
ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, EcorePackage.EGENERIC_TYPE__ELOWER_BOUND, oldELowerBound, newELowerBound);
if (msgs == null) msgs = notification; else msgs.add(notification);
}
return msgs;
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
public void setELowerBound(EGenericType newELowerBound)
{
if (newELowerBound != eLowerBound)
{
NotificationChain msgs = null;
if (eLowerBound != null)
msgs = ((InternalEObject)eLowerBound).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - EcorePackage.EGENERIC_TYPE__ELOWER_BOUND, null, msgs);
if (newELowerBound != null)
msgs = ((InternalEObject)newELowerBound).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - EcorePackage.EGENERIC_TYPE__ELOWER_BOUND, null, msgs);
msgs = basicSetELowerBound(newELowerBound, msgs);
if (msgs != null) msgs.dispatch();
}
else if (eNotificationRequired())
eNotify(new ENotificationImpl(this, Notification.SET, EcorePackage.EGENERIC_TYPE__ELOWER_BOUND, newELowerBound, newELowerBound));
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
public ETypeParameter getETypeParameter()
{
return eTypeParameter;
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated NOT
*/
public NotificationChain basicSetETypeParameter(ETypeParameter newETypeParameter, NotificationChain msgs)
{
ETypeParameter oldETypeParameter = eTypeParameter;
eTypeParameter = newETypeParameter;
if (eNotificationRequired())
{
ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, EcorePackage.EGENERIC_TYPE__ETYPE_PARAMETER, oldETypeParameter, newETypeParameter);
if (msgs == null) msgs = notification; else msgs.add(notification);
}
if (oldETypeParameter != newETypeParameter)
{
if (newETypeParameter != null)
{
msgs = setERawType(getErasure(newETypeParameter), msgs);
}
else
{
msgs = setERawType(eClassifier, msgs);
}
}
return msgs;
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated NOT
*/
public void setETypeParameter(ETypeParameter newETypeParameter)
{
if (newETypeParameter != eTypeParameter)
{
// Maintain a (weak hash) set on the type parameter of all referencing generic types.
//
if (eTypeParameter != null)
{
synchronized (eTypeParameter)
{
((ETypeParameterImpl)eTypeParameter).getEGenericTypes().remove(this);
}
}
if (newETypeParameter != null)
{
synchronized (newETypeParameter)
{
((ETypeParameterImpl)newETypeParameter).getEGenericTypes().add(this);
}
}
NotificationChain msgs = basicSetETypeParameter(newETypeParameter, null);
if (msgs != null)
{
msgs.dispatch();
}
}
else if (eNotificationRequired())
{
eNotify(new ENotificationImpl(this, Notification.SET, EcorePackage.EGENERIC_TYPE__ETYPE_PARAMETER, newETypeParameter, newETypeParameter));
}
}
protected EClassifier getErasure(ETypeParameter eTypeParameter)
{
if (eTypeParameter == null)
{
return null;
}
else
{
boolean needEClass = eContainer instanceof EClass || eContainer instanceof EReference;
boolean needEDataType = !needEClass && eContainer instanceof EAttribute;
for (EGenericType eBound : eTypeParameter.getEBounds())
{
EClassifier eRawType = eBound.getERawType();
if (needEClass ? eRawType instanceof EClass : needEDataType ? eRawType instanceof EDataType : eRawType!= null)
{
return eRawType;
}
}
return needEClass ? EcorePackage.Literals.EOBJECT : EcorePackage.Literals.EJAVA_OBJECT;
}
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
public EClassifier getEClassifier()
{
if (eClassifier != null && eClassifier.eIsProxy())
{
InternalEObject oldEClassifier = (InternalEObject)eClassifier;
eClassifier = (EClassifier)eResolveProxy(oldEClassifier);
if (eClassifier != oldEClassifier)
{
if (eNotificationRequired())
eNotify(new ENotificationImpl(this, Notification.RESOLVE, EcorePackage.EGENERIC_TYPE__ECLASSIFIER, oldEClassifier, eClassifier));
}
}
return eClassifier;
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
public EClassifier basicGetEClassifier()
{
return eClassifier;
}
public NotificationChain setEClassifier(EClassifier newEClassifier, NotificationChain msgs)
{
EClassifier oldEClassifier = eClassifier;
eClassifier = newEClassifier;
if (eNotificationRequired())
{
ENotificationImpl notification =
new ENotificationImpl(this, Notification.SET, EcorePackage.EGENERIC_TYPE__ECLASSIFIER, oldEClassifier, eClassifier);
if (msgs == null)
{
msgs = notification;
}
else
{
msgs.add(notification);
}
}
return msgs;
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated NOT
*/
public void setEClassifier(EClassifier newEClassifier)
{
EClassifier oldEClassifier = eClassifier;
NotificationChain msgs = setEClassifier(newEClassifier, null);
if (oldEClassifier != newEClassifier && eTypeParameter == null)
{
msgs = setERawType(newEClassifier, msgs);
}
if (msgs != null)
{
msgs.dispatch();
}
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated NOT
*/
public boolean isInstance(Object object)
{
// If there is type parameter...
//
ETypeParameter eTypeParameter = getETypeParameter();
if (eTypeParameter != null)
{
// If the object isn't an instance of all of the bounds, then it's not an instance of this generic type.
//
EList<EGenericType> eBounds = eTypeParameter.getEBounds();
for (EGenericType eBound : eBounds)
{
if (!eBound.isInstance(object))
{
return false;
}
}
// No contradiction is found, so it must be an instance.
//
return true;
}
else
{
// If there is no classifier, or the object isn't an instance of that classifier, then it's not an instance of this generic type.
//
EClassifier eClassifier = getEClassifier();
if (eClassifier == null || !eClassifier.isInstance(object))
{
return false;
}
else if (eClassifier instanceof EDataType)
{
// If we're dealing with a data type instance, we don't have more Ecore information about the instance so we must assume it's a proper instance.
// We could consider using reified Java reflection for further checking.
//
return true;
}
else
{
// Otherwise we're dealing with an instance of an EClass.
//
EClass eClass = (EClass)eClassifier;
// If the class has no type parameters, we're done.
//
EList<ETypeParameter> eTypeParameters = eClass.getETypeParameters();
if (eTypeParameters.isEmpty())
{
return true;
}
else
{
// If the generic type has no corresponding arguments, we're done.
//
EList<EGenericType> eTypeArguments = getETypeArguments();
int size = eTypeArguments.size();
if (size == 0)
{
return true;
}
else
{
// The object is an instance of the eClass, so it must be an EObject.
//
EObject eObject = (EObject)object;
EClass instanceEClass = eObject.eClass();
// If the classes are the same, we're done.
//
if (eClass == instanceEClass)
{
return true;
}
else
{
// We must necessarily find the class among all the generic super types.
//
for (EGenericType eGenericSuperType : instanceEClass.getEAllGenericSuperTypes())
{
if (eGenericSuperType.getEClassifier() == eClass)
{
// If it's specified as a raw type, we're done.
//
EList<EGenericType> instanceETypeArguments = eGenericSuperType.getETypeArguments();
if (instanceETypeArguments.isEmpty())
{
return true;
}
else
{
// Look for a contradiction between the type arguments of this generic type and the type arguments specified for the instance.
//
for (int i = 0; i < size; ++i)
{
EGenericType instanceETypeArgument = instanceETypeArguments.get(i);
EGenericType eTypeArgument = eTypeArguments.get(i);
EGenericType reifiedType = EcoreUtil.getReifiedType(instanceEClass, instanceETypeArgument);
if (eTypeArgument.getETypeParameter() == null ? !isCompatibleArgument(reifiedType, eTypeArgument) : !isSuperType(reifiedType, eTypeArgument))
{
return false;
}
}
return true;
}
}
}
// We should not get here.
//
return false;
}
}
}
}
}
}
private static boolean isSuperType(EGenericType eGenericType, EGenericType superEGenericType)
{
// If there is type parameter...
//
ETypeParameter eTypeParameter = superEGenericType.getETypeParameter();
if (eTypeParameter != null)
{
// If the type is not a subtype of of all of the bounds, then it's not an subtype.
//
EList<EGenericType> eBounds = eTypeParameter.getEBounds();
for (EGenericType eBound : eBounds)
{
if (!isSuperType(eGenericType, eBound))
{
return false;
}
}
// No contradiction is found, so it subtype.
//
return true;
}
else
{
// If there is no classifier, we treat it as a type argument and check for compatibility.
//
EClassifier eClassifier = superEGenericType.getEClassifier();
if (eClassifier == null)
{
return isCompatibleArgument(eGenericType, superEGenericType);
}
else
{
// If the type doesn't have a classifier, then it's not a subtype.
//
EClassifier eGenericTypeEClassifier = eGenericType.getEClassifier();
if (eGenericTypeEClassifier == null)
{
return false;
}
else
{
// If both the instance classes are non-null, check Java assignability for them.
//
Class<?> instanceClass = eClassifier.getInstanceClass();
Class<?> instanceTypeArgumentInstanceClass = eGenericTypeEClassifier.getInstanceClass();
if (instanceClass != null && instanceTypeArgumentInstanceClass != null)
{
if (!instanceClass.isAssignableFrom(instanceTypeArgumentInstanceClass))
{
return false;
}
}
// If their both EClasses, check Ecore super types.
//
else if (eClassifier instanceof EClass && eGenericTypeEClassifier instanceof EClass)
{
if (!((EClass)eClassifier).isSuperTypeOf((EClass)eGenericTypeEClassifier))
{
return false;
}
}
else if (eClassifier != eGenericTypeEClassifier)
{
// Otherwise they're not compatible.
//
return false;
}
// If the class has no type parameters, we're done.
//
EList<ETypeParameter> eTypeParameters = eClassifier.getETypeParameters();
if (eTypeParameters.isEmpty())
{
return true;
}
else
{
// If the generic type has no corresponding arguments, we're done.
//
EList<EGenericType> eTypeArguments = superEGenericType.getETypeArguments();
int size = eTypeArguments.size();
if (size == 0)
{
return true;
}
else if (eClassifier instanceof EDataType)
{
// If it's an EDataType, check that the arguments, if any, are compatible.
//
return isCompatibleArguments(eGenericType.getETypeArguments(), eTypeArguments);
}
else
{
// They are both EClasses...
//
EClass eClass = (EClass)eClassifier;
EClass eGenericTypeEClass = (EClass)eGenericTypeEClassifier;
// If the classes are the same, check that the type arguments, if any, are compatible.
//
if (eClass == eGenericTypeEClass)
{
return isCompatibleArguments(eGenericType.getETypeArguments(), eTypeArguments);
}
else
{
// We generally expect to find the class among all the generic super types.
//
for (EGenericType eGenericSuperType : eGenericTypeEClass.getEAllGenericSuperTypes())
{
if (eGenericSuperType.getEClassifier() == eClass)
{
// If it's specified as a raw type, we're done.
//
EList<EGenericType> instanceETypeArguments = eGenericSuperType.getETypeArguments();
if (instanceETypeArguments.isEmpty())
{
return true;
}
else
{
// Look for a contradiction between the type arguments of this generic type and the type arguments specified for the instance.
//
for (int i = 0; i < size; ++i)
{
EGenericType instanceETypeArgument = instanceETypeArguments.get(i);
EGenericType eTypeArgument = eTypeArguments.get(i);
EGenericType reifiedType = EcoreUtil.getReifiedType(eGenericTypeEClass, instanceETypeArgument);
if (!isCompatibleArgument(reifiedType, eTypeArgument))
{
return false;
}
}
return true;
}
}
}
// We should not get here.
//
return true;
}
}
}
}
}
}
}
private static boolean isCompatibleArguments(EList<EGenericType> instanceETypeArguments, EList<EGenericType> eTypeArguments)
{
// Check any argument, if present, for compatibility.
//
int size = Math.min(instanceETypeArguments.size(), eTypeArguments.size());
if (size > 0)
{
for (int i = 0; i < size; ++i)
{
if (!isCompatibleArgument(instanceETypeArguments.get(i), eTypeArguments.get(i)))
{
return false;
}
}
}
return true;
}
protected static boolean isCompatibleArgument(EGenericType instanceETypeArgument, EGenericType eTypeArgument)
{
// If the type argument specifies a type parameter...
//
ETypeParameter eTypeParameter = eTypeArgument.getETypeParameter();
if (eTypeParameter != null)
{
// The instance type argument must not be incompatible with any of the type argument's bounds.
//
for (EGenericType eBound : eTypeParameter.getEBounds())
{
if (!isCompatibleArgument(instanceETypeArgument, eBound))
{
return false;
}
}
return true;
}
else
{
// If the type argument specifies a classifier...
//
EClassifier eClassifier = eTypeArgument.getEClassifier();
if (eClassifier != null)
{
// If the instance type argument specifies a classifier...
//
EClassifier instanceTypeArgumentEClassifier = instanceETypeArgument.getEClassifier();
if (instanceTypeArgumentEClassifier != null)
{
// If they're the same classifier they're compatible...
//
if (eClassifier == instanceTypeArgumentEClassifier)
{
return isEqualArguments(instanceETypeArgument.getETypeArguments(), eTypeArgument.getETypeArguments());
}
else
{
// If both the instance classes are non-null, check Java assignability for them.
//
Class<?> instanceClass = eClassifier.getInstanceClass();
Class<?> instanceTypeArgumentInstanceClass = instanceTypeArgumentEClassifier.getInstanceClass();
if (instanceClass != null && instanceTypeArgumentInstanceClass != null)
{
// The arguments must be equal.
//
return instanceClass.isAssignableFrom(instanceTypeArgumentInstanceClass) && isEqualArguments(instanceETypeArgument.getETypeArguments(), eTypeArgument.getETypeArguments());
}
// If their both EClasses, check Ecore super types.
//
else if (eClassifier instanceof EClass && instanceTypeArgumentEClassifier instanceof EClass)
{
// The arguments must be equal.
//
return ((EClass)eClassifier).isSuperTypeOf((EClass)instanceTypeArgumentEClassifier) && isEqualArguments(instanceETypeArgument.getETypeArguments(), eTypeArgument.getETypeArguments());
}
else
{
// Otherwise they're not compatible.
//
return false;
}
}
}
else
{
// If the type argument specifies a type parameter...
//
ETypeParameter instanceTypeArgumentETypeParameter = instanceETypeArgument.getETypeParameter();
if (instanceTypeArgumentETypeParameter != null)
{
// One of the bounds must be compatible...
//
for (EGenericType eBound : instanceTypeArgumentETypeParameter.getEBounds())
{
if (isCompatibleArgument(eBound, eTypeArgument))
{
return true;
}
}
return false;
}
else
{
// It must be wildcard of some sort, but that's not valid.
//
return false;
}
}
}
else
{
EGenericType eLowerBound = eTypeArgument.getELowerBound();
if (eLowerBound != null)
{
return isCompatibleArgument(eLowerBound, instanceETypeArgument);
}
else
{
EGenericType eUpperBound = eTypeArgument.getEUpperBound();
if (eUpperBound != null)
{
return isCompatibleArgument(instanceETypeArgument, eUpperBound);
}
else
{
// An unbounded wildcard is compatible with anything.
//
return true;
}
}
}
}
}
protected static boolean isEqualArguments(EList<EGenericType> instanceETypeArguments, EList<EGenericType> eTypeArguments)
{
// Check all the arguments, if any, for equality.
//
int size = Math.min(instanceETypeArguments.size(), eTypeArguments.size());
if (size != 0)
{
for (int i = 0; i < size; ++i)
{
if (!isEqualArgument(instanceETypeArguments.get(i), eTypeArguments.get(i)))
{
return false;
}
}
}
return true;
}
protected static boolean isEqualArgument(EGenericType eGenericType1, EGenericType eGenericType2)
{
// If they are the same instance they are equal.
//
if (eGenericType1 == eGenericType2)
{
return true;
}
// If one is null (but the other is not) then they are not equal.
//
else if (eGenericType1 == null || eGenericType2 == null)
{
return false;
}
else
{
// Consider the classifiers in a special way
// to take into account the fact they they often acts as wrappers for instance type names
// and that two classifiers that wrap the same instance type name should be considered equal.
//
EClassifier eClassifier1 = eGenericType1.getEClassifier();
EClassifier eClassifier2 = eGenericType2.getEClassifier();
// If they are the same classifier, they are of course equal.
//
if (eClassifier1 != eClassifier2)
{
// If they both aren't null...
//
if (eClassifier1 != null && eClassifier2 != null)
{
// Consider the instance type names they wrap
// to see if they are non-null and equal.
//
String instanceTypeName1 = eClassifier1.getInstanceTypeName();
String instanceTypeName2 = eClassifier2.getInstanceTypeName();
// I.e., the classifiers are considered equal if they wrap the same non-null type.
//
if (instanceTypeName1 == null || !instanceTypeName1.equals(instanceTypeName2))
{
return false;
}
}
// If one is null (but the other is not) then they can't be equal.
//
else if (eClassifier1 != null || eClassifier2 != null)
{
return false;
}
}
// Type parameters are assumed to be equal.
//
ETypeParameter eTypeParameter1 = eGenericType1.getETypeParameter();
ETypeParameter eTypeParameter2 = eGenericType2.getETypeParameter();
if (eTypeParameter1 != null && eTypeParameter2 != null)
{
return true;
}
// The arguments, type parameters, lower bounds and upper bounds must be equal type arguments.
//
return
isEqualArguments(eGenericType1.getETypeArguments(), eGenericType2.getETypeArguments()) &&
isEqualArgument(eGenericType1.getELowerBound(), eGenericType2.getELowerBound()) &&
isEqualArgument(eGenericType1.getEUpperBound(), eGenericType2.getEUpperBound());
}
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
@Override
public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
{
switch (featureID)
{
case EcorePackage.EGENERIC_TYPE__EUPPER_BOUND:
return basicSetEUpperBound(null, msgs);
case EcorePackage.EGENERIC_TYPE__ETYPE_ARGUMENTS:
return ((InternalEList<?>)getETypeArguments()).basicRemove(otherEnd, msgs);
case EcorePackage.EGENERIC_TYPE__ELOWER_BOUND:
return basicSetELowerBound(null, msgs);
}
return eDynamicInverseRemove(otherEnd, featureID, msgs);
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
@Override
public Object eGet(int featureID, boolean resolve, boolean coreType)
{
switch (featureID)
{
case EcorePackage.EGENERIC_TYPE__EUPPER_BOUND:
return getEUpperBound();
case EcorePackage.EGENERIC_TYPE__ETYPE_ARGUMENTS:
return getETypeArguments();
case EcorePackage.EGENERIC_TYPE__ERAW_TYPE:
if (resolve) return getERawType();
return basicGetERawType();
case EcorePackage.EGENERIC_TYPE__ELOWER_BOUND:
return getELowerBound();
case EcorePackage.EGENERIC_TYPE__ETYPE_PARAMETER:
return getETypeParameter();
case EcorePackage.EGENERIC_TYPE__ECLASSIFIER:
if (resolve) return getEClassifier();
return basicGetEClassifier();
}
return eDynamicGet(featureID, resolve, coreType);
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
@SuppressWarnings("unchecked")
@Override
public void eSet(int featureID, Object newValue)
{
switch (featureID)
{
case EcorePackage.EGENERIC_TYPE__EUPPER_BOUND:
setEUpperBound((EGenericType)newValue);
return;
case EcorePackage.EGENERIC_TYPE__ETYPE_ARGUMENTS:
getETypeArguments().clear();
getETypeArguments().addAll((Collection<? extends EGenericType>)newValue);
return;
case EcorePackage.EGENERIC_TYPE__ELOWER_BOUND:
setELowerBound((EGenericType)newValue);
return;
case EcorePackage.EGENERIC_TYPE__ETYPE_PARAMETER:
setETypeParameter((ETypeParameter)newValue);
return;
case EcorePackage.EGENERIC_TYPE__ECLASSIFIER:
setEClassifier((EClassifier)newValue);
return;
}
eDynamicSet(featureID, newValue);
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
@Override
public void eUnset(int featureID)
{
switch (featureID)
{
case EcorePackage.EGENERIC_TYPE__EUPPER_BOUND:
setEUpperBound((EGenericType)null);
return;
case EcorePackage.EGENERIC_TYPE__ETYPE_ARGUMENTS:
getETypeArguments().clear();
return;
case EcorePackage.EGENERIC_TYPE__ELOWER_BOUND:
setELowerBound((EGenericType)null);
return;
case EcorePackage.EGENERIC_TYPE__ETYPE_PARAMETER:
setETypeParameter((ETypeParameter)null);
return;
case EcorePackage.EGENERIC_TYPE__ECLASSIFIER:
setEClassifier((EClassifier)null);
return;
}
eDynamicUnset(featureID);
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
@Override
public boolean eIsSet(int featureID)
{
switch (featureID)
{
case EcorePackage.EGENERIC_TYPE__EUPPER_BOUND:
return eUpperBound != null;
case EcorePackage.EGENERIC_TYPE__ETYPE_ARGUMENTS:
return eTypeArguments != null && !eTypeArguments.isEmpty();
case EcorePackage.EGENERIC_TYPE__ERAW_TYPE:
return eRawType != null;
case EcorePackage.EGENERIC_TYPE__ELOWER_BOUND:
return eLowerBound != null;
case EcorePackage.EGENERIC_TYPE__ETYPE_PARAMETER:
return eTypeParameter != null;
case EcorePackage.EGENERIC_TYPE__ECLASSIFIER:
return eClassifier != null;
}
return eDynamicIsSet(featureID);
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
@Override
public Object eInvoke(int operationID, EList<?> arguments) throws InvocationTargetException
{
switch (operationID)
{
case EcorePackage.EGENERIC_TYPE___IS_INSTANCE__OBJECT:
return isInstance(arguments.get(0));
}
return eDynamicInvoke(operationID, arguments);
}
@Override
public String toString()
{
StringBuilder result = new StringBuilder(super.toString());
result.append(" (expression: ");
toString(result);
result.append(')');
return result.toString();
}
protected void toString(StringBuilder result)
{
if (eClassifier != null)
{
String label = eClassifier.getName();
String tail = null;
if (label != null)
{
result.append(label);
}
else
{
String instanceTypeName = eClassifier.getInstanceTypeName();
if (instanceTypeName != null)
{
int index = instanceTypeName.indexOf('[');
if (index != -1)
{
tail = instanceTypeName.substring(index);
result.append(instanceTypeName, 0, index);
}
else
{
result.append(instanceTypeName);
}
}
}
if (eTypeArguments != null && !eTypeArguments.isEmpty())
{
boolean first = true;
result.append('<');
for (EGenericType eTypeArgument : eTypeArguments)
{
if (first)
{
first = false;
}
else
{
result.append(", ");
}
((EGenericTypeImpl)eTypeArgument).toString(result);
}
result.append('>');
}
if (tail != null)
{
result.append(tail);
}
}
else if (eTypeParameter != null)
{
String label = eTypeParameter.getName();
if (label != null)
{
result.append(label);
}
}
else
{
result.append('?');
if (eLowerBound != null)
{
result.append(" super ");
((EGenericTypeImpl)eLowerBound).toString(result);
}
else
{
if (eUpperBound != null)
{
result.append(" extends ");
((EGenericTypeImpl)eUpperBound).toString(result);
}
}
}
}
} //EGenericTypeImpl