/**

   * Determines whether the given non-wildcard import should be added.

   * By default, this returns false if the short name is a built-in Java language type name.

   * @since 2.8

   */

  protected boolean shouldImport(String packageName, String shortName, String importName)

  {

    return !CodeGenUtil.isJavaDefaultType(shortName);

  }

  /**

   * 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;

    }

  }

      // These are used packages upon for which there is a cyclic dependency.

      // So they're not really simple dependencies.

      //

      List<GenPackage> nonSimpleDependencies = new ArrayList<GenPackage>(initializationDependencies);

      nonSimpleDependencies.retainAll(initializationDependencies);

      simpleDependencies.removeAll(nonSimpleDependencies);

      collectPackages(interDependencies, nonSimpleDependencies, -1);

      for (GenPackage genPackage : nonSimpleDependencies)

      {

        if (genPackage.isLoadedInitialization())

        {

          loadInterDependencies.add(genPackage);

        }

        else

        {

          buildInterDependencies.add(genPackage);

        }

      }

import org.eclipse.emf.ecore.EModelElement;

  @Override

  public EModelElement getEcoreModelElement()

  {

    return getEcoreTypeParameter();

  }

_UI_ConversionDelegateRegistry_extensionpoint = Conversion Delegate Factory Registry

   <extension-point id="conversion_delegate" name="%_UI_ConversionDelegateRegistry_extensionpoint" schema="schema/conversion_delegate.exsd"/>

<?xml version='1.0' encoding='UTF-8'?>

<!-- Schema file written by PDE -->

<schema targetNamespace="org.eclipse.emf.ecore" xmlns="http://www.w3.org/2001/XMLSchema">

<annotation>

      <appInfo>

         <meta.schema plugin="org.eclipse.emf.ecore" id="conversion_delegate" name="Conversion Delegate Factory Registry"/>

      </appInfo>

      <documentation>

         This extension point is used to define a factory for conversion delegates whose type is identified by a URI. The global EMF conversion delegate factory registry, <samp>EDataType.Internal.ConversionDelegate.Factory.Registry.INSTANCE</samp>, is used to record the registration.

      </documentation>

   </annotation>

   <element name="extension">

      <annotation>

         <appInfo>

            <meta.element />

         </appInfo>

      </annotation>

      <complexType>

         <sequence>

            <element ref="factory" minOccurs="1" maxOccurs="unbounded"/>

         </sequence>

         <attribute name="point" type="string" use="required">

            <annotation>

               <documentation>

                  A fully qualified identifier of the target extension point.

               </documentation>

            </annotation>

         </attribute>

         <attribute name="id" type="string">

            <annotation>

               <documentation>

                  An optional identifier of the extension instance.

               </documentation>

            </annotation>

         </attribute>

         <attribute name="name" type="string">

            <annotation>

               <documentation>

                  An optional name of the extension instance.

               </documentation>

            </annotation>

         </attribute>

      </complexType>

   </element>

   <element name="factory">

      <annotation>

         <appInfo>

            <meta.element labelAttribute="id"/>

         </appInfo>

      </annotation>

      <complexType>

         <attribute name="uri" type="string" use="required">

            <annotation>

               <documentation>

                  A URI identifying the type of conversion delegates that can be created by the factory.

               </documentation>

            </annotation>

         </attribute>

         <attribute name="class" type="string" use="required">

            <annotation>

               <documentation>

                  The fully qualified name of a Java class implementing <samp>org.eclipse.emf.ecore.EDataType.Internal.Delegate.Factory</samp>.

               </documentation>

               <appInfo>

                  <meta.attribute kind="java" basedOn="org.eclipse.emf.ecore.EDataType.Internal.ConversionDelegate.Factory"/>

               </appInfo>

            </annotation>

         </attribute>

      </complexType>

   </element>

   <annotation>

      <appInfo>

         <meta.section type="since"/>

      </appInfo>

      <documentation>

         2.8.0

      </documentation>

   </annotation>

   <annotation>

      <appInfo>

         <meta.section type="examples"/>

      </appInfo>

      <documentation>

         Following is an example of how an conversion delegate factory can be registered: 

<pre>

  <extension point="org.eclipse.emf.ecore.conversion_delegate" >

    <factory uri="http://www.eclipse.org/emf/2002/Ecore/Javascript" class="org.eclipse.emf.js4emf.ecore.internal.delegates.JavascriptDelegateFactory"/> 

  </extension>

</pre>

      </documentation>

   </annotation>

   <annotation>

      <appInfo>

         <meta.section type="apiInfo"/>

      </appInfo>

      <documentation>

         The value of the class attribute must represent a class that implements <samp>org.eclipse.emf.ecore.EDataType.Internal.ConversionDelegate.Factory</samp> and has a no argument contructor.

<p>

A conversion delegate factory can be also registered from the source code with the <samp>EDataType.Internal.ConversionDelegate.Factory.Registry.INSTANCE</samp> as follows:

</p>

<pre>

  EDataType.Internal.ConversionDelegate.Factory.Registry.INSTANCE.put("http://www.eclipse.org/emf/2002/Ecore/Javascript", new JavascriptDelegateFactory());

</pre>

      </documentation>

   </annotation>

   <annotation>

      <appInfo>

         <meta.section type="copyright"/>

      </appInfo>

      <documentation>

         Copyright (c) 2011 Hallvard Traetteberg and others.<br>

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 <a 

href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>

      </documentation>

   </annotation>

</schema>

import java.util.HashMap;

import java.util.Map;

  /**

   * Internal API implemented by all data types.

   * @since 2.8

   */

  interface Internal

  {

    /**

     * An API for converting values of the data type to and from a string representation.

     */

    interface ConversionDelegate

    {

      /**

       * A factory for creating conversion delegates.

       */

      interface Factory

      {

        /**

         * Creates a conversion delegate for the given EDataType.

         * @param eDataType the EDataType for which a conversion delegate is to be created.

         * @return a new conversion delegate for the given EDataType.

         */

        ConversionDelegate createConversionDelegate(EDataType eDataType);

        /**

         * A <code>Factory</code> wrapper that is used by the {@link Factory.Registry}.

         */

        interface Descriptor

        {

          Factory getFactory();

        }

        /**

         * A registry of factories for creating conversion delegates.

         */

        interface Registry extends Map<String, Object>

        {

          Registry INSTANCE = new Impl();

          Factory getFactory(String uri);

          class Impl extends HashMap<String, Object> implements Registry

          {

            private static final long serialVersionUID = 1L;

            @Override

            public Object get(Object key)

            {

              Object factory = super.get(key);

              if (factory instanceof Descriptor)

              {

                Descriptor factoryDescriptor = (Descriptor)factory;

                factory = factoryDescriptor.getFactory();

                put((String)key, factory);

                return factory;

              }

              else

              {

                return factory;

              }

            }

            public Factory getFactory(String uri)

            {

              return (Factory)get(uri);

            }

          }

        }

      }

      /**

       * Converts a value of the data type to a string literal.

       * @param value the value to be converted.

       * @return the literal representation of the value.

       */

      String convertToString(Object value);

      /**

       * Creates a value of the data type from a string literal.

       * @param literal the string literal to be converted.

       * @return the value of the literal representation.

       */

      Object createFromString(String literal);

    }

    /**

     * Returns the delegate for this data type.

     * A default delegate implementation need not be available,

     * so this might <code>null</code>.

     * @return the delegate for this feature.

     */

    ConversionDelegate getConversionDelegate();

    /**

     * Sets the specialized delegate for this data type.

     * @param settingDelegate the specialized delegate.

     */

    void setConversionDelegate(ConversionDelegate conversionDelegate);

  }

