/**

   * Returns as list that corresponds to {@link #getInterfaceExtends()}.

   * @since 2.8

   */

  List<String >getQualifiedInterfaceExtendsList();

import org.eclipse.emf.ecore.EOperation;

import org.eclipse.emf.ecore.EStructuralFeature;

import org.eclipse.emf.ecore.ETypeParameter;

  /**

   * Set up reasonable initial defaults.

   * @since 2.8

   */

  void initialize();

  /**

   * @since 2.8

   */

  GenTypeParameter findGenTypeParameter(ETypeParameter eTypeParameter);

  /**

   * @since 2.8

   */

  GenFeature findGenFeature(EStructuralFeature eStructuralFeature);

  /**

   * @since 2.8

   */

  GenOperation findGenOperation(EOperation eOperation);

import org.eclipse.core.resources.IProject;

import org.eclipse.core.resources.IWorkspace;

import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.jdt.core.IClasspathEntry;

import org.eclipse.jdt.core.IJavaProject;

import org.eclipse.jdt.core.JavaCore;

import org.eclipse.emf.ecore.EAnnotation;

import org.eclipse.emf.ecore.EAttribute;

import org.eclipse.emf.ecore.EModelElement;

import org.eclipse.emf.ecore.EOperation;

import org.eclipse.emf.ecore.ETypeParameter;

  @Override

  public GenFeature findGenFeature(EStructuralFeature feature)

  {

    return super.findGenFeature(feature);

  }

  @Override

  public GenOperation findGenOperation(EOperation operation)

  {

    return super.findGenOperation(operation);

  }

  public GenTypeParameter findGenTypeParameter(ETypeParameter eTypeParameter)

  {

    for (EObject eObject = eTypeParameter.eContainer(); eObject != null; eObject = eObject.eContainer())

    {

      if (eObject instanceof EOperation)

      {

        EOperation eOperation = (EOperation)eObject;

        int index = eOperation.getETypeParameters().indexOf(eTypeParameter);

        if (index != -1)

        {

          GenOperation genOperation = findGenOperation(eOperation);

          return genOperation.getGenTypeParameters().get(index);

        }

      }

      else if (eObject instanceof EClassifier)

      {

        EClassifier eClassifier = (EClassifier)eObject;

        int index = eClassifier.getETypeParameters().indexOf(eTypeParameter);

        if (index != -1)

        {

          GenClassifier genClassifier = findGenClassifier(eClassifier);

          return genClassifier.getGenTypeParameters().get(index);

        }

      }

    }

    return null;

  }

  public void initialize()

  {

    Resource resource = eResource();

    if (resource != null)

    {

      URI uri = resource.getURI();

      setModelDirectory(EclipseHelper.getModelDirectory(uri));

      setComplianceLevel(EclipseHelper.getComplianceLevel(uri));

    }

    setUpdateClasspath(false);

    setOperationReflection(true);

    setMinimalReflectiveMethods(true);

    setRootExtendsClass("org.eclipse.emf.ecore.impl.MinimalEObjectImpl$Container");

    GenPackage mainGenPackage = getMainGenPackage();

    setModelName(mainGenPackage.getPrefix());

    GenRuntimeVersion[] values = GenRuntimeVersion.values();

    setRuntimeVersion(values[values.length - 1]);

    handleAnnotations(this, mainGenPackage.getEcorePackage());

    for (TreeIterator<EObject> i = eAllContents(); i.hasNext();)

    {

      EObject content = i.next();

      if (content instanceof GenBase)

      {

        GenBase genBase = (GenBase)content;

        EModelElement eModelElement = genBase.getEcoreModelElement();

        if (eModelElement != null)

        {

          handleAnnotations(genBase, eModelElement);

        }

      }

    }

  }

  protected void handleAnnotations(GenBase genBase, EModelElement eModelElement)

  {

    EAnnotation eAnnotation = eModelElement.getEAnnotation(GenModelPackage.eNS_URI);

    if (eAnnotation != null)

    {

      EClass eClass = genBase.eClass();

      for (Map.Entry<String, String> entry : eAnnotation.getDetails())

      {

        EStructuralFeature eStructuralFeature = eClass.getEStructuralFeature(entry.getKey());

        if (eStructuralFeature instanceof EAttribute)

        {

          EAttribute eAttribute = (EAttribute)eStructuralFeature;

          genBase.eSet(eStructuralFeature, EcoreUtil.createFromString(eAttribute.getEAttributeType(), entry.getValue()));

        }

      }

    }

  }

  private static class EclipseHelper

  {

    static String getModelDirectory(URI uri)

    {

      if (EMFPlugin.IS_RESOURCES_BUNDLE_AVAILABLE)

      {

        try

        {

          IWorkspace workspace = ResourcesPlugin.getWorkspace();

          IProject project = workspace.getRoot().getProject(uri.segment(1));

          IJavaProject javaProject = JavaCore.create(project);

          IClasspathEntry[] classpath = javaProject.getRawClasspath();

          IClasspathEntry bestEntry = null;

          for (IClasspathEntry classpathEntry : classpath)

          {

            if (classpathEntry.getEntryKind() == IClasspathEntry.CPE_SOURCE)

            {

              // Look for the first entry that's Java source.

              if (bestEntry == null)

              {

                bestEntry = classpathEntry;

              }

              // If there's a src-gen entry, prefer that over all others.

              //

              else if (classpathEntry.getPath().toString().endsWith("src-gen"))

              {

                bestEntry = classpathEntry;

              }

            }

          }

          return bestEntry == null ? project.getFullPath() + "/src" : bestEntry.getPath().toString();

        }

        catch (Exception exception)

        {

          CodeGenEcorePlugin.INSTANCE.log(exception);

        }

      }

      return null;

    }

    static GenJDKLevel getComplianceLevel(URI uri)

    {

      if (EMFPlugin.IS_RESOURCES_BUNDLE_AVAILABLE)

      {

        try

        {

          IWorkspace workspace = ResourcesPlugin.getWorkspace();

          IProject project = workspace.getRoot().getProject(uri.segment(2));

          String complianceLevel = CodeGenUtil.EclipseUtil.getJavaComplianceLevel(project);

          if ("1.5".equals(complianceLevel))

          {

            return GenJDKLevel.JDK50_LITERAL;

          }

          else if ("1.6".equals(complianceLevel))

          {

            return GenJDKLevel.JDK60_LITERAL;

          }

          else if ("1.4".equals(complianceLevel))

          {

            return GenJDKLevel.JDK14_LITERAL;

          }

        }

        catch (Exception exception)

        {

          CodeGenEcorePlugin.INSTANCE.log(exception);

        }

      }

      return GenJDKLevel.JDK50_LITERAL;

    }

  }

