Java Examples for org.eclipse.emf.codegen.ecore.genmodel.GenModel

public void computeEPackages(Monitor monitor, ModelImporter modelImporter) throws Exception {
    IProject project = genModelFile.getProject();
    project.open(BasicMonitor.toIProgressMonitor(monitor));
    if (!project.hasNature(JavaCore.NATURE_ID) && oldGenModelVersion.getModelDirectory() != null) {
        project = project.getWorkspace().getRoot().getFolder(new Path(oldGenModelVersion.getModelDirectory())).getProject();
    }
    Collection<IFile> allGenModelFiles = new ArrayList<IFile>();
    Collection<IProject> allReferencedProjects = new ArrayList<IProject>();
    getAllReferencedProjects(allReferencedProjects, project.getDescription().getReferencedProjects());
    getAllReferencedProjects(allReferencedProjects, project.getDescription().getDynamicReferences());
    for (IProject referencedProject : allReferencedProjects) {
        getAllGenModelFiles(allGenModelFiles, referencedProject);
    }
    ResourceSet resourceSet = modelImporter.createResourceSet();
    for (IFile file : allGenModelFiles) {
        Resource resource = resourceSet.getResource(modelImporter.createFileURI(file.getFullPath().toString()), true);
        GenModel genModel = (GenModel) resource.getContents().get(0);
        externalGenModels.add(genModel);
        for (GenPackage genPackage : genModel.getGenPackages()) {
            determineExternalPackages(genPackage, modelImporter);
        }
    }
    // Iterate over all projects to look at the manifests.
    //
    List<String> allReferencedPluginIDs = new UniqueEList<String>();
    allReferencedProjects.add(project);
    for (IProject referencedProject : allReferencedProjects) {
        try {
            // Determine the required plugins.
            //
            URI manifestURI = URI.createURI(referencedProject.getFullPath() + "/META-INF/MANIFEST.MF");
            Manifest manifest = new Manifest(resourceSet.getURIConverter().createInputStream(manifestURI));
            String requires = manifest.getMainAttributes().getValue("Require-Bundle");
            if (requires != null) {
                ManifestElement[] elements = ManifestElement.parseHeader(Constants.REQUIRE_BUNDLE, requires);
                for (int j = 0; j < elements.length; ++j) {
                    // Include each required plugin of the starting project and the exported ones of all the required projects.
                    //
                    ManifestElement element = elements[j];
                    if (project == referencedProject || "reexport".equals(element.getDirective("visibility"))) {
                        String pluginID = element.getValue();
                        allReferencedPluginIDs.add(pluginID);
                    }
                }
            }
        } catch (IOException exception) {
        }
    }
    //
    for (int i = 0; i < allReferencedPluginIDs.size(); ++i) {
        // Determine the required plugins.
        //
        String pluginID = allReferencedPluginIDs.get(i);
        Bundle bundle = Platform.getBundle(pluginID);
        if (bundle != null) {
            // Ignore this for Eclipse 3.5 compatibility.
            //
            @SuppressWarnings("cast") String requires = (String) bundle.getHeaders().get(Constants.REQUIRE_BUNDLE);
            if (requires != null) {
                ManifestElement[] elements = ManifestElement.parseHeader(Constants.REQUIRE_BUNDLE, requires);
                for (int j = 0; j < elements.length; ++j) {
                    // Also add each required plugin for consideration in the loop.
                    //
                    ManifestElement element = elements[j];
                    String value = element.getValue();
                    if ("reexport".equals(element.getDirective("visibility"))) {
                        allReferencedPluginIDs.add(value);
                    }
                }
            }
        }
    }
    // Determine the inverse map from plugin IDs to their registered GenModel locations.
    //
    Map<String, List<URI>> allPluginsWithGenModels = new HashMap<String, List<URI>>();
    for (Map.Entry<String, URI> entry : EcorePlugin.getEPackageNsURIToGenModelLocationMap(true).entrySet()) {
        // If it's a platform plugin URI, include it in the map.
        //
        URI genModelLocation = entry.getValue();
        if (genModelLocation.isPlatformPlugin()) {
            List<URI> uris = allPluginsWithGenModels.get(genModelLocation.segment(1));
            if (uris == null) {
                uris = new UniqueEList<URI>();
            }
            uris.add(genModelLocation);
            allPluginsWithGenModels.put(genModelLocation.segment(1), uris);
        }
    }
    // Keep only the plugins that have GenModels for consideration.
    //
    allReferencedPluginIDs.retainAll(allPluginsWithGenModels.keySet());
    for (String pluginID : allReferencedPluginIDs) {
        //
        for (URI uri : allPluginsWithGenModels.get(pluginID)) {
            // Load the model and if it's not one already considered, e.g., a local version in the workspace, process its GenPackages.
            //
            Resource resource = resourceSet.getResource(uri, true);
            GenModel genModel = (GenModel) resource.getContents().get(0);
            if (externalGenModels.add(genModel)) {
                for (GenPackage genPackage : genModel.getGenPackages()) {
                    determineExternalPackages(genPackage, modelImporter);
                }
            }
        }
    }
    IPath targetFragmentRoot = analyzeProject(project);
    modelImporter.setModelPluginDirectory(targetFragmentRoot.toString());
    if (packageNameToEPackageMap.isEmpty()) {
        error(JavaImporterPlugin.INSTANCE.getString(foundJava ? "_UI_NoModelElementsInJava_message" : "_UI_NoModelElements_message"));
    }
    for (EPackage ePackage : packageNameToEPackageMap.values()) {
        modelImporter.getEPackages().add(ePackage);
        ModelImporter.EPackageImportInfo ePackageInfo = modelImporter.getEPackageImportInfo(ePackage);
        ePackageInfo.setPrefix(ePackageToPrefixMap.get(ePackage));
        for (Map.Entry<String, EPackage> entry : packageNameToEPackageMap.entrySet()) {
            if (entry.getValue() == ePackage) {
                String qualifiedPackageName = entry.getKey();
                if (qualifiedPackageName != null) {
                    int index = qualifiedPackageName.lastIndexOf(".");
                    if (index != -1) {
                        ePackageInfo.setBasePackage(qualifiedPackageName.substring(0, index));
                    }
                }
                break;
            }
        }
    }
}