import java.util.List;

import org.eclipse.emf.ecore.util.EcoreUtil;

  protected ConversionDelegate conversionDelegate;

  protected boolean conversionDelegateIsSet;

  public ConversionDelegate getConversionDelegate()

  {

    if (conversionDelegate == null)

    {

      List<String> conversionDelegates = EcoreUtil.getConversionDelegates(getEPackage());

      if (!conversionDelegates.isEmpty())

      {

        for (String eDataTypeDelegateUri : conversionDelegates)

        {

          String body = EcoreUtil.getAnnotation(this, eDataTypeDelegateUri, "createFromString");

          if (body != null)

          {

            EDataType.Internal.ConversionDelegate.Factory eDataTypeDelegateFactory = EcoreUtil.getConversionDelegateFactory(this);

            conversionDelegate = eDataTypeDelegateFactory.createConversionDelegate(this);

            conversionDelegateIsSet = true;

          }

        }

      }

    }

    return conversionDelegate;

  }

  public void setConversionDelegate(ConversionDelegate conversionDelegate)

  {

    this.conversionDelegate = conversionDelegate;

  }

    EDataType.Internal.ConversionDelegate conversionDelegate = ((EDataType.Internal)eDataType).getConversionDelegate();

    if (conversionDelegate != null)

    {

      return conversionDelegate.createFromString(stringValue);

    }

    EDataType.Internal.ConversionDelegate conversionDelegate = ((EDataType.Internal)eDataType).getConversionDelegate();

    if (conversionDelegate != null)

    {

      return conversionDelegate.convertToString(objectValue);

    }