import org.eclipse.emf.ecore.EModelElement;

  @Override

  public EModelElement getEcoreModelElement()

  {

    return getEcoreTypeParameter();

  }

import java.lang.reflect.Method;

import org.eclipse.core.resources.IProject;

import org.eclipse.emf.common.notify.impl.AdapterImpl;

    ResourceSet resourceSet = null;

    try

    {

      Class<?> xtextResourceSetClass = CommonPlugin.loadClass("org.eclipse.xtext", "org.eclipse.xtext.resource.XtextResourceSet");

      resourceSet = (ResourceSet)xtextResourceSetClass.newInstance();

      class EditingDomainProvider extends AdapterImpl implements IEditingDomainProvider

      {

        public EditingDomain getEditingDomain()

        {

          return editingDomain;

        }

        @Override

        public boolean isAdapterForType(Object type)

        {

          return IEditingDomainProvider.class.equals(type);

        }

      }

      resourceSet.eAdapters().add(new EditingDomainProvider());

    }

    catch (Exception e)

    {

      e.printStackTrace();

      // ignore missing Xtext

    }

    try

    {

      ResourceSet resourceSet = editingDomain.getResourceSet();

      Method setClasspathURIContextMethod = resourceSet.getClass().getMethod("setClasspathURIContext", Object.class);

      Class<?> javaCoreClass = CommonPlugin.loadClass("org.eclipse.jdt.core", "org.eclipse.jdt.core.JavaCore");

      IProject project = ((IFileEditorInput)editorInput).getFile().getProject();

      Method createMethod = javaCoreClass.getMethod("create", IProject.class);

      Object javaProject = createMethod.invoke(null, project);

      setClasspathURIContextMethod.invoke(resourceSet, javaProject);

    }

    catch (Exception e)

    {

      e.printStackTrace();

      // ignore missing Xtext

    }