public void computeEPackages(Monitor monitor, ModelImporter modelImporter) throws Exception {
    IProject project = genModelFile.getProject();
    project.open(BasicMonitor.toIProgressMonitor(monitor));
    if (!project.hasNature(JavaCore.NATURE_ID) && oldGenModelVersion.getModelDirectory() != null) {
        project = project.getWorkspace().getRoot().getFolder(new Path(oldGenModelVersion.getModelDirectory())).getProject();
    }
    Collection<IFile> allGenModelFiles = new ArrayList<IFile>();
    Collection<IProject> allReferencedProjects = new ArrayList<IProject>();
    getAllReferencedProjects(allReferencedProjects, project.getDescription().getReferencedProjects());
    getAllReferencedProjects(allReferencedProjects, project.getDescription().getDynamicReferences());
    for (IProject referencedProject : allReferencedProjects) {
        getAllGenModelFiles(allGenModelFiles, referencedProject);
    }
    ResourceSet resourceSet = modelImporter.createResourceSet();
    for (IFile file : allGenModelFiles) {
        Resource resource = resourceSet.getResource(modelImporter.createFileURI(file.getFullPath().toString()), true);
        GenModel genModel = (GenModel) resource.getContents().get(0);
        externalGenModels.add(genModel);
        for (GenPackage genPackage : genModel.getGenPackages()) {
            determineExternalPackages(genPackage, modelImporter);
        }
    }
    // Iterate over all projects to look at the manifests.
    //
    List<String> allReferencedPluginIDs = new UniqueEList<String>();
    allReferencedProjects.add(project);
    for (IProject referencedProject : allReferencedProjects) {
        try {
            // Determine the required plugins.
            //
            URI manifestURI = URI.createURI(referencedProject.getFullPath() + "/META-INF/MANIFEST.MF");
            Manifest manifest = new Manifest(resourceSet.getURIConverter().createInputStream(manifestURI));
            String requires = manifest.getMainAttributes().getValue("Require-Bundle");
            if (requires != null) {
                ManifestElement[] elements = ManifestElement.parseHeader(Constants.REQUIRE_BUNDLE, requires);
                for (int j = 0; j < elements.length; ++j) {
                    // Include each required plugin of the starting project and the exported ones of all the required projects.
                    //
                    ManifestElement element = elements[j];
                    if (project == referencedProject || "reexport".equals(element.getDirective("visibility"))) {
                        String pluginID = element.getValue();
                        allReferencedPluginIDs.add(pluginID);
                    }
                }
            }
        } catch (IOException exception) {
        }
    }
    //
    for (int i = 0; i < allReferencedPluginIDs.size(); ++i) {
        // Determine the required plugins.
        //
        String pluginID = allReferencedPluginIDs.get(i);
        Bundle bundle = Platform.getBundle(pluginID);
        if (bundle != null) {
            // Ignore this for Eclipse 3.5 compatibility.
            //
            @SuppressWarnings("cast") String requires = (String) bundle.getHeaders().get(Constants.REQUIRE_BUNDLE);
            if (requires != null) {
                ManifestElement[] elements = ManifestElement.parseHeader(Constants.REQUIRE_BUNDLE, requires);
                for (int j = 0; j < elements.length; ++j) {
                    // Also add each required plugin for consideration in the loop.
                    //
                    ManifestElement element = elements[j];
                    String value = element.getValue();
                    if ("reexport".equals(element.getDirective("visibility"))) {
                        allReferencedPluginIDs.add(value);
                    }
                }
            }
        }
    }
    // Determine the inverse map from plugin IDs to their registered GenModel locations.
    //
    Map<String, List<URI>> allPluginsWithGenModels = new HashMap<String, List<URI>>();
    for (Map.Entry<String, URI> entry : EcorePlugin.getEPackageNsURIToGenModelLocationMap().entrySet()) {
        // If it's a platform plugin URI, include it in the map.
        //
        URI genModelLocation = entry.getValue();
        if (genModelLocation.isPlatformPlugin()) {
            List<URI> uris = allPluginsWithGenModels.get(genModelLocation.segment(1));
            if (uris == null) {
                uris = new UniqueEList<URI>();
            }
            uris.add(genModelLocation);
            allPluginsWithGenModels.put(genModelLocation.segment(1), uris);
        }
    }
    // Keep only the plugins that have GenModels for consideration.
    //
    allReferencedPluginIDs.retainAll(allPluginsWithGenModels.keySet());
    for (String pluginID : allReferencedPluginIDs) {
        //
        for (URI uri : allPluginsWithGenModels.get(pluginID)) {
            // Load the model and if it's not one already considered, e.g., a local version in the workspace, process its GenPackages.
            //
            Resource resource = resourceSet.getResource(uri, true);
            GenModel genModel = (GenModel) resource.getContents().get(0);
            if (externalGenModels.add(genModel)) {
                for (GenPackage genPackage : genModel.getGenPackages()) {
                    determineExternalPackages(genPackage, modelImporter);
                }
            }
        }
    }
    IPath targetFragmentRoot = analyzeProject(project);
    modelImporter.setModelPluginDirectory(targetFragmentRoot.toString());
    if (packageNameToEPackageMap.isEmpty()) {
        error(JavaImporterPlugin.INSTANCE.getString(foundJava ? "_UI_NoModelElementsInJava_message" : "_UI_NoModelElements_message"));
    }
    for (EPackage ePackage : packageNameToEPackageMap.values()) {
        modelImporter.getEPackages().add(ePackage);
        ModelImporter.EPackageImportInfo ePackageInfo = modelImporter.getEPackageImportInfo(ePackage);
        ePackageInfo.setPrefix(ePackageToPrefixMap.get(ePackage));
        for (Map.Entry<String, EPackage> entry : packageNameToEPackageMap.entrySet()) {
            if (entry.getValue() == ePackage) {
                String qualifiedPackageName = entry.getKey();
                if (qualifiedPackageName != null) {
                    int index = qualifiedPackageName.lastIndexOf(".");
                    if (index != -1) {
                        ePackageInfo.setBasePackage(qualifiedPackageName.substring(0, index));
                    }
                }
                break;
            }
        }
    }
}

protected EPackage getInputEPackage(IStructuredSelection structuredSelection) {
    Object element = structuredSelection.getFirstElement();
    if (element instanceof IFile) {
        IFile file = (IFile) element;
        XtextResourceSet resourceSet = new XtextResourceSet();
        IProject project = file.getProject();
        resourceSet.setClasspathURIContext(JavaCore.create(project));
        resourceSet.getURIConverter().getURIMap().putAll(EcorePlugin.computePlatformURIMap());
        if ("ecore".equals(file.getFullPath().getFileExtension())) {
            return (EPackage) EcoreUtil.getObjectByType(resourceSet.getResource(URI.createPlatformResourceURI(file.getFullPath().toString(), true), true).getContents(), EcorePackage.Literals.EPACKAGE);
        } else if ("genmodel".equals(file.getFullPath().getFileExtension())) {
            GenModel genModel = (GenModel) EcoreUtil.getObjectByType(resourceSet.getResource(URI.createPlatformResourceURI(file.getFullPath().toString(), true), true).getContents(), GenModelPackage.Literals.GEN_MODEL);
            if (genModel.getGenPackages().size() == 1) {
                return genModel.getGenPackages().get(0).getEcorePackage();
            }
        }
    }
    return null;
}

public static String adjustGenModel(GenModel genModel, GenDelegationKind featureDelegation) {
    StringBuilder builder = new StringBuilder();
    if (genModel.getFeatureDelegation() != featureDelegation) {
        genModel.setFeatureDelegation(featureDelegation);
        //$NON-NLS-1$
        builder.append(Messages.getString("CDOMigratorUtil.4"));
        //$NON-NLS-1$
        builder.append(" ");
        builder.append(featureDelegation);
        //$NON-NLS-1$
        builder.append("\n");
    }
    if (!ROOT_EXTENDS_CLASS.equals(genModel.getRootExtendsClass())) {
        genModel.setRootExtendsClass(ROOT_EXTENDS_CLASS);
        //$NON-NLS-1$
        builder.append(Messages.getString("CDOMigratorUtil.6"));
        //$NON-NLS-1$
        builder.append(" ");
        builder.append(ROOT_EXTENDS_CLASS);
        //$NON-NLS-1$
        builder.append("\n");
    }
    if (!ROOT_EXTENDS_INTERFACE.equals(genModel.getRootExtendsInterface())) {
        genModel.setRootExtendsInterface(ROOT_EXTENDS_INTERFACE);
        //$NON-NLS-1$
        builder.append(Messages.getString("CDOMigratorUtil.8"));
        //$NON-NLS-1$
        builder.append(" ");
        builder.append(ROOT_EXTENDS_INTERFACE);
        //$NON-NLS-1$
        builder.append("\n");
    }
    EList<String> pluginVariables = genModel.getModelPluginVariables();
    if (!pluginVariables.contains(PLUGIN_VARIABLE)) {
        pluginVariables.add(PLUGIN_VARIABLE);
        //$NON-NLS-1$
        builder.append(Messages.getString("CDOMigratorUtil.10"));
        //$NON-NLS-1$
        builder.append(" ");
        builder.append(PLUGIN_VARIABLE);
        //$NON-NLS-1$
        builder.append("\n");
    }
    if (!PROVIDER_ROOT_EXTENDS_CLASS.equals(genModel.getProviderRootExtendsClass())) {
        genModel.setProviderRootExtendsClass(PROVIDER_ROOT_EXTENDS_CLASS);
        //$NON-NLS-1$
        builder.append(Messages.getString("CDOMigratorUtil.9"));
        //$NON-NLS-1$
        builder.append(" ");
        builder.append(PROVIDER_ROOT_EXTENDS_CLASS);
        //$NON-NLS-1$
        builder.append("\n");
    }
    IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
    IFolder modelFolder = root.getFolder(new Path(genModel.getModelDirectory()));
    IProject modelProject = modelFolder.getProject();
    if (!modelProject.exists()) {
        try {
            modelProject.create(new NullProgressMonitor());
            //$NON-NLS-1$ //$NON-NLS-2$
            builder.append(Messages.getString("CDOMigratorUtil.12") + "\n");
        } catch (CoreException ex) {
            throw new WrappedException(ex);
        }
    }
    if (!modelProject.isOpen()) {
        try {
            modelProject.open(new NullProgressMonitor());
            //$NON-NLS-1$ //$NON-NLS-2$
            builder.append(Messages.getString("CDOMigratorUtil.13") + "\n");
        } catch (CoreException ex) {
            throw new WrappedException(ex);
        }
    }
    return builder.length() == 0 ? null : builder.toString();
}

@Override
public EObject getModel() {
    EObject eObject = super.getModel();
    if (eObject instanceof EEFGenModel) {
        ResourceSet resourceSet = null;
        for (GenEditionContext context : ((EEFGenModel) eObject).getEditionContexts()) {
            PropertiesEditionContext propertiesEditionContext = context.getPropertiesEditionContext();
            if (propertiesEditionContext != null) {
                resourceSet = propertiesEditionContext.getModel().eResource().getResourceSet();
                Resource resource = resourceSet.getResource(URI.createPlatformPluginURI("org.eclipse.emf.ecore/model/XMLType.genmodel", true), true);
                if (!resource.getContents().isEmpty() && resource.getContents().get(0) instanceof GenModel) {
                    ((GenModel) resource.getContents().get(0)).reconcile();
                }
                ;
                propertiesEditionContext.getModel().reconcile();
            }
        }
        // reconcile all genmodels of the resourceSet
        if (resourceSet != null) {
            for (Resource resource : resourceSet.getResources()) {
                if (!resource.getContents().isEmpty() && resource.getContents().get(0) instanceof GenModel) {
                    ((GenModel) resource.getContents().get(0)).reconcile();
                }
                ;
            }
        }
    }
    // load 
    return eObject;
}

