/*
 * Copyright (c) 2005, 2011 IBM Corporation, Embarcadero Technologies, 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
 *   Kenn Hussey (Embarcadero Technologies) - 206636, 204200
 *   Lutz Wrage - 241411
 *   Kenn Hussey - 286329, 323181, 344908
 *
 * $Id: GenClassImpl.java,v 1.49 2011/05/06 03:02:05 khussey Exp $
 */
package org.eclipse.uml2.codegen.ecore.genmodel.impl;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import org.eclipse.emf.codegen.ecore.genmodel.GenFeature;
import org.eclipse.emf.codegen.ecore.genmodel.GenJDKLevel;
import org.eclipse.emf.codegen.ecore.genmodel.GenOperation;
import org.eclipse.emf.codegen.ecore.genmodel.GenRuntimeVersion;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.UniqueEList;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EOperation;
import org.eclipse.emf.ecore.EParameter;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.uml2.codegen.ecore.Generator;
import org.eclipse.uml2.codegen.ecore.genmodel.GenClass;
import org.eclipse.uml2.codegen.ecore.genmodel.GenModelPackage;
import org.eclipse.uml2.codegen.ecore.genmodel.util.UML2GenModelUtil;

/**
 * <!-- begin-user-doc -->
 * An implementation of the model object '<em><b>Gen Class</b></em>'.
 * <!-- end-user-doc -->
 * <p>
 * </p>
 *
 * @generated
 */