/**

 * <copyright>

 *

 * Copyright (c) 2011 Hallvard Traetteberg 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: 

 *   Hallvard Traetteberg - Initial API and implementation

 *

 * </copyright>

 *

 * $Id$

 */

package org.eclipse.emf.ecore.plugin;

import org.eclipse.core.runtime.IConfigurationElement;

import org.eclipse.core.runtime.Platform;

import org.eclipse.emf.ecore.EDataType;

/**

 * A plugin extension reader that populates the

 * {@link org.eclipse.emf.ecore.util.EDataType.ConversionDelegate.Factory.Registry#INSTANCE global} EDataType delegate factory registry.

 * Clients are not expected to use this class directly.

 */

class ConversionDelegateFactoryRegistryReader extends RegistryReader

{

  static class ConversionDelegateFactoryDescriptor extends PluginClassDescriptor implements EDataType.Internal.ConversionDelegate.Factory.Descriptor

  {

    protected EDataType.Internal.ConversionDelegate.Factory factory;

    public ConversionDelegateFactoryDescriptor(IConfigurationElement e, String attrName)

    {

      super(e, attrName);

    }

    public EDataType.Internal.ConversionDelegate.Factory getFactory()

    {

      if (factory == null)

      {

        factory = (EDataType.Internal.ConversionDelegate.Factory)createInstance();

      }

      return factory;

    }

  }

  static final String TAG_FACTORY = "factory";

  static final String ATT_URI = "uri";

  static final String ATT_CLASS = "class";

  public ConversionDelegateFactoryRegistryReader()

  {

    super(Platform.getExtensionRegistry(), EcorePlugin.getPlugin().getBundle().getSymbolicName(), EcorePlugin.CONVERSION_DELEGATE_PPID);

  }

  @Override

  protected boolean readElement(IConfigurationElement element, boolean add)

  {

    if (element.getName().equals(TAG_FACTORY))

    {

      String uri = element.getAttribute(ATT_URI);

      if (uri == null)

      {

        logMissingAttribute(element, ATT_URI);

      }

      else if (element.getAttribute(ATT_CLASS) == null)

      {

        logMissingAttribute(element, ATT_CLASS);

      }

      else if (add)

      {

        Object previous = EDataType.Internal.ConversionDelegate.Factory.Registry.INSTANCE.put(uri, new ConversionDelegateFactoryDescriptor(element, ATT_CLASS));

        if (previous instanceof ConversionDelegateFactoryDescriptor)

        {

          ConversionDelegateFactoryDescriptor descriptor = (ConversionDelegateFactoryDescriptor)previous;

          EcorePlugin.INSTANCE.log("Both '" + descriptor.element.getContributor().getName() + "' and '" + element.getContributor().getName() + "' register a conversion delegate factory for '" + uri + "'");

        }

        return true;

      }

      else

      {

        EDataType.Internal.ConversionDelegate.Factory.Registry.INSTANCE.remove(uri);

        return true;

      }

    }

    return false;

  }

}

  public static final String CONVERSION_DELEGATE_PPID = "conversion_delegate";

  /**

   * @since 2.8

   */

  public static List<String> getConversionDelegates(EPackage ePackage)

  {

    EAnnotation eAnnotation = ePackage.getEAnnotation(EcorePackage.eNS_URI);

    if (eAnnotation != null)

    {

      String eDataTypeDelegates = eAnnotation.getDetails().get("conversionDelegates");

      if (eDataTypeDelegates != null)

      {

        List<String> result = new ArrayList<String>();

        for (StringTokenizer stringTokenizer = new StringTokenizer(eDataTypeDelegates); stringTokenizer.hasMoreTokens();)

        {

          String eDataTypeDelegate = stringTokenizer.nextToken();

          result.add(eDataTypeDelegate);

        }

        return result;

      }

    }

    return Collections.emptyList();

  }

  public static void setConversionDelegates(EPackage ePackage, List<String> eDataTypeDelegates)

  {

    EAnnotation eAnnotation = ePackage.getEAnnotation(EcorePackage.eNS_URI);

    if (eDataTypeDelegates == null || eDataTypeDelegates.isEmpty())

    {

      if (eAnnotation != null)

      {

        eAnnotation.getDetails().remove("conversionDelegates");

      }

    }

    else

    {

      if (eAnnotation == null)

      {

        eAnnotation = EcoreFactory.eINSTANCE.createEAnnotation();

        eAnnotation.setSource(EcorePackage.eNS_URI);

        ePackage.getEAnnotations().add(eAnnotation);

      }

      StringBuffer value = new StringBuffer();

      for (Iterator<String> i = eDataTypeDelegates.iterator(); i.hasNext();)

      {

        value.append(i.next());

        if (i.hasNext())

        {

          value.append(' ');

        }

      }

      eAnnotation.getDetails().put("conversionDelegates", value.toString());

    }

  }

  /**

   * @since 2.8

   */

  public static EDataType.Internal.ConversionDelegate.Factory getConversionDelegateFactory(EDataType eDataType)

  {

    for (String eDataTypeDelegate : getConversionDelegates(eDataType.getEPackage()))

    {

      if (eDataType.getEAnnotation(eDataTypeDelegate) != null)

      {

        return EDataType.Internal.ConversionDelegate.Factory.Registry.INSTANCE.getFactory(eDataTypeDelegate);

      }

    }

    return null;

  }

      else

      {

        newObjectsToAttach.remove(eObject);

      }

    EList<Object> copy = null;

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

    }