@Override
public void run() {
    generator.requestInitialize();
    LoopholeGeneratorOperation operation = new LoopholeGeneratorOperation(activeEditorPart.getSite().getShell());
    operation.setRootDiagnosticMessage(getText());
    GenModel genModel = null;
    GenGapModel genGapModel = null;
    Collection<?> selection = ((IStructuredSelection) getActiveEditorSelection()).toList();
    for (Object object : selection) {
        for (int i = 0; i < projectTypes.length; i++) {
            GenBase genBase = null;
            if (object instanceof GenGapModel) {
                genGapModel = (GenGapModel) object;
                genModel = genGapModel.getGenModel();
                genBase = genModel;
            }
            if (object instanceof GenGapPackage) {
                genBase = ((GenGapPackage) object).getGenPackage();
                genGapModel = ((GenGapPackage) object).getGenGapModel();
                genModel = genBase.getGenModel();
            }
            operation.addGeneratorAndArguments(generator, genBase, projectTypes[i].getType(), projectTypes[i].getName());
        }
    }
    operation.setGenGapModel(genGapModel);
    Set<IProject> projects = new HashSet<IProject>();
    Set<IWorkingSet> workingSets = new HashSet<IWorkingSet>();
    if (genModel != null) {
        IProject project = ResourcesPlugin.getWorkspace().getRoot().getFile(new Path(genModel.getModelDirectory())).getProject();
        if (project != null) {
            IWorkbench workbench = PlatformUI.getWorkbench();
            for (IWorkingSet workingSet : workbench.getWorkingSetManager().getAllWorkingSets()) {
                IAdaptable[] elements = workingSet.getElements();
                for (IAdaptable element : elements) {
                    if (project.equals(element.getAdapter(IProject.class))) {
                        workingSets.add(workingSet);
                        continue;
                    }
                }
            }
            if (!workingSets.isEmpty()) {
                for (int i = 0; i < projectTypes.length; i++) {
                    Object projectType = projectTypes[i].getType();
                    if (GenBaseGeneratorAdapter.EDIT_PROJECT_TYPE.equals(projectType)) {
                        IProject editProject = ResourcesPlugin.getWorkspace().getRoot().getFile(new Path(genModel.getEditDirectory())).getProject();
                        if (!editProject.exists()) {
                            projects.add(editProject);
                        }
                    }
                    if (GenBaseGeneratorAdapter.EDITOR_PROJECT_TYPE.equals(projectType)) {
                        IProject editorProject = ResourcesPlugin.getWorkspace().getRoot().getFile(new Path(genModel.getEditorDirectory())).getProject();
                        if (!editorProject.exists()) {
                            projects.add(editorProject);
                        }
                    }
                    if (GenBaseGeneratorAdapter.TESTS_PROJECT_TYPE.equals(projectType)) {
                        IProject testsProject = ResourcesPlugin.getWorkspace().getRoot().getFile(new Path(genModel.getTestsDirectory())).getProject();
                        if (!testsProject.exists()) {
                            projects.add(testsProject);
                        }
                    }
                }
            }
        }
    }
    //
    try {
        new ProgressMonitorDialog(activeEditorPart.getSite().getShell()).run(true, true, operation);
        if (!projects.isEmpty()) {
            for (IWorkingSet workingSet : workingSets) {
                List<IAdaptable> elements = new ArrayList<IAdaptable>(Arrays.asList(workingSet.getElements()));
                elements.addAll(projects);
                workingSet.setElements(workingSet.adaptElements(elements.toArray(new IAdaptable[elements.size()])));
            }
        }
    } catch (Exception exception) {
        GenModelEditPlugin.INSTANCE.log(exception);
    }
}

/**
   * This method checks if the genModel has a dynamic templates property and a
   * template directory set to projectName/templates
   * It also copies the ClassJava.jet from the core project.
   * it returns the a String containing the changes that has been done on genmodel.
   */
public String setGenModelTemplates(final GenModel gm, final boolean forceSave) {
    final StringBuffer changes = new StringBuffer();
    boolean _isDynamicTemplates = gm.isDynamicTemplates();
    boolean _not = (!_isDynamicTemplates);
    if (_not) {
        gm.setDynamicTemplates(true);
        changes.append("The dynamic template property must be set to true");
    }
    gm.setImportOrganizing(true);
    final String expectedTemplateDir = (("/" + this.projectName) + "/templates");
    final String currentTemplateDir = gm.getTemplateDirectory();
    boolean _equals = expectedTemplateDir.equals(currentTemplateDir);
    boolean _not_1 = (!_equals);
    if (_not_1) {
        gm.setTemplateDirectory(expectedTemplateDir);
        if (((!Objects.equal(currentTemplateDir, null)) && (currentTemplateDir.length() > 0))) {
            changes.append("\nThe  template directory must be changed :  \n");
            changes.append(("\n   Previous value was : " + currentTemplateDir));
            changes.append(("\n   New value is       : " + expectedTemplateDir));
        } else {
            changes.append(("The template directory has been set to : " + expectedTemplateDir));
        }
    }
    final IFile classJavajet = this.project.getFile((expectedTemplateDir + "/model/Class.javajet"));
    boolean _exists = classJavajet.exists();
    boolean _not_2 = (!_exists);
    if (_not_2) {
        final EMFPatternExtractor extractor = new EMFPatternExtractor(this.project, this.classPattern, this.interfacePattern);
        extractor.run();
        this.refreshWorkspace();
        changes.append("\nThe Class.javajet has been installed");
    }
    if (((changes.length() > 0) && forceSave)) {
        final Map<Object, Object> opt = new HashMap<Object, Object>();
        opt.put(Resource.OPTION_SAVE_ONLY_IF_CHANGED, Resource.OPTION_SAVE_ONLY_IF_CHANGED_MEMORY_BUFFER);
        opt.put(Resource.OPTION_LINE_DELIMITER, Resource.OPTION_LINE_DELIMITER_UNSPECIFIED);
        try {
            Resource _eResource = gm.eResource();
            _eResource.save(opt);
        } catch (final Throwable _t) {
            if (_t instanceof IOException) {
                final IOException e = (IOException) _t;
                Class<? extends GenerateDevStructure> _class = this.getClass();
                final Bundle bundle = FrameworkUtil.getBundle(_class);
                final ILog logger = Platform.getLog(bundle);
                String _symbolicName = bundle.getSymbolicName();
                Resource _eResource_1 = gm.eResource();
                String _plus = ("Unable to save the genModel in : " + _eResource_1);
                Status _status = new Status(IStatus.WARNING, _symbolicName, _plus, e);
                logger.log(_status);
            } else {
                throw Exceptions.sneakyThrow(_t);
            }
        }
    }
    return changes.toString();
}

/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
public GenModel getDomainGenModel() {
    if (domainGenModel != null && domainGenModel.eIsProxy()) {
        InternalEObject oldDomainGenModel = (InternalEObject) domainGenModel;
        domainGenModel = (GenModel) eResolveProxy(oldDomainGenModel);
        if (domainGenModel != oldDomainGenModel) {
            if (eNotificationRequired())
                eNotify(new ENotificationImpl(this, Notification.RESOLVE, GMFGenPackage.GEN_EDITOR_GENERATOR__DOMAIN_GEN_MODEL, oldDomainGenModel, domainGenModel));
        }
    }
    return domainGenModel;
}

@Override
@Nullable
public GenPackage getGenPackage(@NonNull String nsURI) {
    if (genPackageMap != null) {
        GenPackage genPackage = genPackageMap.get(nsURI);
        if (genPackage != null) {
            return genPackage;
        }
    }
    ResourceSet externalResourceSet = environmentFactory.getResourceSet();
    URI uri = EMF_2_9.EcorePlugin.getEPackageNsURIToGenModelLocationMap(false).get(nsURI);
    if (uri != null) {
        Resource resource = externalResourceSet.getResource(uri, true);
        for (EObject eObject : resource.getContents()) {
            if (eObject instanceof GenModel) {
                GenModel genModel = (GenModel) eObject;
                genModel.reconcile();
                for (GenPackage genPackage : genModel.getGenPackages()) {
                    if (genPackage != null) {
                        return genPackage;
                    }
                }
            }
        }
    }
    return null;
}

protected GenClass getGenClass(EClass eClass) {
    GenModel genModel = getGenModel(eClass);
    for (GenPackage pck : genModel.getAllGenPackagesWithClassifiers()) {
        for (GenClass genClass : pck.getGenClasses()) {
            EClass c = genClass.getEcoreClass();
            // As a workaround we compute the qualified names of the EClasses. This workaround should be removed later when possible.
            if (qualifiedNameProvider.getFullyQualifiedName(eClass).equals(qualifiedNameProvider.getFullyQualifiedName(c))) {
                return genClass;
            }
        }
    }
    return null;
}

/**
	 * Export profile.
	 *
	 * @param rootProfile
	 *            Profile
	 */