public class GenClassImpl
		extends org.eclipse.emf.codegen.ecore.genmodel.impl.GenClassImpl
		implements GenClass {

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

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

	protected List<GenFeature> duplicateGenFeatures = null;

	public List<GenFeature> getDuplicateGenFeatures() {
		List<GenFeature> result = new ArrayList<GenFeature>(getGenFeatures());

		if (duplicateGenFeatures == null) {
			duplicateGenFeatures = new ArrayList<GenFeature>();

			for (EStructuralFeature duplicateEcoreFeature : Generator
				.getDuplicateEcoreFeatures(getEcoreClass())) {

				GenFeature duplicateGenFeature = getGenModel()
					.createGenFeature();
				duplicateGenFeature.initialize(duplicateEcoreFeature);
				duplicateGenFeatures.add(duplicateGenFeature);
			}
		}

		result.addAll(duplicateGenFeatures);

		return result;
	}

	protected List<GenFeature> collectDuplicateGenFeatures(
			List<org.eclipse.emf.codegen.ecore.genmodel.GenClass> genClasses,
			List<GenFeature> genFeatures, GenFeatureFilter filter) {
		List<GenFeature> result = new ArrayList<GenFeature>();

		if (genClasses != null) {

			for (org.eclipse.emf.codegen.ecore.genmodel.GenClass genClass : genClasses) {
				result
					.addAll(collectGenFeatures(null,
						UML2GenModelUtil.getDuplicateGenFeatures(genClass),
						filter));
			}
		}

		if (genFeatures != null) {
			result.addAll(collectGenFeatures(null, genFeatures, filter));
		}

		return result;
	}

	protected List<GenFeature> getAllDuplicateGenFeatures() {
		return collectDuplicateGenFeatures(getAllBaseGenClasses(),
			getDuplicateGenFeatures(), null);
	}

	@Override
	public List<GenFeature> getDeclaredGenFeatures() {
		Map<String, GenFeature> declaredGenFeatures = new LinkedHashMap<String, GenFeature>();

		List<GenFeature> redefinedGenFeatures = collectGenFeatures(null,
			getRedefinedGenFeatures(), new GenFeatureFilter() {

				public boolean accept(GenFeature genFeature) {
					return !getAllGenFeatures().contains(genFeature);
				}
			});

		for (GenFeature redefinedGenFeature : redefinedGenFeatures) {
			declaredGenFeatures.put(redefinedGenFeature.getName(),
				redefinedGenFeature);
		}

		List<GenFeature> duplicateGenFeatures = collectGenFeatures(null,
			getDuplicateGenFeatures(), new GenFeatureFilter() {

				public boolean accept(GenFeature genFeature) {
					return !UML2GenModelUtil.isDuplicate(genFeature)
						|| !UML2GenModelUtil.isRedefinition(genFeature);
				}
			});

		for (GenFeature duplicateGenFeature : duplicateGenFeatures) {
			declaredGenFeatures.put(duplicateGenFeature.getName(),
				duplicateGenFeature);
		}

		return new ArrayList<GenFeature>(declaredGenFeatures.values());
	}

	protected List<GenFeature> getImplementedGenFeatures(GenFeatureFilter filter) {
		Map<String, GenFeature> implementedGenFeatures = new LinkedHashMap<String, GenFeature>();

		for (org.eclipse.emf.codegen.ecore.genmodel.GenClass implementedGenClass : getImplementedGenClasses()) {

			for (GenFeature unionGenFeature : UML2GenModelUtil
				.getUnionGenFeatures(implementedGenClass)) {

				implementedGenFeatures.put(unionGenFeature.getName(),
					unionGenFeature);
			}

			for (GenFeature supersetGenFeature : UML2GenModelUtil
				.getSupersetGenFeatures(implementedGenClass)) {

				implementedGenFeatures.put(supersetGenFeature.getName(),
					supersetGenFeature);
			}

			for (GenFeature redefinedGenFeature : UML2GenModelUtil
				.getRedefinedGenFeatures(implementedGenClass)) {

				implementedGenFeatures.put(redefinedGenFeature.getName(),
					redefinedGenFeature);
			}

			for (GenFeature duplicateGenFeature : UML2GenModelUtil
				.getDuplicateGenFeatures(implementedGenClass)) {

				implementedGenFeatures.put(duplicateGenFeature.getName(),
					duplicateGenFeature);
			}
		}

		return collectGenFeatures(null, new ArrayList<GenFeature>(
			implementedGenFeatures.values()), filter);
	}

	@Override
	public List<GenFeature> getDeclaredFieldGenFeatures() {
		return getImplementedGenFeatures(new GenFeatureFilter() {

			public boolean accept(GenFeature genFeature) {

				if (UML2GenModelUtil.isDuplicate(genFeature)) {

					for (GenFeature redefinedGenFeature : UML2GenModelUtil
						.getRedefinedGenFeatures(genFeature)) {

						if (getExtendedGenFeatures().contains(
							redefinedGenFeature)) {

							return !UML2GenModelUtil
								.isUnion(redefinedGenFeature)
								&& !isRedefined(redefinedGenFeature);
						}
					}
				}

				return !getExtendedGenFeatures().contains(genFeature)
					&& !UML2GenModelUtil.isUnion(genFeature)
					&& !isRedefined(genFeature);
			}
		});
	}

	@Override
	public List<GenFeature> getImplementedGenFeatures() {
		return getImplementedGenFeatures(new GenFeatureFilter() {

			public boolean accept(GenFeature genFeature) {
				return !isRedefined(genFeature);
			}
		});
	}

	@Override
	public List<GenFeature> getExtendedGenFeatures() {
		return collectDuplicateGenFeatures(getExtendedGenClasses(), null, null);
	}

	protected List<GenOperation> duplicateGenOperations = null;

	public List<GenOperation> getDuplicateGenOperations() {
		List<GenOperation> result = new ArrayList<GenOperation>(
			getGenOperations());

		if (duplicateGenOperations == null) {
			duplicateGenOperations = new ArrayList<GenOperation>();

			for (EOperation duplicateEcoreOperation : Generator
				.getDuplicateEcoreOperations(getEcoreClass())) {

				GenOperation duplicateGenOperation = getGenModel()
					.createGenOperation();
				duplicateGenOperation.initialize(duplicateEcoreOperation);
				duplicateGenOperations.add(duplicateGenOperation);
			}
		}

		result.addAll(duplicateGenOperations);

		return result;
	}

	protected List<GenOperation> collectDuplicateGenOperations(
			List<org.eclipse.emf.codegen.ecore.genmodel.GenClass> genClasses,
			List<GenOperation> genOperations, GenOperationFilter filter) {
		List<GenOperation> result = new ArrayList<GenOperation>();

		if (genClasses != null) {

			for (org.eclipse.emf.codegen.ecore.genmodel.GenClass genClass : genClasses) {
				result.addAll(collectGenOperations(this, null,
					UML2GenModelUtil.getDuplicateGenOperations(genClass),
					filter));
			}
		}

		if (genFeatures != null) {
			result.addAll(collectGenOperations(this, null, genOperations,
				filter));
		}

		return result;
	}

	protected List<GenOperation> getAllDuplicateGenOperations() {
		return collectDuplicateGenOperations(getAllBaseGenClasses(),
			getDuplicateGenOperations(), null);
	}

	@Override
	public List<GenOperation> getDeclaredGenOperations() {
		Map<String, GenOperation> declaredGenOperations = new LinkedHashMap<String, GenOperation>();

		List<GenOperation> redefinedGenOperations = collectGenOperations(this,
			null, getRedefinedGenOperations(), new GenOperationFilter() {

				public boolean accept(GenOperation genOperation) {
					return !getAllDuplicateGenOperations().contains(
						genOperation);
				}
			});

		for (GenOperation redefinedGenOperation : redefinedGenOperations) {
			declaredGenOperations
				.put(
					redefinedGenOperation.getName()
						+ redefinedGenOperation.getParameterTypes(""), redefinedGenOperation); //$NON-NLS-1$
		}

		List<GenOperation> duplicateGenOperations = collectGenOperations(this,
			null, getDuplicateGenOperations(), new GenOperationFilter() {

				public boolean accept(GenOperation genOperation) {
					return !UML2GenModelUtil.isDuplicate(genOperation)
						|| !UML2GenModelUtil.isRedefinition(genOperation);
				}
			});

		for (GenOperation duplicateGenOperation : duplicateGenOperations) {
			declaredGenOperations
				.put(
					duplicateGenOperation.getName()
						+ duplicateGenOperation.getParameterTypes(""), duplicateGenOperation); //$NON-NLS-1$
		}

		return collectGenOperations(this, null, new ArrayList<GenOperation>(
			declaredGenOperations.values()), new CollidingGenOperationFilter());
	}

	protected List<GenOperation> getImplementedGenOperations(
			GenOperationFilter filter) {
		Map<String, GenOperation> implementedGenOperations = new LinkedHashMap<String, GenOperation>();

		for (org.eclipse.emf.codegen.ecore.genmodel.GenClass implementedGenClass : getImplementedGenClasses()) {

			for (GenOperation redefinedGenOperation : UML2GenModelUtil
				.getRedefinedGenOperations(implementedGenClass)) {

				implementedGenOperations
					.put(
						redefinedGenOperation.getName()
							+ redefinedGenOperation.getParameterTypes(""), redefinedGenOperation); //$NON-NLS-1$
			}

			for (GenOperation duplicateGenOperation : UML2GenModelUtil
				.getDuplicateGenOperations(implementedGenClass)) {

				implementedGenOperations
					.put(
						duplicateGenOperation.getName()
							+ duplicateGenOperation.getParameterTypes(""), duplicateGenOperation); //$NON-NLS-1$
			}
		}

		return collectGenOperations(this, null, new ArrayList<GenOperation>(
			implementedGenOperations.values()), filter);
	}

	@Override
	public List<GenOperation> getImplementedGenOperations() {
		return getImplementedGenOperations(new CollidingGenOperationFilter() {

			@Override
			public boolean accept(GenOperation genOperation) {
				return super.accept(genOperation) && !isRedefined(genOperation);
			}
		});
	}

	public GenOperation getImplementedCollidingGetGenOperation(
			final GenFeature genFeature) {
		List<GenOperation> implementedCollidingGenOperations = getImplementedGenOperations(new CollidingGenOperationFilter() {

			@Override
			public boolean accept(GenOperation genOperation) {
				return !super.accept(genOperation)
					&& genOperation.getName().equals(
						genFeature.getGetAccessor());
			}
		});

		return implementedCollidingGenOperations.isEmpty()
			? null
			: (GenOperation) implementedCollidingGenOperations.get(0);
	}

	public GenOperation getImplementedCollidingSetGenOperation(
			final GenFeature genFeature) {
		List<GenOperation> implementedCollidingGenOperations = getImplementedGenOperations(new CollidingGenOperationFilter() {

			@Override
			public boolean accept(GenOperation genOperation) {
				return !super.accept(genOperation)
					&& genOperation.getName().equals("set" //$NON-NLS-1$
						+ genFeature.getAccessorName());
			}
		});

		return implementedCollidingGenOperations.isEmpty()
			? null
			: (GenOperation) implementedCollidingGenOperations.get(0);
	}

	public GenOperation getImplementedCollidingIsSetGenOperation(
			final GenFeature genFeature) {
		List<GenOperation> implementedCollidingGenOperations = getImplementedGenOperations(new CollidingGenOperationFilter() {

			@Override
			public boolean accept(GenOperation genOperation) {
				return !super.accept(genOperation)
					&& genOperation.getName().equals("isSet" //$NON-NLS-1$
						+ genFeature.getAccessorName());
			}
		});

		return implementedCollidingGenOperations.isEmpty()
			? null
			: (GenOperation) implementedCollidingGenOperations.get(0);
	}

	public GenOperation getImplementedCollidingUnsetGenOperation(
			final GenFeature genFeature) {
		List<GenOperation> implementedCollidingGenOperations = getImplementedGenOperations(new CollidingGenOperationFilter() {

			@Override
			public boolean accept(GenOperation genOperation) {
				return !super.accept(genOperation)
					&& genOperation.getName().equals("unset" //$NON-NLS-1$
						+ genFeature.getAccessorName());
			}
		});

		return implementedCollidingGenOperations.isEmpty()
			? null
			: (GenOperation) implementedCollidingGenOperations.get(0);
	}

	@Override
	public List<GenOperation> getExtendedGenOperations() {
		return collectDuplicateGenOperations(getExtendedGenClasses(), null,
			null);
	}

	@Override
	public List<GenOperation> getInvariantOperations() {
		return collectGenOperations(this, null, getDuplicateGenOperations(),
			new GenOperationFilter() {

				public boolean accept(GenOperation genOperation) {
					return genOperation.isInvariant();
				}
			});
	}

	public String getImportedOperationsClassName() {
		return getGenModel().getImportedName(getQualifiedOperationsClassName());
	}

	public String getOperationsClassName() {
		return getName() + "Operations"; //$NON-NLS-1$
	}

	public String getQualifiedOperationsClassName() {
		return UML2GenModelUtil.getOperationsPackageName(getGenPackage()) + "." //$NON-NLS-1$
			+ getOperationsClassName();
	}

	public List<GenOperation> getOperationsClassGenOperations() {
		EList<GenOperation> result = new UniqueEList.FastCompare<GenOperation>();

		if (!isInterface()) {

			for (GenOperation genOperation : getImplementedGenOperations(null)) {
				org.eclipse.emf.codegen.ecore.genmodel.GenClass genClass = genOperation
					.getGenClass();

				if ((genClass == this || genClass.isInterface())
					&& !genOperation.hasBody()
					&& (genClass.getGenModel().getRuntimeVersion().getValue() < GenRuntimeVersion.EMF26_VALUE || (!genOperation
						.hasInvariantExpression() && !genOperation
						.hasInvocationDelegate()))) {

					result.add(genOperation);
				}
			}
		}

		return result;
	}

	@Override
	public String getOperationID(GenOperation genOperation) {

		if (genOperation.isInvariant()) {
			String prefix = UML2GenModelUtil.getInvariantPrefix(getGenModel());

			if (!isBlank(prefix)) {
				return getClassifierID()
					+ "__" //$NON-NLS-1$
					+ format(genOperation.getName(), '_', prefix, false, false)
						.toUpperCase();
			}
		}

		return super.getOperationID(genOperation);
	}

	public String getOperationsClassExtends() {

		for (org.eclipse.emf.codegen.ecore.genmodel.GenClass classExtendsGenClass = getClassExtendsGenClass(); classExtendsGenClass != null; classExtendsGenClass = classExtendsGenClass
			.getClassExtendsGenClass()) {

			if (UML2GenModelUtil.isOperationsClasses(classExtendsGenClass
				.getGenPackage())
				&& !UML2GenModelUtil.getOperationsClassGenOperations(
					classExtendsGenClass).isEmpty()) {

				return " extends " //$NON-NLS-1$
					+ UML2GenModelUtil
						.getImportedOperationsClassName(classExtendsGenClass);
			}
		}

		return ""; //$NON-NLS-1$
	}

	@Override
	public List<GenFeature> getEInverseAddGenFeatures() {
		return collectGenFeatures(null, super.getEInverseAddGenFeatures(),
			new GenFeatureFilter() {

				public boolean accept(GenFeature genFeature) {
					return !genFeature.isDerived();
				}
			});
	}

	@Override
	public List<GenFeature> getEInverseRemoveGenFeatures() {
		return collectGenFeatures(null, super.getEInverseRemoveGenFeatures(),
			new GenFeatureFilter() {

				public boolean accept(GenFeature genFeature) {
					return !genFeature.isDerived();
				}
			});
	}

	protected String getSubsetListConstructor(GenFeature genFeature) {
		return getSubsetSupersetListConstructor(genFeature);
	}

	protected String getSupersetListConstructor(GenFeature genFeature) {
		return getSubsetSupersetListConstructor(genFeature);
	}

	protected String getSubsetSupersetListConstructor(GenFeature genFeature) {
		StringBuffer sb = new StringBuffer();

		String unsettable = genFeature.isUnsettable()
			? ".Unsettable" //$NON-NLS-1$
			: ""; //$NON-NLS-1$

		if (genFeature.isMapType()) {
			return super.getListConstructor(genFeature);
		} else if (genFeature.isFeatureMapType()) {
			return super.getListConstructor(genFeature);
		} else if (getGenModel().isSuppressNotification()) {
			sb.append(getGenModel().getImportedName(
				"org.eclipse.emf.ecore.util.BasicInternalEList")); //$NON-NLS-1$
			if (getEffectiveComplianceLevel().getValue() >= GenJDKLevel.JDK50) {
				sb.append('<');
				sb.append(UML2GenModelUtil.getRedefinedListItemType(this,
					genFeature));
				sb.append('>');
			}
			sb.append("("); //$NON-NLS-1$
			sb.append(genFeature.getRawListItemType());
			sb.append(".class)"); //$NON-NLS-1$
		} else if (genFeature.isEffectiveContains()) {
			if (genFeature.isBidirectional()) {
				GenFeature reverseFeature = genFeature.getReverse();
				sb.append(getGenModel()
					.getImportedName(
						"org.eclipse.uml2.common.util.SubsetSupersetEObjectContainmentWithInverseEList")); //$NON-NLS-1$
				sb.append(unsettable);
				if (genFeature.isResolveProxies()) {
					sb.append(".Resolving"); //$NON-NLS-1$
				}
				if (getEffectiveComplianceLevel().getValue() >= GenJDKLevel.JDK50) {
					sb.append('<');
					sb.append(UML2GenModelUtil.getRedefinedListItemType(this,
						genFeature));
					sb.append('>');
				}
				sb.append("("); //$NON-NLS-1$
				sb.append(genFeature.getRawListItemType());
				sb.append(".class, this, "); //$NON-NLS-1$
				sb.append(getQualifiedFeatureID(genFeature));
				sb.append(", "); //$NON-NLS-1$
				if (UML2GenModelUtil.getSupersetGenFeatures(this, genFeature,
					false).isEmpty()) {
					sb.append("null"); //$NON-NLS-1$
				} else {
					sb.append(genFeature.getUpperName());
					sb.append("_ESUPERSETS"); //$NON-NLS-1$
				}
				sb.append(", "); //$NON-NLS-1$
				if (UML2GenModelUtil.getSubsetGenFeatures(this, genFeature,
					false).isEmpty()) {
					sb.append("null"); //$NON-NLS-1$
				} else {
					sb.append(genFeature.getUpperName());
					sb.append("_ESUBSETS"); //$NON-NLS-1$
				}
				sb.append(", "); //$NON-NLS-1$
				sb.append(reverseFeature.getGenClass().getQualifiedFeatureID(
					reverseFeature));
				sb.append(")"); //$NON-NLS-1$
			} else {
				sb.append(getGenModel()
					.getImportedName(
						"org.eclipse.uml2.common.util.SubsetSupersetEObjectContainmentEList")); //$NON-NLS-1$
				sb.append(unsettable);
				if (genFeature.isResolveProxies()) {
					sb.append(".Resolving"); //$NON-NLS-1$
				}
				if (getEffectiveComplianceLevel().getValue() >= GenJDKLevel.JDK50) {
					sb.append('<');
					sb.append(UML2GenModelUtil.getRedefinedListItemType(this,
						genFeature));
					sb.append('>');
				}
				sb.append("("); //$NON-NLS-1$
				sb.append(genFeature.getRawListItemType());
				sb.append(".class, this, "); //$NON-NLS-1$
				sb.append(getQualifiedFeatureID(genFeature));
				sb.append(", "); //$NON-NLS-1$
				if (UML2GenModelUtil.getSupersetGenFeatures(this, genFeature,
					false).isEmpty()) {
					sb.append("null"); //$NON-NLS-1$
				} else {
					sb.append(genFeature.getUpperName());
					sb.append("_ESUPERSETS"); //$NON-NLS-1$
				}
				sb.append(", "); //$NON-NLS-1$
				if (UML2GenModelUtil.getSubsetGenFeatures(this, genFeature,
					false).isEmpty()) {
					sb.append("null"); //$NON-NLS-1$
				} else {
					sb.append(genFeature.getUpperName());
					sb.append("_ESUBSETS"); //$NON-NLS-1$
				}
				sb.append(")"); //$NON-NLS-1$
			}
		} else if (genFeature.isReferenceType()) {
			if (genFeature.isBidirectional()) {
				GenFeature reverseFeature = genFeature.getReverse();
				if (genFeature.isResolveProxies()) {
					sb.append(getGenModel()
						.getImportedName(
							"org.eclipse.uml2.common.util.SubsetSupersetEObjectWithInverseResolvingEList")); //$NON-NLS-1$
				} else {
					sb.append(getGenModel()
						.getImportedName(
							"org.eclipse.uml2.common.util.SubsetSupersetEObjectWithInverseEList")); //$NON-NLS-1$
				}
				sb.append(unsettable);
				if (reverseFeature.isListType()) {
					sb.append(".ManyInverse"); //$NON-NLS-1$
				}
				if (getEffectiveComplianceLevel().getValue() >= GenJDKLevel.JDK50) {
					sb.append('<');
					sb.append(UML2GenModelUtil.getRedefinedListItemType(this,
						genFeature));
					sb.append('>');
				}
				sb.append("("); //$NON-NLS-1$
				sb.append(genFeature.getRawListItemType());
				sb.append(".class, this, "); //$NON-NLS-1$
				sb.append(getQualifiedFeatureID(genFeature));
				sb.append(", "); //$NON-NLS-1$
				if (UML2GenModelUtil.getSupersetGenFeatures(this, genFeature,
					false).isEmpty()) {
					sb.append("null"); //$NON-NLS-1$
				} else {
					sb.append(genFeature.getUpperName());
					sb.append("_ESUPERSETS"); //$NON-NLS-1$
				}
				sb.append(", "); //$NON-NLS-1$
				if (UML2GenModelUtil.getSubsetGenFeatures(this, genFeature,
					false).isEmpty()) {
					sb.append("null"); //$NON-NLS-1$
				} else {
					sb.append(genFeature.getUpperName());
					sb.append("_ESUBSETS"); //$NON-NLS-1$
				}
				sb.append(", "); //$NON-NLS-1$
				sb.append(reverseFeature.getGenClass().getQualifiedFeatureID(
					reverseFeature));
				sb.append(")"); //$NON-NLS-1$
			} else {
				if (genFeature.isResolveProxies()) {
					sb.append(getGenModel()
						.getImportedName(
							"org.eclipse.uml2.common.util.SubsetSupersetEObjectResolvingEList")); //$NON-NLS-1$
				} else {
					sb.append(getGenModel()
						.getImportedName(
							"org.eclipse.uml2.common.util.SubsetSupersetEObjectEList")); //$NON-NLS-1$
				}
				sb.append(unsettable);
				if (getEffectiveComplianceLevel().getValue() >= GenJDKLevel.JDK50) {
					sb.append('<');
					sb.append(UML2GenModelUtil.getRedefinedListItemType(this,
						genFeature));
					sb.append('>');
				}
				sb.append("("); //$NON-NLS-1$
				sb.append(genFeature.getRawListItemType());
				sb.append(".class, this, "); //$NON-NLS-1$
				sb.append(getQualifiedFeatureID(genFeature));
				sb.append(", "); //$NON-NLS-1$
				if (UML2GenModelUtil.getSupersetGenFeatures(this, genFeature,
					false).isEmpty()) {
					sb.append("null"); //$NON-NLS-1$
				} else {
					sb.append(genFeature.getUpperName());
					sb.append("_ESUPERSETS"); //$NON-NLS-1$
				}
				sb.append(", "); //$NON-NLS-1$
				if (UML2GenModelUtil.getSubsetGenFeatures(this, genFeature,
					false).isEmpty()) {
					sb.append("null"); //$NON-NLS-1$
				} else {
					sb.append(genFeature.getUpperName());
					sb.append("_ESUBSETS"); //$NON-NLS-1$
				}
				sb.append(")"); //$NON-NLS-1$
			}
		} else { // datatype
			return super.getListConstructor(genFeature);
		}
		return sb.toString();
	}

	protected String getDerivedUnionListConstructor(GenFeature genFeature) {
		StringBuffer sb = new StringBuffer();

		if (genFeature.isMapType()) {
			return super.getListConstructor(genFeature);
		} else if (genFeature.isFeatureMapType()) {
			return super.getListConstructor(genFeature);
		} else if (genFeature.isReferenceType()) {
			sb.append(getGenModel().getImportedName(
				"org.eclipse.uml2.common.util.DerivedUnionEObjectEList")); //$NON-NLS-1$
			if (getEffectiveComplianceLevel().getValue() >= GenJDKLevel.JDK50) {
				sb.append('<');
				sb.append(UML2GenModelUtil.getRedefinedListItemType(this,
					genFeature));
				sb.append('>');
			}
			sb.append("("); //$NON-NLS-1$
			sb.append(genFeature.getRawListItemType());
			sb.append(".class, this, "); //$NON-NLS-1$
			sb.append(getQualifiedFeatureID(genFeature));
			sb.append(", "); //$NON-NLS-1$
			if (UML2GenModelUtil.getSubsetGenFeatures(this, genFeature, true)
				.isEmpty()) {
				sb.append("null"); //$NON-NLS-1$
			} else {
				sb.append(genFeature.getUpperName());
				sb.append("_ESUBSETS"); //$NON-NLS-1$
			}
			sb.append(")"); //$NON-NLS-1$
		} else { // datatype
			return super.getListConstructor(genFeature);
		}
		return sb.toString();
	}

	@Override
	public String getListConstructor(GenFeature genFeature) {

		if (UML2GenModelUtil.isUnion(genFeature)) {
			return getDerivedUnionListConstructor(genFeature);
		}

		if (isSuperset(genFeature)
			&& !getSubsetGenFeatures(genFeature, false).isEmpty()) {

			return getSupersetListConstructor(genFeature);
		}

		if (UML2GenModelUtil.isSubset(genFeature)
			&& !getSupersetGenFeatures(genFeature, false).isEmpty()) {

			return getSubsetListConstructor(genFeature);
		}

		return super.getListConstructor(genFeature);
	}

	@Override
	public GenFeature findGenFeature(EStructuralFeature ecoreFeature) {
		org.eclipse.emf.codegen.ecore.genmodel.GenClass genClass = findGenClass(Generator
			.getEcoreContainingClass(ecoreFeature));

		for (GenFeature duplicateGenFeature : UML2GenModelUtil
			.getDuplicateGenFeatures(genClass)) {

			if (ecoreFeature.getName().equals(
				duplicateGenFeature.getEcoreFeature().getName())) {

				return duplicateGenFeature;
			}
		}

		return null;
	}

	@Override
	public GenOperation findGenOperation(EOperation ecoreOperation) {
		org.eclipse.emf.codegen.ecore.genmodel.GenClass genClass = findGenClass(Generator
			.getEcoreContainingClass(ecoreOperation));

		genOperationsLoop : for (GenOperation duplicateGenOperation : UML2GenModelUtil
			.getDuplicateGenOperations(genClass)) {

			if (ecoreOperation.getName().equals(
				duplicateGenOperation.getEcoreOperation().getName())
				&& ecoreOperation.getEParameters().size() == duplicateGenOperation
					.getEcoreOperation().getEParameters().size()) {

				for (int j = 0; j < ecoreOperation.getEParameters().size(); j++) {
					EParameter ecoreParameter = ecoreOperation.getEParameters()
						.get(j);

					if (!ecoreParameter
						.getEType()
						.getName()
						.equals(
							(duplicateGenOperation.getEcoreOperation()
								.getEParameters().get(j)).getEType().getName())) {

						continue genOperationsLoop;
					}
				}

				return duplicateGenOperation;
			}
		}

		return null;
	}

	public boolean isDerivedUnionListType(GenFeature genFeature) {

		if (UML2GenModelUtil.isUnion(genFeature) && genFeature.isListType()) {

			if (UML2GenModelUtil.isDuplicate(genFeature)
				&& !UML2GenModelUtil.isRedefinition(genFeature)) {

				return false;
			}

			for (GenFeature subsetGenFeature : getSubsetGenFeatures(genFeature)) {

				if (UML2GenModelUtil.isDuplicate(subsetGenFeature)
					&& !UML2GenModelUtil.isRedefinition(subsetGenFeature)) {

					return false;
				}
			}

			return true;
		}

		return false;
	}

	public List<GenFeature> getUnionGenFeatures() {
		List<GenFeature> unionGenFeatures = new UniqueEList.FastCompare<GenFeature>();

		for (GenFeature duplicateGenFeature : getDuplicateGenFeatures()) {

			if (UML2GenModelUtil.isUnion(duplicateGenFeature)) {
				unionGenFeatures.add(duplicateGenFeature);
			}

			for (GenFeature subsettedGenFeature : UML2GenModelUtil
				.getSubsettedGenFeatures(duplicateGenFeature)) {

				if (UML2GenModelUtil.isUnion(subsettedGenFeature)) {
					unionGenFeatures.add(subsettedGenFeature);
				}
			}
		}

		return unionGenFeatures;
	}

	public List<GenFeature> getImplementedUnionGenFeatures() {
		return getImplementedGenFeatures(new GenFeatureFilter() {

			public boolean accept(GenFeature genFeature) {
				return UML2GenModelUtil.isUnion(genFeature)
					&& !isRedefined(genFeature);
			}
		});
	}

	public boolean isSuperset(GenFeature genFeature) {
		final EStructuralFeature ecoreFeature = genFeature.getEcoreFeature();

		return !genFeature.isDerived()
			&& !collectGenFeatures(null, getAllDuplicateGenFeatures(),
				new GenFeatureFilter() {

					public boolean accept(GenFeature genFeature) {
						return Generator.getSubsettedEcoreFeatures(
							genFeature.getEcoreFeature())
							.contains(ecoreFeature);
					}
				}).isEmpty();
	}

	public List<GenFeature> getSupersetGenFeatures() {
		List<GenFeature> supersetGenFeatures = new UniqueEList.FastCompare<GenFeature>();

		for (GenFeature duplicateGenFeature : getDuplicateGenFeatures()) {

			if (isSuperset(duplicateGenFeature)) {
				supersetGenFeatures.add(duplicateGenFeature);
			}

			for (GenFeature subsettedGenFeature : UML2GenModelUtil
				.getSubsettedGenFeatures(duplicateGenFeature)) {

				if (isSuperset(subsettedGenFeature)) {
					supersetGenFeatures.add(subsettedGenFeature);
				}
			}
		}

		return supersetGenFeatures;
	}

	public List<GenFeature> getSubsetGenFeatures(GenFeature supersetGenFeature) {
		return getSubsetGenFeatures(supersetGenFeature, true);
	}

	public List<GenFeature> getSubsetGenFeatures(GenFeature supersetGenFeature,
			boolean includeDerived) {
		return getSubsetGenFeatures(supersetGenFeature, includeDerived, true);
	}

	public List<GenFeature> getSubsetGenFeatures(GenFeature supersetGenFeature,
			boolean includeDerived, boolean includeListType) {
		Map<String, GenFeature> subsetGenFeatures = new LinkedHashMap<String, GenFeature>();

		final EStructuralFeature supersetEcoreFeature = supersetGenFeature
			.getEcoreFeature();

		for (GenFeature duplicateGenFeature : getAllDuplicateGenFeatures()) {

			if (Generator.getSubsettedEcoreFeatures(
				duplicateGenFeature.getEcoreFeature()).contains(
				supersetEcoreFeature)
				&& (includeDerived || !duplicateGenFeature.isDerived())
				&& (includeListType || !duplicateGenFeature.isListType())) {

				subsetGenFeatures.put(duplicateGenFeature.getName(),
					duplicateGenFeature);
			}
		}

		return new ArrayList<GenFeature>(subsetGenFeatures.values());
	}

	public List<GenFeature> getIsSetSubsetGenFeatures(GenFeature unionGenFeature) {
		return collectGenFeatures(null, getSubsetGenFeatures(unionGenFeature),
			new GenFeatureFilter() {

				public boolean accept(GenFeature genFeature) {
					return !getExtendedGenFeatures().contains(genFeature);
				}
			});
	}

	public List<GenFeature> getSubsetGenFeatures() {
		return collectGenFeatures(null, getDuplicateGenFeatures(),
			new GenFeatureFilter() {

				public boolean accept(GenFeature genFeature) {
					return UML2GenModelUtil.isSubset(genFeature);
				}
			});
	}

	public List<GenFeature> getImplementedSubsetGenFeatures() {
		return getImplementedGenFeatures(new GenFeatureFilter() {

			public boolean accept(GenFeature genFeature) {
				return UML2GenModelUtil.isSubset(genFeature)
					&& !collectGenFeatures(null,
						getSupersetGenFeatures(genFeature),
						new GenFeatureFilter() {

							public boolean accept(GenFeature genFeature) {
								return !genFeature.isDerived();
							}
						}).isEmpty();
			}
		});
	}

	public List<GenFeature> getImplementedSubsetGenFeatures(
			final boolean listType) {
		return collectGenFeatures(null, getImplementedSubsetGenFeatures(),
			new GenFeatureFilter() {

				public boolean accept(GenFeature genFeature) {
					return listType == genFeature.isListType();
				}
			});
	}

	public String getSubsetFeatureAccessorArray(GenFeature supersetGenFeature) {
		return getSubsetFeatureAccessorArray(supersetGenFeature, false);
	}

	public String getSubsetFeatureAccessorArray(GenFeature supersetGenFeature,
			boolean includeDerived) {
		StringBuffer sb = new StringBuffer();

		Iterator<GenFeature> subsetGenFeatures = getSubsetGenFeatures(
			supersetGenFeature, includeDerived).iterator();

		if (subsetGenFeatures.hasNext()) {
			sb.append("new "); //$NON-NLS-1$
			sb.append(getGenModel().getImportedName(
				"org.eclipse.emf.ecore.EStructuralFeature")); //$NON-NLS-1$
			sb.append("[] {"); //$NON-NLS-1$

			while (subsetGenFeatures.hasNext()) {
				GenFeature subsetGenFeature = subsetGenFeatures.next();

				sb.append(subsetGenFeature.getQualifiedFeatureAccessor());

				if (subsetGenFeatures.hasNext()) {
					sb.append(", "); //$NON-NLS-1$
				}
			}

			sb.append("}"); //$NON-NLS-1$
		} else {
			sb.append("null"); //$NON-NLS-1$
		}

		return sb.toString();
	}

	public String getSubsetFeatureIDArray(GenFeature supersetGenFeature) {
		return getSubsetFeatureIDArray(supersetGenFeature, false);
	}

	public String getSubsetFeatureIDArray(GenFeature supersetGenFeature,
			boolean includeDerived) {
		StringBuffer sb = new StringBuffer();

		Iterator<GenFeature> subsetGenFeatures = getSubsetGenFeatures(
			supersetGenFeature, includeDerived).iterator();

		if (subsetGenFeatures.hasNext()) {
			sb.append("new int[] {"); //$NON-NLS-1$

			while (subsetGenFeatures.hasNext()) {
				GenFeature subsetGenFeature = subsetGenFeatures.next();

				sb.append(getQualifiedFeatureID(subsetGenFeature));

				if (subsetGenFeatures.hasNext()) {
					sb.append(", "); //$NON-NLS-1$
				}
			}

			sb.append("}"); //$NON-NLS-1$			
		} else {
			sb.append("null"); //$NON-NLS-1$
		}

		return sb.toString();
	}

	public List<GenFeature> getSupersetGenFeatures(GenFeature subsetGenFeature) {
		return getSupersetGenFeatures(subsetGenFeature, true);
	}

	public List<GenFeature> getSupersetGenFeatures(GenFeature subsetGenFeature,
			boolean includeDerived) {
		return getSupersetGenFeatures(subsetGenFeature, includeDerived, true);
	}

	public List<GenFeature> getSupersetGenFeatures(GenFeature subsetGenFeature,
			final boolean includeDerived, final boolean includeListType) {
		return collectGenFeatures(null,
			UML2GenModelUtil.getSubsettedGenFeatures(subsetGenFeature),
			new GenFeatureFilter() {

				public boolean accept(GenFeature genFeature) {
					return (includeDerived || !genFeature.isDerived())
						&& (includeListType || !genFeature.isListType());
				}
			});
	}

	public List<GenFeature> getImplementedSupersetGenFeatures() {
		return getImplementedGenFeatures(new GenFeatureFilter() {

			public boolean accept(GenFeature genFeature) {
				return isSuperset(genFeature)
					&& !getSubsetGenFeatures(genFeature, false).isEmpty();
			}
		});
	}

	public List<GenFeature> getImplementedSupersetGenFeatures(
			final boolean listType) {
		return collectGenFeatures(null, getImplementedSupersetGenFeatures(),
			new GenFeatureFilter() {

				public boolean accept(GenFeature genFeature) {
					return listType == genFeature.isListType();
				}
			});
	}

	public String getSupersetFeatureAccessorArray(GenFeature subsetGenFeature) {
		StringBuffer sb = new StringBuffer();

		Iterator<GenFeature> supersetGenFeatures = getSupersetGenFeatures(
			subsetGenFeature, false).iterator();

		if (supersetGenFeatures.hasNext()) {
			sb.append("new "); //$NON-NLS-1$
			sb.append(getGenModel().getImportedName(
				"org.eclipse.emf.ecore.EStructuralFeature")); //$NON-NLS-1$
			sb.append("[] {"); //$NON-NLS-1$

			while (supersetGenFeatures.hasNext()) {
				GenFeature supersetGenFeature = supersetGenFeatures.next();

				sb.append(supersetGenFeature.getQualifiedFeatureAccessor());

				if (supersetGenFeatures.hasNext()) {
					sb.append(", "); //$NON-NLS-1$
				}
			}

			sb.append("}"); //$NON-NLS-1$
		} else {
			sb.append("null"); //$NON-NLS-1$
		}

		return sb.toString();
	}

	public String getSupersetFeatureIDArray(GenFeature subsetGenFeature) {
		StringBuffer sb = new StringBuffer();

		Iterator<GenFeature> supersetGenFeatures = getSupersetGenFeatures(
			subsetGenFeature, false).iterator();

		if (supersetGenFeatures.hasNext()) {
			sb.append("new int[] {"); //$NON-NLS-1$

			while (supersetGenFeatures.hasNext()) {
				GenFeature supersetGenFeature = supersetGenFeatures.next();

				sb.append(getQualifiedFeatureID(supersetGenFeature));

				if (supersetGenFeatures.hasNext()) {
					sb.append(", "); //$NON-NLS-1$
				}
			}

			sb.append("}"); //$NON-NLS-1$
		} else {
			sb.append("null"); //$NON-NLS-1$
		}

		return sb.toString();
	}

	public boolean isRedefined(GenFeature genFeature) {
		final EStructuralFeature ecoreFeature = genFeature.getEcoreFeature();

		return !collectGenFeatures(null, getAllDuplicateGenFeatures(),
			new GenFeatureFilter() {

				public boolean accept(GenFeature genFeature) {
					return Generator.getRedefinedEcoreFeatures(
						genFeature.getEcoreFeature()).contains(ecoreFeature);
				}
			}).isEmpty();
	}

	public List<GenFeature> getRedefinedGenFeatures() {
		List<GenFeature> redefinedGenFeatures = new UniqueEList.FastCompare<GenFeature>();

		for (GenFeature duplicateGenFeature : getDuplicateGenFeatures()) {

			if (isRedefined(duplicateGenFeature)) {
				redefinedGenFeatures.add(duplicateGenFeature);
			}

			for (GenFeature redefinedGenFeature : UML2GenModelUtil
				.getRedefinedGenFeatures(duplicateGenFeature)) {

				if (!duplicateGenFeature.getName().equals(
					redefinedGenFeature.getName())) {

					redefinedGenFeatures.add(redefinedGenFeature);
				}
			}
		}

		return redefinedGenFeatures;
	}

	public List<GenFeature> getImplementedRedefinedGenFeatures() {
		return getImplementedGenFeatures(new GenFeatureFilter() {

			public boolean accept(GenFeature genFeature) {
				return isRedefined(genFeature);
			}
		});
	}

	public List<GenFeature> getRedefinitionGenFeatures(
			GenFeature redefinedGenFeature) {
		Map<String, GenFeature> redefinitionGenFeatures = new LinkedHashMap<String, GenFeature>();

		EStructuralFeature redefinedEcoreFeature = redefinedGenFeature
			.getEcoreFeature();

		for (GenFeature duplicateGenFeature : getAllDuplicateGenFeatures()) {

			if (Generator.getRedefinedEcoreFeatures(
				duplicateGenFeature.getEcoreFeature()).contains(
				redefinedEcoreFeature)) {

				if (!duplicateGenFeature.getName().equals(
					redefinedGenFeature.getName())) {

					redefinitionGenFeatures.put(duplicateGenFeature.getName(),
						duplicateGenFeature);
				}
			}
		}

		return new ArrayList<GenFeature>(redefinitionGenFeatures.values());
	}

	public boolean isRedefined(GenOperation genOperation) {
		final EOperation ecoreOperation = genOperation.getEcoreOperation();

		return !collectGenOperations(this, null,
			getAllDuplicateGenOperations(), new GenOperationFilter() {

				public boolean accept(GenOperation genOperation) {
					return Generator.getRedefinedEcoreOperations(
						genOperation.getEcoreOperation()).contains(
						ecoreOperation);
				}
			}).isEmpty();
	}

	public List<GenOperation> getRedefinedGenOperations() {
		List<GenOperation> redefinedGenOperations = new UniqueEList.FastCompare<GenOperation>();

		for (GenOperation duplicateGenOperation : getDuplicateGenOperations()) {

			if (isRedefined(duplicateGenOperation)) {
				redefinedGenOperations.add(duplicateGenOperation);
			}

			for (GenOperation redefinedGenOperation : UML2GenModelUtil
				.getRedefinedGenOperations(duplicateGenOperation)) {

				if (!(duplicateGenOperation.getName() + duplicateGenOperation
					.getParameterTypes("")).equals(redefinedGenOperation //$NON-NLS-1$
					.getName() + redefinedGenOperation.getParameterTypes(""))) { //$NON-NLS-1$

					redefinedGenOperations.add(redefinedGenOperation);
				}
			}
		}

		return redefinedGenOperations;
	}

	public List<GenOperation> getImplementedRedefinedGenOperations() {
		return getImplementedGenOperations(new CollidingGenOperationFilter() {

			@Override
			public boolean accept(GenOperation genOperation) {
				return super.accept(genOperation) && isRedefined(genOperation);
			}
		});
	}

	public List<GenOperation> getRedefinitionGenOperations(
			GenOperation redefinedGenOperation) {
		Map<String, GenOperation> redefinitionGenOperations = new LinkedHashMap<String, GenOperation>();

		EOperation redefinedEcoreOperation = redefinedGenOperation
			.getEcoreOperation();

		for (GenOperation duplicateGenOperation : getAllDuplicateGenOperations()) {

			if (Generator.getRedefinedEcoreOperations(
				duplicateGenOperation.getEcoreOperation()).contains(
				redefinedEcoreOperation)) {

				if (!(duplicateGenOperation.getName() + duplicateGenOperation
					.getParameterTypes("")).equals(redefinedGenOperation //$NON-NLS-1$
					.getName() + redefinedGenOperation.getParameterTypes(""))) { //$NON-NLS-1$

					redefinitionGenOperations.put(
						duplicateGenOperation.getName(), duplicateGenOperation);
				}
			}
		}

		return new ArrayList<GenOperation>(redefinitionGenOperations.values());
	}

	public List<GenFeature> getKeyGenFeatures() {
		return getKeyGenFeatures(true);
	}

	public List<GenFeature> getKeyGenFeatures(final boolean includeContains) {
		return collectGenFeatures(null, getAllGenFeatures(),
			new GenFeatureFilter() {

				public boolean accept(GenFeature genFeature) {
					return UML2GenModelUtil.isKey(genFeature)
						&& !genFeature.isPrimitiveType()
						&& (includeContains || !genFeature.isContains());
				}
			});
	}

	public boolean isFactoryMethods(GenFeature genFeature) {
		return UML2GenModelUtil.isFactoryMethods(genFeature.getGenModel())
			&& genFeature.isChangeable()
			&& (genFeature.isEffectiveContains() || UML2GenModelUtil
				.isEffectiveContainsSubset(genFeature))
			&& getChildrenClasses(genFeature).size() > 0;
	}

	@Override
	public boolean isESetField(GenFeature genFeature) {
		return super.isESetField(genFeature)
			&& (!UML2GenModelUtil.isUnion(genFeature))
			&& !isRedefined(genFeature);
	}

	@Override
	public boolean isField(GenFeature genFeature) {
		return super.isField(genFeature)
			&& (!UML2GenModelUtil.isUnion(genFeature))
			&& !isRedefined(genFeature);
	}

	protected class CollidingGenOperationFilter
			extends
			org.eclipse.emf.codegen.ecore.genmodel.impl.GenClassImpl.CollidingGenOperationFilter {

		protected CollidingGenOperationFilter() {
			super();

			allGenFeatures = getAllDuplicateGenFeatures();
		}

	}

	@Override
	public List<GenFeature> getToStringGenFeatures() {
		return collectGenFeatures(null, super.getToStringGenFeatures(),
			new GenFeatureFilter() {

				public boolean accept(GenFeature genFeature) {
					return !isRedefined(genFeature);
				}
			});
	}

	@Override
	public List<GenFeature> getEGetGenFeatures() {
		final List<GenFeature> allGenFeatures = getAllGenFeatures();
		final List<GenFeature> extendedGenFeatures = getExtendedGenFeatures();

		if (getGenModel().isMinimalReflectiveMethods()) {
			return collectGenFeatures(null, getImplementedGenFeatures(null),
				new GenFeatureFilter() {

					public boolean accept(GenFeature genFeature) {

						if (UML2GenModelUtil.isDuplicate(genFeature)) {

							for (GenFeature redefinedGenFeature : UML2GenModelUtil
								.getRedefinedGenFeatures(genFeature)) {

								if (!extendedGenFeatures
									.contains(redefinedGenFeature)) {

									return allGenFeatures
										.contains(redefinedGenFeature);
								}
							}
						}
						return allGenFeatures.contains(genFeature)
							&& !extendedGenFeatures.contains(genFeature);
					}
				});
		} else {
			return super.getEGetGenFeatures();
		}
	}

	@Override
	public List<GenFeature> getESetGenFeatures() {
		final List<GenFeature> allGenFeatures = getAllGenFeatures();
		final List<GenFeature> extendedGenFeatures = getExtendedGenFeatures();

		if (getGenModel().isMinimalReflectiveMethods()) {
			return collectGenFeatures(null, getImplementedGenFeatures(null),
				new GenFeatureFilter() {

					public boolean accept(GenFeature genFeature) {

						if (UML2GenModelUtil.isDuplicate(genFeature)) {

							for (GenFeature redefinedGenFeature : UML2GenModelUtil
								.getRedefinedGenFeatures(genFeature)) {

								if (!extendedGenFeatures
									.contains(redefinedGenFeature)) {

									return genFeature.isChangeable()
										&& allGenFeatures
											.contains(redefinedGenFeature);
								}
							}
						}
						return genFeature.isChangeable()
							&& allGenFeatures.contains(genFeature)
							&& !extendedGenFeatures.contains(genFeature);
					}
				});
		} else {
			return super.getESetGenFeatures();
		}
	}

	public boolean hasOCLOperationBodies() {

		for (GenOperation genOperation : getAllGenOperations()) {

			if (UML2GenModelUtil.hasOCLBody(genOperation)) {
				return true;
			}
		}

		return false;
	}

}