import org.eclipse.emf.ecore.InternalEObject;

    /*

    */

    ts.addTest(new ChangeDescriptionReverseTest("testEight"));

      {

      ResourceSet finalResourceSet = new ResourceSetImpl();

      Resource changeDescriptionResource = finalResourceSet.createResource(URI.createURI("changes.change"));

      changeDescriptionResource.getContents().add(changeDescription);

      changeDescriptionResource.save(System.err, null);

      }

  public void testEight() throws Exception

  {

    new TestHelper()

      {

        Resource ecoreResource;

        EPackage ecorePackage;

        @Override

        void loadResources(ResourceSet resourceSet)

        {

          ecoreResource = resourceSet.getResource(URI.createURI("platform:/plugin/org.eclipse.emf.ecore/model/Ecore.ecore"), true);

          ecorePackage = (EPackage)ecoreResource.getContents().get(0);

          EAnnotation eAnnotation = EcoreFactory.eINSTANCE.createEAnnotation();

          ecorePackage.getEAnnotations().add(eAnnotation);

          eAnnotation.setSource(getName());

          EList<EObject> references = eAnnotation.getReferences();

          EObject eClassProxy = EcoreFactory.eINSTANCE.createEObject();

          ((InternalEObject)eClassProxy).eSetProxyURI(URI.createURI("platform:/plugin/org.eclipse.emf.ecore/model/Ecore.ecore#//EClass"));

          references.add(eClassProxy);

          EObject ePackageProxy = EcoreFactory.eINSTANCE.createEObject();

          ((InternalEObject)ePackageProxy).eSetProxyURI(URI.createURI("platform:/plugin/org.eclipse.emf.ecore/model/Ecore.ecore#//EPackage"));

          references.add(ePackageProxy);

        }

        @Override

        void makeChanges()

        {

          EList<EObject> references = ecorePackage.getEAnnotation(getName()).getReferences();

          references.clear();

          references.add(ecorePackage.getEClassifier("EClass"));

          references.add(ecorePackage.getEClassifier("EPackage"));

          EClass eClass = EcoreFactory.eINSTANCE.createEClass();

          eClass.setName("NewClass");

          EAnnotation eAnnotation = EcoreFactory.eINSTANCE.createEAnnotation();

          eAnnotation.getReferences().add(eClass);

          EPackage ePackage = EcoreFactory.eINSTANCE.createEPackage();

          ePackage.setName("NewPackage");

          ePackage.getEClassifiers().add(eClass);

          ecorePackage.getESubpackages().add(ePackage);

          ecorePackage.getEAnnotations().add(eAnnotation);

          ResourceSet resourceSet = ecoreResource.getResourceSet();

          resourceSet.createResource(URI.createURI("platform:/plugin/org.eclipse.emf.ecore/model/EPackage/NewPackage.ecore")).getContents().add(

            ePackage);

          resourceSet.createResource(URI.createURI("platform:/plugin/org.eclipse.emf.ecore/model/EClass/NewClass.ecore")).getContents().add(

            eClass);

        }

      }.doit();

  }