public void exportProfile(final Profile rootProfile) {
    final Shell activeShell = PlatformUI.getWorkbench().getDisplay().getActiveShell();
    final boolean isProfile = isProfileRoot(rootProfile);
    if (isProfile && validateUmlElementWithProgress(rootProfile)) {
        if (initParameters(rootProfile) == IDialogConstants.OK_ID && ProfileServices.INSTANCE.defineAllProfiles(rootProfile)) {
            GenericUMLProfileTools.save(rootProfile);
            final IProject profilePlugin = createPluginProjectWithProgress(profilePluginName);
            // the following code is OK.
            final IFolder modelFolder = //$NON-NLS-1$
            profilePlugin.getFolder(//$NON-NLS-1$
            "model");
            try {
                modelFolder.create(false, true, null);
            } catch (final CoreException e) {
                LogServices.INSTANCE.error("exportProfile(" + rootProfile.getClass() + ") not handled", e);
            }
            // make a copy of the profile into the new plug-in used for the
            // creation of static profile
            final IFile profileCopyIFile = modelFolder.getFile(//$NON-NLS-1$
            profileName + //$NON-NLS-1$
            "." + UMLResource.FILE_EXTENSION);
            final IFile rootProfileIFile = GenericUMLProfileTools.resourceToIFile(rootProfile.eResource());
            try {
                rootProfileIFile.copy(profileCopyIFile.getFullPath(), true, new NullProgressMonitor());
            } catch (final CoreException e) {
                LogServices.INSTANCE.error("exportProfile(" + rootProfile.getClass() + ") not handled", e);
            }
            final Resource profileCopyResource = new ResourceSetImpl().createResource(URI.createURI(profileCopyIFile.getFullPath().toString()));
            final Profile profileCopy = (Profile) GenericUMLProfileTools.load(profileCopyResource.getURI());
            initEPackageStereotype(profileCopy);
            final UmlToEcore umlToEcore = new UmlToEcore();
            final Resource profileEcoreResource = umlToEcore.umlToEcore(profileCopy);
            if (validateEObjectWithProgress(profileEcoreResource.getContents().get(0))) {
                final EcoreToGenmodel ecoreToGenmodel = new EcoreToGenmodel();
                final GenModel genModel = ecoreToGenmodel.ecoreToGenmodel(profileEcoreResource);
                final GenerateModelCode generateModelCode = new GenerateModelCode();
                generateModelCode.generateModelCode(genModel);
                addProfileExtensions(profilePlugin, modelFolder, profileCopy);
                // }
                try {
                    profilePlugin.build(IncrementalProjectBuilder.FULL_BUILD, new NullProgressMonitor());
                } catch (final CoreException e) {
                    LogServices.INSTANCE.error("exportProfile(" + rootProfile.getClass() + ") not handled", e);
                }
                final IWorkbenchWizard wizard = new PluginExportWizard();
                final StructuredSelection selection = new StructuredSelection(profilePlugin);
                wizard.init(PlatformUI.getWorkbench(), selection);
                final WizardDialog wd = new ResizableWizardDialog(PDEPlugin.getActiveWorkbenchShell(), wizard);
                wd.create();
                wd.open();
                // ecore.ecore that confused Acceleo in the VP.
                try {
                    profilePlugin.close(new NullProgressMonitor());
                } catch (final CoreException e) {
                    e.printStackTrace();
                }
            } else {
                MessageDialog.openError(activeShell, "Exportation error", "Due to the error, the exportation will be stopped.");
            }
        } else {
            MessageDialog.openInformation(activeShell, "Exportation canceled", "Exportation canceled by user.");
        }
    } else {
        if (!isProfile) {
            MessageDialog.openError(activeShell, "Exportation error", "The root element of this model is not a profile. Due to the error, the exportation will be stopped.");
        } else {
            MessageDialog.openError(activeShell, "Exportation error", "Due to the error, the exportation will be stopped.");
        }
    }
}

/**
     * Create contents of the wizard.
     * 
     * @param parent
     */
public void createControl(Composite parent) {
    Composite container = new Composite(parent, SWT.NULL);
    setControl(container);
    container.setLayout(new GridLayout(1, false));
    if (displayCreateComposite) {
        Section sctnGenmodel = formToolkit.createSection(container, Section.EXPANDED | Section.TITLE_BAR);
        sctnGenmodel.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1));
        formToolkit.paintBordersFor(sctnGenmodel);
        sctnGenmodel.setText("Genmodel");
        Composite composite = formToolkit.createComposite(sctnGenmodel, SWT.NONE);
        formToolkit.paintBordersFor(composite);
        sctnGenmodel.setClient(composite);
        composite.setLayout(new GridLayout(3, false));
        new Label(composite, SWT.NONE);
        new Label(composite, SWT.NONE);
        btnInitializeGeneratorModel = formToolkit.createButton(composite, "Initialize Generator Model", SWT.CHECK);
        new Label(composite, SWT.NONE);
        formToolkit.createLabel(composite, "Filename", SWT.NONE);
        formToolkit.createLabel(composite, "generator.eiqgen", SWT.NONE);
    }
    Section sctnReferencedEmfGenerator = formToolkit.createSection(container, Section.EXPANDED | Section.TITLE_BAR);
    sctnReferencedEmfGenerator.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1));
    formToolkit.paintBordersFor(sctnReferencedEmfGenerator);
    sctnReferencedEmfGenerator.setText("Referenced EMF Generator models");
    referencedGenmodels = formToolkit.createTree(sctnReferencedEmfGenerator, SWT.NONE);
    referencedGenmodels.setEnabled(false);
    formToolkit.paintBordersFor(referencedGenmodels);
    sctnReferencedEmfGenerator.setClient(referencedGenmodels);
    referencedGenmodels.setHeaderVisible(true);
    referencedGenmodels.setLinesVisible(true);
    genModelViewer = new TreeViewer(referencedGenmodels);
    genModelViewer.setContentProvider(new ITreeContentProvider() {

        List<GenModel> genmodels;

        @SuppressWarnings("unchecked")
        @Override
        public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
            if (newInput instanceof List<?>) {
                genmodels = (List<GenModel>) newInput;
            }
        }

        @Override
        public void dispose() {
        }

        @Override
        public boolean hasChildren(Object element) {
            return element instanceof GenModel && !((GenModel) element).getGenPackages().isEmpty();
        }

        @Override
        public Object getParent(Object element) {
            if (element instanceof GenPackage) {
                return ((GenPackage) element).getGenModel();
            }
            return null;
        }

        @Override
        public Object[] getElements(Object inputElement) {
            return genmodels.toArray(new GenModel[genmodels.size()]);
        }

        @Override
        public Object[] getChildren(Object parentElement) {
            if (parentElement instanceof GenModel) {
                List<GenPackage> packages = ((GenModel) parentElement).getGenPackages();
                return packages.toArray(new GenPackage[packages.size()]);
            }
            return null;
        }
    });
    genModelViewer.setLabelProvider(new LabelProvider() {
    });
    TreeViewerColumn resourcePathColumn = new TreeViewerColumn(genModelViewer, SWT.LEFT);
    resourcePathColumn.setLabelProvider(new ColumnLabelProvider() {

        @Override
        public String getText(Object element) {
            if (element instanceof GenModel) {
                return ((GenModel) element).eResource().getURI().toPlatformString(true);
            } else if (element instanceof GenPackage) {
                return ((GenPackage) element).getNSURI();
            }
            return super.getText(element);
        }
    });
    TreeViewerColumn packageURIColumn = new TreeViewerColumn(genModelViewer, SWT.LEFT);
    packageURIColumn.setLabelProvider(new ColumnLabelProvider() {

        @Override
        public String getText(Object element) {
            if (element instanceof GenModel) {
                return String.format("Plug-in dependency: %s", ((GenModel) element).getModelPluginID());
            } else if (element instanceof GenPackage) {
                return "";
            }
            return super.getText(element);
        }
    });
    TableLayout tableLayout = new TableLayout();
    tableLayout.addColumnData(new ColumnWeightData(50, true));
    tableLayout.addColumnData(new ColumnWeightData(50, true));
    referencedGenmodels.setLayout(tableLayout);
    genModelViewer.setInput(selectedGenmodels);
    Composite composite_1 = formToolkit.createComposite(sctnReferencedEmfGenerator, SWT.NONE);
    formToolkit.paintBordersFor(composite_1);
    sctnReferencedEmfGenerator.setTextClient(composite_1);
    composite_1.setLayout(new RowLayout(SWT.HORIZONTAL));
    addGenmodel = formToolkit.createButton(composite_1, "Add", SWT.NONE);
    addGenmodel.setEnabled(false);
    addGenmodel.addSelectionListener(new SelectionAdapter() {

        @Override
        public void widgetSelected(SelectionEvent e) {
            selectGenmodelFromWorkspace();
        }
    });
    if (displayCreateComposite) {
        /* m_bindingContext = */
        initDataBindings();
    }
}

