return listIterator();
}
protected EGenericType wrap(EClassifier eClassifier)
{
EGenericType eGenericType = EcoreFactory.eINSTANCE.createEGenericType();
eGenericType.setEClassifier(eClassifier);
return eGenericType;
}
protected EClassifier unwrap(EGenericType eGenericType)
{
EClassifier result = ((EGenericTypeImpl)eGenericType).basicGetERawType();
if (result != null)
{
return result;
}
else
{
return EcorePackage.Literals.EJAVA_OBJECT;
}
}
@Override
protected void delegateAdd(int index, EClassifier eClassifier)
{
getEGenericExceptions().add(index, wrap(eClassifier));
}
@Override
protected void delegateClear()
{
getEGenericExceptions().clear();
}
@Override
protected void delegateAdd(EClassifier eClassifier)
{
getEGenericExceptions().add(wrap(eClassifier));
}
@Override
protected boolean delegateContains(Object object)
{
for (EClassifier eClassifier : this)
{
if (object == eClassifier)
{
return true;
}
}
return false;
}
@Override
protected boolean delegateContainsAll(Collection<?> collection)
{
for (Object object : collection)
{
if (!delegateContains(object))
{
return false;
}
}
return true;
}
@Override
protected boolean delegateEquals(Object object)
{
if (object instanceof List<?>)
{
List<?> list = (List<?>)object;
if (list.size() == delegateSize())
{
for (Iterator<?> i = list.iterator(), j = iterator(); i.hasNext(); )
{
if (i.next() != j.next())
{
return false;
}
}
return true;
}
}
return false;
}
@Override
protected EClassifier delegateGet(int index)
{
EGenericType eGenericType = getEGenericExceptions().get(index);
return unwrap(eGenericType);
}
@Override
protected int delegateHashCode()
{
int hashCode = 1;
for (EGenericType eGenericType : getEGenericExceptions())
{
Object object = unwrap(eGenericType);
hashCode = 31 * hashCode + (object == null ? 0 : object.hashCode());
}
return hashCode;
}
@Override
protected int delegateIndexOf(Object object)
{
int index = 0;
for (EGenericType eGenericType : getEGenericExceptions())
{
if (object == unwrap(eGenericType))
{
return index;
}
++index;
}
return -1;
}
@Override
protected boolean delegateIsEmpty()
{
return getEGenericExceptions().isEmpty();
}
@Override
protected int delegateLastIndexOf(Object object)
{
EList<EGenericType> eGenericExceptions = getEGenericExceptions();
for (int i = eGenericExceptions.size() - 1; i >= 0; --i)
{
if (unwrap(eGenericExceptions.get(i)) == object)
{
return i;
}
}
return -1;
}
@Override
protected EClassifier delegateRemove(int index)
{
EGenericType eGenericType = getEGenericExceptions().remove(index);
return unwrap(eGenericType);
}
@Override
protected EClassifier delegateSet(int index, EClassifier eClassifier)
{
EGenericType eGenericType = getEGenericExceptions().get(index);
EClassifier result = unwrap(eGenericType);
// If this is just a proxy being resolved...
//
if (resolveProxy(result) == eClassifier)
{
// Force the raw type to be resolved so we don't resolve this endlessly.
//
eGenericType.getERawType();
}
else
{
// Update the classifier and hence the raw type as normal.
//
eGenericType.setEClassifier(eClassifier);
}
return result;
}
@Override