public void invoke(IWorkflowContext ctx) {
    ResourceSet resSet = getResourceSet();
    Resource resource = resSet.getResource(URI.createURI(genModel), true);
    final GenModel genModel = (GenModel) resource.getContents().get(0);
    genModel.setCanGenerate(true);
    genModel.reconcile();
    createGenModelSetup().registerGenModel(genModel);
    Generator generator = new Generator() {

        @Override
        public JControlModel getJControlModel() {
            return new JControlModel() {

                @Override
                public boolean canMerge() {
                    return false;
                }
            };
        }
    };
    log.info("generating EMF code for " + this.genModel);
    generator.getAdapterFactoryDescriptorRegistry().addDescriptor(GenModelPackage.eNS_URI, new GeneratorAdapterDescriptor(getTypeMapper(), getLineDelimiter()));
    generator.setInput(genModel);
    Diagnostic diagnostic = generator.generate(genModel, GenBaseGeneratorAdapter.MODEL_PROJECT_TYPE, new BasicMonitor());
    if (diagnostic.getSeverity() != Diagnostic.OK)
        log.info(diagnostic);
    if (generateEdit) {
        Diagnostic editDiag = generator.generate(genModel, GenBaseGeneratorAdapter.EDIT_PROJECT_TYPE, new BasicMonitor());
        if (editDiag.getSeverity() != Diagnostic.OK)
            log.info(editDiag);
    }
    if (generateEditor) {
        Diagnostic editorDiag = generator.generate(genModel, GenBaseGeneratorAdapter.EDITOR_PROJECT_TYPE, new BasicMonitor());
        if (editorDiag.getSeverity() != Diagnostic.OK)
            log.info(editorDiag);
    }
}

/**
	 * Determines the common superclass of all DSL types that are mapped to Pivot
	 * Model types.
	 * 
	 * @param genModel
	 * @return the common superclass of the all DSL types
	 */
public static String getCommonSuperType(GenModel genModel) {
    if (dSL2PivotModel == null)
        createAnnotatedElements(genModel);
    Iterator<GenClass> dslTypeIter = dSL2PivotModel.keySet().iterator();
    EClass commonSuperType = null;
    // find the first common super type
    if (dslTypeIter.hasNext()) {
        GenClass dslTypeGenClass = dslTypeIter.next();
        commonSuperType = dslTypeGenClass.getEcoreClass();
    } else
        // no elements are annotated, so no common super type can be found
        return "Object";
    while (dslTypeIter.hasNext()) {
        commonSuperType = getCommonSuperType(commonSuperType, dslTypeIter.next().getEcoreClass());
        if (commonSuperType.getName().equals("EObject")) {
            return "Object";
        }
    }
    return genModel.findGenPackage(commonSuperType.getEPackage()).getInterfacePackageName() + "." + commonSuperType.getName();
}

public EObject enableCDOGen(EObject cur, Set<GenModel> genmodels) throws IOException {
    for (GenModel genModel : genmodels) {
        if (isNotFromPluginsOrRegistry(genModel)) {
            genModel.getModelPluginVariables().add("CDO=org.eclipse.emf.cdo");
            genModel.setRootExtendsInterface("org.eclipse.emf.cdo.CDOObject");
            genModel.setRootExtendsClass("org.eclipse.emf.internal.cdo.CDOObjectImpl");
            genModel.setFeatureDelegation(GenDelegationKind.REFLECTIVE_LITERAL);
            genModel.setProviderRootExtendsClass("org.eclipse.emf.cdo.edit.CDOItemProviderAdapter");
            if (genModel.eResource().getURI().isPlatformResource()) {
                URI cdoMFURI = getCDOMFUri(genModel);
                if (!URIConverter.INSTANCE.exists(cdoMFURI, Collections.EMPTY_MAP)) {
                    try (OutputStream out = URIConverter.INSTANCE.createOutputStream(cdoMFURI, Collections.EMPTY_MAP)) {
                        new PrintWriter(out).write("This is a marker file for bundles with CDO native models.");
                    }
                }
            }
        }
    }
    return cur;
}

public static String adjustGenModel(GenModel genModel) {
    StringBuilder builder = new StringBuilder();
    if (!ROOT_EXTENDS_CLASS.equals(genModel.getRootExtendsClass())) {
        genModel.setRootExtendsClass(ROOT_EXTENDS_CLASS);
        builder.append("Set Root Extends Class = ");
        builder.append(ROOT_EXTENDS_CLASS);
        builder.append("\n");
    }
    if (!ROOT_EXTENDS_INTERFACE.equals(genModel.getRootExtendsInterface())) {
        genModel.setRootExtendsInterface(ROOT_EXTENDS_INTERFACE);
        builder.append("Set Root Extends Interface = ");
        builder.append(ROOT_EXTENDS_INTERFACE);
        builder.append("\n");
    }
    if (!DYNAMIC_TEMPLATES.equals(genModel.isDynamicTemplates())) {
        genModel.setDynamicTemplates(DYNAMIC_TEMPLATES);
        builder.append("Set Dynamic Templates = ");
        builder.append(DYNAMIC_TEMPLATES);
        builder.append("\n");
    }
    if (!TEMPLATE_DIRECTORY.equals(genModel.getTemplateDirectory())) {
        genModel.setTemplateDirectory(TEMPLATE_DIRECTORY);
        ;
        builder.append("Set Template Directory = ");
        builder.append(TEMPLATE_DIRECTORY);
        builder.append("\n");
    }
    EList<String> pluginVariables = genModel.getModelPluginVariables();
    if (!pluginVariables.contains(PLUGIN_VARIABLE_NEO4EMF)) {
        pluginVariables.add(PLUGIN_VARIABLE_NEO4J);
        pluginVariables.add(PLUGIN_VARIABLE_NEO4EMF);
        builder.append("Added Model Plugin Variables = ");
        builder.append(PLUGIN_VARIABLE_NEO4J);
        builder.append(", ");
        builder.append(PLUGIN_VARIABLE_NEO4EMF);
        builder.append("\n");
    }
    EList<String> templatePluginVariables = genModel.getTemplatePluginVariables();
    if (!templatePluginVariables.contains(TEMPLATE_PLUGIN_VARIABLE)) {
        templatePluginVariables.add(TEMPLATE_PLUGIN_VARIABLE);
        builder.append("Added Template Plugin Variables = ");
        builder.append(TEMPLATE_PLUGIN_VARIABLE);
        builder.append("\n");
    }
    IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
    IFolder modelFolder = root.getFolder(new Path(genModel.getModelDirectory()));
    IProject modelProject = modelFolder.getProject();
    if (!modelProject.exists()) {
        try {
            modelProject.create(new NullProgressMonitor());
            //$NON-NLS-2$
            builder.append(//$NON-NLS-2$
            "Created target model project" + "\n");
        } catch (CoreException ex) {
            throw new WrappedException(ex);
        }
    }
    if (!modelProject.isOpen()) {
        try {
            modelProject.open(new NullProgressMonitor());
            //$NON-NLS-2$
            builder.append(//$NON-NLS-2$
            "Opened target model project" + "\n");
        } catch (CoreException ex) {
            throw new WrappedException(ex);
        }
    }
    return builder.length() == 0 ? null : builder.toString();
}

private GenModel loadGenModel(URI uri) {
    if (debug)
        System.err.println("loadGenModel! " + uri);
    //		final ResourceSet rs = new ResourceSetImpl();
    Resource resource;
    try {
        resource = masterResourceSet.getResource(uri, true);
        if (resource.getContents().isEmpty()) {
            throw new Exception();
        }
    } catch (Exception e) {
        System.err.println("Loading from resource");
        uri = URI.createURI(uri.toString().replaceFirst("resource", "plugin"));
        resource = masterResourceSet.getResource(uri, true);
    }
    if (!resource.getContents().isEmpty()) {
        final GenModel model = (GenModel) resource.getContents().get(0);
        //			model.reconcile();
        //			for (GenPackage gp : model.getGenPackages()) {
        //				fixAllInstanceClassNames(gp);
        //			}
        genModelCache.put(uri, model);
        return model;
    } else {
        System.err.println("COULD NOT LOAD GENMODEL!!!!!! " + uri);
        return null;
    }
}

public String getBasePackage(String genModelFile) {
    Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap().put("genmodel", new org.eclipse.emf.ecore.xmi.impl.EcoreResourceFactoryImpl());
    ResourceSet resourceSet = new ResourceSetImpl();
    resourceSet.getURIConverter().getURIMap().putAll(EcorePlugin.computePlatformURIMap());
    URI genModelURI = URI.createFileURI(genModelFile);
    Resource resource = resourceSet.getResource(genModelURI, true);
    GenModel eltGenModel = (GenModel) resource.getContents().get(0);
    return eltGenModel.getGenPackages().get(0).getBasePackage();
}

public static List<EMFMetaModel> getEMFMetaModels() {
    List<EMFMetaModel> result = new ArrayList<EMFMetaModel>();
    for (Entry<String, Object> ePackageEntry : EPackage.Registry.INSTANCE.entrySet()) {
        try {
            String ePackageUri = ePackageEntry.getKey();
            EPackage ePackage = null;
            if (ePackageEntry.getValue() instanceof EPackage.Descriptor) {
                ePackage = ((EPackage.Descriptor) ePackageEntry.getValue()).getEPackage();
            } else {
                ePackage = (EPackage) ePackageEntry.getValue();
            }
            if (ePackage != null) {
                URI genModelLocation = EcorePlugin.getEPackageNsURIToGenModelLocationMap().get(ePackageUri);
                if (genModelLocation != null) {
                    Resource.Factory genModelFactory = Resource.Factory.Registry.INSTANCE.getFactory(genModelLocation);
                    if (genModelFactory != null) {
                        Resource genModelResource = genModelFactory.createResource(genModelLocation);
                        genModelResource.load(null);
                        EList<EObject> genModelContents = genModelResource.getContents();
                        if (genModelContents.size() == 1 && genModelContents.get(0) instanceof GenModel) {
                            GenModel genModel = (GenModel) genModelContents.get(0);
                            if (genModel != null) {
                                EList<GenPackage> genPackages = genModel.getGenPackages();
                                if (genPackages.size() == 1) {
                                    GenPackage genPackage = genPackages.get(0);
                                    String fileExtension = genPackage.getFileExtension();
                                    Object resourceFactoryObject = Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap().get(fileExtension);
                                    if (resourceFactoryObject == null) {
                                        resourceFactoryObject = Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap().get("*");
                                    }
                                    Resource.Factory resourceFactory = null;
                                    if (resourceFactoryObject instanceof Resource.Factory.Descriptor) {
                                        resourceFactory = ((Resource.Factory.Descriptor) resourceFactoryObject).createFactory();
                                    } else {
                                        resourceFactory = (Resource.Factory) resourceFactoryObject;
                                    }
                                    Class<?>[] interfaces = ePackage.getClass().getInterfaces();
                                    if (interfaces.length == 1 && interfaces[0].isInterface() && EPackage.class.isAssignableFrom(interfaces[0])) {
                                        EMFMetaModel emfMetaModel = new EMFMetaModel(fileExtension, ePackageUri, ePackage, resourceFactory);
                                        result.add(emfMetaModel);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    return result;
}

@Override
protected Diagnostic generateModel(Object object, Monitor monitor) {
    boolean addedPluginDependecies = false;
    GenModel genModel = (GenModel) object;
    for (GenPackage genPackage : genModel.getGenPackages()) {
        EPackage ePackage = genPackage.getEcorePackage();
        if (EPackageAnnotation.get(ePackage).generate()) {
            if (!addedPluginDependecies) {
                // TODO: maybe don't hardcode those plugin ids here
                genModel.getModelPluginVariables().add("org.eclipselab.emf.ecore.protobuf");
                genModel.getModelPluginVariables().add("com.google.protobuf");
                addedPluginDependecies = true;
            }
            DescriptorProtos.FileDescriptorSet.Builder files = DescriptorProtos.FileDescriptorSet.newBuilder();
            MapperRegistry mappers = new MapperRegistry(new DefaultNamingStrategy());
            mappers.find(ePackage).map(ePackage, files);
            DescriptorProtos.FileDescriptorProto.Builder file = files.getFileBuilder(0);
            file.getOptionsBuilder().setJavaPackage(genPackage.getReflectionPackageName()).setJavaOuterClassname(genPackage.getPrefix() + "Protos");
            Descriptors.FileDescriptor file2;
            try {
                file2 = Descriptors.FileDescriptor.buildFrom(file.build(), new Descriptors.FileDescriptor[0]);
            } catch (DescriptorValidationException e) {
                return BasicDiagnostic.toDiagnostic(e);
            }
            URI srcDirectory = toURI(genModel.getModelDirectory());
            URI targetDirectory = srcDirectory.appendSegments(genPackage.getReflectionPackageName().split("\\."));
            URI targetFile = targetDirectory.appendSegment(file.getPackage() + ".proto");
            ensureContainerExists(targetDirectory, createMonitor(monitor, 1));
            try {
                Writer writer = new OutputStreamWriter(createOutputStream(targetFile));
                writer.write(new DescriptorDebugStringBuilder().build(file2));
                writer.close();
            } catch (Exception e) {
                return BasicDiagnostic.toDiagnostic(e);
            }
            srcDirectory = srcDirectory.appendSegment("");
            String workingDirectory = toAbsoluteFilesystemPath(srcDirectory) + File.separator;
            String protoFile = toPlatformResourceURI(targetFile).deresolve(toPlatformResourceURI(srcDirectory)).toFileString();
            if (protobufCompiler.isAvailable()) {
                try {
                    protobufCompiler.invoke(workingDirectory, protoFile, workingDirectory);
                } catch (Throwable t) {
                    return BasicDiagnostic.toDiagnostic(t);
                }
            }
            URI utilDirectory = toURI(genModel.getModelDirectory()).appendSegments(genPackage.getUtilitiesPackageName().split("\\."));
            try {
                GenerateProtobufUtilities generateProtobufUtilities = new GenerateProtobufUtilities(genPackage, new File(toAbsoluteFilesystemPath(utilDirectory)), Collections.emptyList());
                generateProtobufUtilities.generate(monitor);
            } catch (IOException e) {
                return BasicDiagnostic.toDiagnostic(e);
            }
        }
    }
    return Diagnostic.OK_INSTANCE;
}

@Test
public void testXcoreGenericTypeWithoutValidation() throws Exception {
    XcoreStandaloneSetup.doSetup();
    loadModel(URI.createURI("classpath:/model/Ecore.ecore"), true);
    loadModel(URI.createURI("classpath:/model/Ecore.genmodel"), true);
    // index 0 has xtext AST model; index 1 has what we want
    GenModel genModel = (GenModel) loadModelFromFile("src/XcoreGenericType/TestModel2.xcore", false).get(1);
    final GenPackage genPackage = genModel.getGenPackages().get(0);
    Assert.assertEquals("testmodel2", genPackage.getNSName());
    final GenClass genClass = genPackage.getGenClasses().get(0);
    GenFeature genFeature = genClass.getGenFeatures().get(0);
    EStructuralFeature feature = genFeature.getEcoreFeature();
    EAttribute attribute = (EAttribute) feature;
    Assert.assertEquals("age", attribute.getName());
    Assert.assertEquals("EInt", attribute.getEType().getName());
}

private void run(String pathToGenModel, String projectName, String projectPath, List<String> pluginPaths) throws Exception {
    ResourceSet rs = new ResourceSetImpl();
    registerFactoriesAndPackages(rs);
    registerURIMappings(rs, pluginPaths);
    EcorePlugin.getPlatformResourceMap().put(projectName, URI.createFileURI(projectPath + File.separator));
    GenModel genModel = loadGenModel(pathToGenModel, rs);
    if (genModel == null) {
        return;
    }
    registerCodeGenAdapter();
    generateCode(genModel, projectPath);
}

public static GenPackage createGenModel(final EPackage rootPackage, final String ecoreLocation, String basePackage, Collection<GenPackage> usedGenPackages) throws IOException {
    GenModel genModel = GenModelFactory.eINSTANCE.createGenModel();
    genModel.setComplianceLevel(GenJDKLevel.JDK70_LITERAL);
    genModel.setCopyrightText("Copyright (c) 2015-2016 Obeo, Inria\n" + "All rights reserved. This program and the accompanying materials\n" + "are made available under the terms of the Eclipse Public License v1.0\n" + "which accompanies this distribution, and is available at\n" + "http://www.eclipse.org/legal/epl-v10.html\n" + "	\n" + "Contributors:\n" + "- William Piers <william.piers@obeo.fr>\n" + "- Philippe Merle <philippe.merle@inria.fr>");
    String modelPluginId = new Path(ecoreLocation).removeLastSegments(2).lastSegment().toString();
    String editPluginId = modelPluginId + ".edit";
    String editorPluginId = modelPluginId + ".editor";
    String testsPluginId = modelPluginId + ".tests";
    genModel.setModelDirectory('/' + modelPluginId + "/src-gen");
    genModel.setEditDirectory('/' + editPluginId + "/src-gen");
    genModel.setEditorDirectory('/' + editorPluginId + "/src-gen");
    genModel.setTestsDirectory('/' + testsPluginId + "/src");
    genModel.getForeignModel().add(new Path(ecoreLocation).lastSegment());
    genModel.setModelName(ConverterUtils.toU1Case(rootPackage.getName()));
    genModel.setModelPluginID(modelPluginId);
    genModel.setEditPluginID(editPluginId);
    genModel.setEditorPluginID(editorPluginId);
    genModel.setTestsPluginID(testsPluginId);
    genModel.setRootExtendsInterface("org.eclipse.emf.ecore.EObject");
    // Activate code generation for Ecore reflective and dynamic invocation of OCCI actions.
    genModel.setOperationReflection(true);
    genModel.getUsedGenPackages().addAll(usedGenPackages);
    genModel.initialize(Collections.singleton(rootPackage));
    GenPackage genPackage = genModel.getGenPackages().get(0);
    genPackage.setPrefix(ConverterUtils.toU1Case(rootPackage.getNsPrefix()));
    genPackage.setBasePackage(basePackage);
    URI genModelURI = URI.createFileURI(new Path(ecoreLocation).removeFileExtension().addFileExtension("genmodel").toString());
    final XMIResourceImpl genModelResource = new XMIResourceImpl(genModelURI);
    genModelResource.getContents().add(genModel);
    genModelResource.save(Collections.EMPTY_MAP);
    return genPackage;
}

private static EMap<EList<String>, GenPackage> findGenPackagesInScope(EPackageWrapper context) {
    Resource eJavaResource = context.eResource();
    if (eJavaResource == null) {
        return ECollections.emptyEMap();
    }
    ResourceSet rs = eJavaResource.getResourceSet();
    if (rs == null) {
        return ECollections.emptyEMap();
    }
    EMap<EList<String>, GenPackage> result = new BasicEMap<EList<String>, GenPackage>();
    String fileName = context.getNamespaces().get(0) + ".genmodel";
    URI ecoreURI = eJavaResource.getURI().trimSegments(1 + context.getNamespaces().size()).appendSegment(fileName);
    try {
        Resource genModelResource = rs.getResource(ecoreURI, true);
        EcoreUtil.resolveAll(genModelResource);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
    // we need to create a copy of the list of resource, because the resource
    // set is expanded while iterating over the resources.
    List<Resource> copy = new ArrayList<Resource>();
    copy.addAll(rs.getResources());
    for (Resource r : copy) {
        if (!r.getContents().isEmpty() && r.getContents().get(0) instanceof GenModel) {
            GenModel genModel = (GenModel) r.getContents().get(0);
            for (GenPackage genPackage : genModel.getGenPackages()) {
                collectGenPackages(genPackage, new BasicEList<String>(), result);
            }
            for (GenPackage genPackage : genModel.getUsedGenPackages()) {
                if (genPackage.eIsProxy()) {
                    // TODO add error
                    String message = "Can't find used generator package for " + genPackage.toString();
                    addError(context.eResource(), message);
                    continue;
                }
                collectGenPackages(genPackage, new BasicEList<String>(), result);
            }
        }
    }
    return result;
}

@Override
protected void adjustGenModel(Monitor monitor) {
    super.adjustGenModel(monitor);
    GenModel genModel = getGenModel();
    String projectName = getModelProjectName();
    IPath genModelPath = getGenModelPath();
    URI modelURI = getModelLocationURIs().get(0);
    URI genModelURI = getGenModel().eResource().getURI();
    genModel.getForeignModel().add(makeRelative(modelURI, genModelURI).toFileString());
    IPath projectLocation = getWorkspaceRoot().getProject(projectName).getLocation();
    if (projectLocation != null) {
        projectLocation = projectLocation.removeLastSegments(1);
    } else {
        projectLocation = getGenModelProjectLocation();
    }
    for (Map.Entry<String, String> entry : getPathMap().entrySet()) {
        String value = entry.getValue();
        if (value != null) {
            genModel.getForeignModel().add(entry.getKey());
            if (new Path(value).equals(projectLocation)) {
                value = "..";
                for (int depth = genModelPath.segmentCount(); depth > 2; --depth) {
                    value += "/..";
                }
                genModel.getForeignModel().add(value);
            } else {
                genModel.getForeignModel().add(value);
            }
        }
    }
}

public static void processAll(ICompositionSystemContext systemContext, IExtensionContext extensionContext) throws CoreException, IOException {
    processLanguageExtension(extensionContext);
    generateEcoreFile(extensionContext);
    GenModel genModel = CompositionSystemGenerator.getGenModel(extensionContext);
    //	generateModelCode(genModel,new BasicMonitor());
    IJavaProject project = createComponentModelProject(systemContext.getBaseLanguageBasePackageName());
    processProjectInfrastructure(project, systemContext, extensionContext);
    processComponentModel(project, systemContext);
    processCompositionAlgebra(project, systemContext);
}

/**
	 * Searches for an edit plugin corresponding to the given EObject and tries to retrieve its associated
	 * image.
	 * 
	 * @param metamodelURI
	 *            the {@link URI}
	 * @param classifier
	 *            the {@link EObject} to get the image from
	 * @return the URL of the image associated to the given classifier (if any found)
	 */
private static URL doGetImageFromWorkspace(URI metamodelURI, EClassifier classifier) {
    URL imageURL = null;
    if (metamodelURI != null && metamodelURI.toString().replace("\"", "").endsWith("ecore")) {
        URI genModelURI = URI.createURI(metamodelURI.toString().replace("\"", "").replace("ecore", "genmodel"));
        try {
            Resource resource = getResourceSet().getResource(genModelURI, true);
            if (resource.getContents().isEmpty() || !(resource.getContents().iterator().next() instanceof GenModel)) {
                return null;
            }
            String editIconsDirectory = ((GenModel) resource.getContents().iterator().next()).getEditIconsDirectory();
            IFolder folder = ResourcesPlugin.getWorkspace().getRoot().getFolder(new Path(editIconsDirectory + "/full/obj16"));
            if (folder.exists()) {
                for (String imageExtension : new String[] { "gif", "png" }) {
                    if (folder.getFile(classifier.getName() + "." + imageExtension).exists()) {
                        imageURL = new URL("file:/" + folder.getFile(classifier.getName() + "." + imageExtension).getLocation().toString());
                    }
                }
            }
        // CHECKSTYLE:OFF
        } catch (RuntimeException e) {
            IntentUiLogger.logInfo("Cannot find genmodel at " + genModelURI + ". Default image will be use to display " + classifier.getName());
        } catch (MalformedURLException e) {
            IntentUiLogger.logError(e);
        }
    }
    return imageURL;
}

// projectName = e.g., "org.archstudio.xadl3.bindings"
public synchronized List<DataBindingGenerationStatus> generateBindings(List<String> schemaURIStrings, List<Xadl3SchemaLocation> schemaLocations, final String projectName) {
    List<DataBindingGenerationStatus> statusList = new ArrayList<DataBindingGenerationStatus>();
    try {
        // Map available schema for offline use.
        for (SchemaRecord schemaRecord : schemaRecords.values()) {
            URIConverter.URI_MAP.put(schemaRecord.nsUri, URI.createURI(schemaRecord.xsdFileUrl.toURI().toString()));
        }
        final IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName);
        XSDImporter importer = new XSDImporter() {

            /*
				 * Note: XSDImporter seems to not support non-local files (e.g., projects imported from an external
				 * folder, linked files, etc.). This is a problem because, in such cases, the generated resources are
				 * saved in the wrong location. Later, when searching for the resources, they cannot be found and the
				 * process fails. To resolve this, we extend the base class and move the resources to the correct
				 * location before saving them.
				 */
            @Override
            protected List<Resource> computeResourcesToBeSaved() {
                List<Resource> resources = super.computeResourcesToBeSaved();
                // Move these resources to the correct location.
                for (Resource resource : resources) {
                    URI uri = resource.getURI();
                    IFile newFile = project.getFile(uri.lastSegment());
                    resource.setURI(URI.createURI(newFile.getLocationURI().toString()));
                }
                return resources;
            }
        };
        importer.setUsePlatformURI(false);
        importer.setCreateEcoreMap(true);
        // We still have to assign some value here, even though it doesn't work.
        importer.setGenModelContainerPath(project.getFullPath());
        importer.setGenModelFileName("xadl.genmodel");
        String subfolder = "src";
        final IPath subfolderPath = project.getFolder(subfolder).getFullPath();
        importer.setModelPluginID(projectName);
        importer.setModelPluginDirectory("/" + projectName + "/" + subfolder);
        StringBuilder combinedModelURIs = new StringBuilder();
        for (String modelURIString : schemaURIStrings) {
            combinedModelURIs.append(modelURIString);
        }
        for (Xadl3SchemaLocation schemaLocation : schemaLocations) {
            if (!schemaLocation.isCopyLocally()) {
                combinedModelURIs.append(schemaLocation.getUrl().toString()).append(" ");
            }
        }
        importer.setModelLocation(combinedModelURIs.toString());
        boolean computePackagesSucceeded = false;
        try {
            importer.computeEPackages(emfMonitor);
            computePackagesSucceeded = true;
            // Fix names of external packages.
            Multimap<String, EPackage> packages = Multimaps.index(importer.getEPackages(), new Function<EPackage, String>() {

                @Override
                public String apply(EPackage input) {
                    return input.getNsURI();
                }
            });
            for (SchemaRecord record : schemaRecords.values()) {
                if (record.packageName != null && packages.get(record.nsUri.toString()).size() > 0) {
                    EPackage e = packages.get(record.nsUri.toString()).iterator().next();
                    e.setName(record.packageName);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            statusList.add(new DataBindingGenerationStatus(null, Status.FAILURE, "Error computing packages for schemas: " + importer.getModelLocation(), e));
            return statusList;
        }
        if (!computePackagesSucceeded) {
            statusList.add(new DataBindingGenerationStatus(null, Status.FAILURE, "Computing packages unsuccessful for schema: " + importer.getModelLocation(), null));
            return statusList;
        }
        // to generate bindings. We assume these are living in other schema projects.
        for (EPackage ePackage : importer.getEPackages()) {
            EPackageConvertInfo ePackageConvertInfo = importer.getEPackageConvertInfo(ePackage);
            if (ePackage.getNsURI().equals(EcorePackage.eNS_URI)) {
                // Don't convert the Ecore dependency; this seems to get included automagically.
                ePackageConvertInfo.setConvert(false);
                continue;
            }
            ePackageConvertInfo.setConvert(true);
        }
        // This causes the code to be generated with generics and such.
        GenModel genModel = importer.getGenModel();
        genModel.setComplianceLevel(GenJDKLevel.JDK70_LITERAL);
        // Inscrutable EMF Magic: Note that this has to be done before the below loop through
        // referenced packages or it will throw a NullPointerException when adding packages to the
        // ResourceSet.
        importer.adjustEPackages(emfMonitor);
        importer.prepareGenModelAndEPackages(emfMonitor);
        boolean modelSaveSucceeded = false;
        try {
            importer.saveGenModelAndEPackages(emfMonitor);
            modelSaveSucceeded = true;
        } catch (Exception e) {
            e.printStackTrace();
            statusList.add(new DataBindingGenerationStatus(null, Status.FAILURE, "Error saving generated content for schema: " + importer.getModelLocation(), e));
            return statusList;
        }
        if (!modelSaveSucceeded) {
            statusList.add(new DataBindingGenerationStatus(null, Status.FAILURE, "Error saving generated content for schema: " + importer.getModelLocation(), null));
            return statusList;
        }
        try {
            genModel.setCanGenerate(true);
            Generator codeGenerator = new Generator();
            codeGenerator.setInput(genModel);
            // Find the gen package for the targeted schema.
            for (GenPackage genPackage : genModel.getGenPackages()) {
                // Only generate code for the schema in this project.
                if (namedSchemaRecords.get(projectName).contains(genPackage.getNSURI())) {
                    codeGenerator.generate(genPackage, GenBaseGeneratorAdapter.MODEL_PROJECT_TYPE, emfMonitor);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            statusList.add(new DataBindingGenerationStatus(null, Status.FAILURE, "Error generating content for schema: " + importer.getModelLocation(), e));
            return statusList;
        }
        // Update plugin's dependencies to include referenced schema.
        BundleContext context = Activator.getSingleton().getContext();
        final IBundleProjectService service = OSGiUtils.getServiceReference(context, IBundleProjectService.class);
        IBundleProjectDescription description = service.getDescription(project);
        Map<String, IRequiredBundleDescription> requiredBundles = new HashMap<>();
        for (IRequiredBundleDescription requiredBundle : SystemUtils.emptyIfNull(description.getRequiredBundles())) {
            requiredBundles.put(requiredBundle.getName(), requiredBundle);
        }
        requiredBundles.put("org.eclipse.emf.ecore", service.newRequiredBundle("org.eclipse.emf.ecore", null, false, true));
        requiredBundles.put("org.eclipse.emf.ecore.xmi", service.newRequiredBundle("org.eclipse.emf.ecore.xmi", null, false, true));
        requiredBundles.put("org.archstudio.dblgen", service.newRequiredBundle("org.archstudio.dblgen", null, false, true));
        for (String nsUri : SystemUtils.emptyIfNull(namedSchemaRecords.get(projectName))) {
            if (schemaRecords.containsKey(nsUri)) {
                for (String importedNsUri : schemaRecords.get(nsUri).imports) {
                    if (schemaRecords.containsKey(importedNsUri)) {
                        String name = schemaRecords.get(importedNsUri).name;
                        if (!projectName.equals(name)) {
                            requiredBundles.put(name, service.newRequiredBundle(name, null, false, true));
                        }
                    }
                }
            }
        }
        description.setRequiredBundles(requiredBundles.values().toArray(new IRequiredBundleDescription[requiredBundles.size()]));
        // Updated plugin's exported packages to include the java packages created. Actually, only
        // export created packages.
        final Map<String, IPackageExportDescription> packageExports = new HashMap<>();
        project.getFolder(subfolder).accept(new IResourceVisitor() {

            @Override
            public boolean visit(IResource resource) throws CoreException {
                try {
                    if (resource instanceof IFile) {
                        IFile file = (IFile) resource;
                        IPath path = file.getParent().getFullPath();
                        String packageName = path.makeRelativeTo(subfolderPath).toString().replace('/', '.');
                        packageExports.put(packageName, service.newPackageExport(packageName, null, true, null));
                    }
                } catch (Exception e) {
                    throw new CoreException(new org.eclipse.core.runtime.Status(IStatus.ERROR, "org.archstudio.dblgen.core", "Error visiting " + resource.toString(), e));
                }
                return true;
            }
        });
        description.setPackageExports(packageExports.values().toArray(new IPackageExportDescription[packageExports.size()]));
        // Update plugin's bin includes to include the model folder.
        Set<IPath> binIncludes = Sets.newHashSet(SystemUtils.emptyIfNull(description.getBinIncludes()));
        binIncludes.add(new Path("model/"));
        List<IPath> binIncludesSorted = Lists.newArrayList(binIncludes);
        Collections.sort(binIncludesSorted, new Comparator<IPath>() {

            @Override
            public int compare(IPath o1, IPath o2) {
                return o1.toString().compareTo(o2.toString());
            }
        });
        description.setBinIncludes(binIncludesSorted.toArray(new IPath[binIncludesSorted.size()]));
        // Make sure that extensions are allowed.
        description.setExtensionRegistry(true);
        // Store the changes.
        description.apply(null);
        project.refreshLocal(IResource.DEPTH_INFINITE, null);
        // Add the package and parser extensions to the plugin.
        IFile manifestFile = project.getFile("META-INF/MANIFEST.MF");
        manifestFile.refreshLocal(IResource.DEPTH_ONE, null);
        IFile pluginFile = project.getFile("plugin.xml");
        pluginFile.refreshLocal(IResource.DEPTH_ONE, null);
        WorkspaceBundlePluginModel pluginModel = new WorkspaceBundlePluginModel(manifestFile, pluginFile);
        IExtensionsModelFactory pluginFactory = pluginModel.getFactory();
        // The workspace extensions are not loaded by default, so manually copy them.
        IPluginModelBase existingPluginModel = PluginRegistry.findModel(project);
        if (existingPluginModel != null) {
            IExtensions extensions = existingPluginModel.getExtensions();
            if (extensions != null) {
                for (IPluginExtension pluginExtension : extensions.getExtensions()) {
                    pluginModel.getExtensions().add(copyPluginExtensions(pluginFactory, pluginExtension));
                }
            }
        }
        // Remove existing generated extensions.
        for (IPluginExtension extension : Lists.newArrayList(pluginModel.getExtensions().getExtensions())) {
            if ("org.eclipse.emf.ecore.generated_package".equals(extension.getPoint())) {
                pluginModel.getExtensions().remove(extension);
            }
            if ("org.eclipse.emf.ecore.extension_parser".equals(extension.getPoint())) {
                pluginModel.getExtensions().remove(extension);
            }
            if ("org.archstudio.dblgen.processedSchema".equals(extension.getPoint())) {
                pluginModel.getExtensions().remove(extension);
            }
        }
        // Add the generated package extensions.
        for (GenPackage genPackage : genModel.getGenPackages()) {
            // Only generate code for the schema in this project.
            if (namedSchemaRecords.get(projectName).contains(genPackage.getNSURI())) {
                String nsURI = genPackage.getNSURI();
                String packageClassName = "" + genPackage.getBasePackage() + "." + genPackage.getPackageName() + "." + genPackage.getPackageInterfaceName();
                IPluginExtension extension = pluginModel.createExtension();
                extension.setPoint("org.eclipse.emf.ecore.generated_package");
                IPluginElement element = pluginModel.createElement(extension);
                element.setName("package");
                element.setAttribute("uri", nsURI);
                element.setAttribute("class", packageClassName);
                extension.add(element);
                pluginModel.getExtensions().add(extension);
            }
        }
        // Add an entry for each processed schema.
        for (String nsUri : namedSchemaRecords.get(projectName)) {
            SchemaRecord schemaRecord = schemaRecords.get(nsUri);
            IPluginExtension extension = pluginModel.createExtension();
            extension.setPoint("org.archstudio.dblgen.processedSchema");
            IPluginElement element = pluginModel.createElement(extension);
            element.setName("Schema");
            element.setAttribute("nsURI", nsUri);
            if (schemaRecord.schemaPath != null) {
                element.setAttribute("file", schemaRecord.schemaPath);
            }
            if (schemaRecord.schemaUrl != null) {
                element.setAttribute("url", schemaRecord.schemaUrl);
            }
            extension.add(element);
            pluginModel.getExtensions().add(extension);
        }
        // Save plug-in model.
        pluginModel.save();
        // Format generated files.
        CodeGeneration.formatCode(project);
        SortManifests.sortManifest(project);
    } catch (Exception e) {
        e.printStackTrace();
        statusList.add(new DataBindingGenerationStatus(null, Status.FAILURE, "Error processing schema: " + e.getMessage(), e));
        return statusList;
    }
    return statusList;
}