Java 类org.eclipse.core.resources.IProject 实例源码

static IFolder createSchema(String name, boolean open, IProject project) throws CoreException {
    IFolder projectFolder = project.getFolder(DbObjType.SCHEMA.name());
    if (!projectFolder.exists()) {
        projectFolder.create(false, true, null);
    }
    IFolder schemaFolder = projectFolder.getFolder(name);
    if (!schemaFolder.exists()) {
        schemaFolder.create(false, true, null);
    }
    IFile file = projectFolder.getFile(name + POSTFIX);
    if (!file.exists()) {
        StringBuilder sb = new StringBuilder();
        sb.append(MessageFormat.format(PATTERN, DbObjType.SCHEMA, name));
        sb.append(MessageFormat.format(OWNER_TO, DbObjType.SCHEMA, name));
        file.create(new ByteArrayInputStream(sb.toString().getBytes()), false, null);
    }
    if (open) {
        openFileInEditor(file);
    }
    return schemaFolder;
}

/**
 * @see PreferencePage#performOk
 */
@Override
public boolean performOk()
{
    if( !modified )
    {
        return true;
    }
    IPath path = Path.EMPTY;
    Object[] checked = listViewer.getCheckedElements();
    for( Object elements : checked )
    {
        path = path.append(((IProject) elements).getName());
    }
    IPreferenceStore prefs = getPreferenceStore();
    prefs.setValue(JPFClasspathPlugin.PREF_PARENT_REGISTRIES, path.toString());
    try
    {
        ((IPersistentPreferenceStore) prefs).save();
    }
    catch( IOException e )
    {
        JPFClasspathLog.logError(e);
    }
    return true;
}

/**
 * Test whether the project has the passed nature
 * 
 * @param receiver
 * @param nature
 * @return
 */
public static boolean hasNature(Object receiver, String nature) {
    IProject project = JDTManager.toJavaProject(receiver);
    if (project == null || !project.isOpen())
        return false;
    IProjectDescription description;
    try {
        description = project.getDescription();
    } catch (CoreException e) {
        ResourceManager.logException(e);
        return false;
    }
    String[] natures = description.getNatureIds();
    for (int i = 0; i < natures.length; i++) {
        if (nature.equalsIgnoreCase(natures[i]))
            return true;
    }
    return false;
}

@Override
public Object executeForSelectedLanguage(ExecutionEvent event,
        IProject updatedGemocLanguageProject, Language language)
        throws ExecutionException {
    CreateDomainModelWizardContextAction action = new CreateDomainModelWizardContextAction(
            updatedGemocLanguageProject); 
    action.actionToExecute = CreateDomainModelAction.CREATE_NEW_EMF_PROJECT;
    action.execute();

    if(action.getCreatedEcoreUri() != null){
        waitForAutoBuild();
        updateMelange(event,language,action.getCreatedEcoreUri());
    }

    return null;
}

/**
 * <ol>
 * <li>create Class1 file with having Class1.field0 -> should have no errors</li>
 * <li>create Class0 file with referencing Class1.field0 -> should have no errors as Class1 already created</li>
 * </ol>
 */
//@formatter:on
@Test
public void testNoErrorMarkersWhenReferencedFileIsCreatedBeforeReferencingFile() throws Exception {
    // create project and test files
    final IProject project = createJSProject("testNoErrorMarkersWhenReferencedFileIsCreatedBeforeReferencingFile");
    IFolder folder = configureProjectWithXtext(project);
    IFolder moduleFolder = createFolder(folder, TestFiles.moduleFolder());

    IFile file2 = createTestFile(moduleFolder, "Class1", TestFiles.class1());
    assertMarkers("File2 should have no errors", file2, 0);

    IFile file1 = createTestFile(moduleFolder, "Class0", TestFiles.class0());

    // The value of the local variable dummy is not used
    assertMarkers("File1 should have no errors", file1, 1);
}

/**
 * Return a path relative to its package fragment root
 * 
 * @param project
 * @param path
 * @return
 * @throws JavaModelException
 */
public static IPath getPathWithinPackageFragment(IResource ifile) throws JavaModelException {
    IProject project = ifile.getProject();
    IPath path = ifile.getFullPath();
    String[] segments = path.segments();
    IJavaProject jproject = JavaCore.create(project);
    IPackageFragment[] pkgs = jproject.getPackageFragments();
    IPath p = new Path("/");
    for (int i = 0; i < segments.length; i++) {
        for (int j = 0; j < pkgs.length; j++) {
            if (pkgs[j].getPath().equals(p)) {
                IPath ret = path.makeRelativeTo(pkgs[j].getPath());
                return ret;
            }
        }
        p = p.append(segments[i]);
    }
    return null;
}

@Override
protected void createModel(IProject project, boolean notify)
{
    IPluginModel model = null;
    if( isPluginProject(project) )
    {
        model = new ProjectPluginModelImpl(this, project);
    }
    if( model != null )
    {
        fModels.put(project, model);
        if( notify )
        {
            addChange(model, IModelProviderEvent.MODELS_ADDED);
        }
    }
}

private static void mkdirs(IFolder destPath) {
    IContainer parent = destPath.getParent(); 
    if (! parent.exists()) {
        if (parent instanceof IFolder) {
            mkdirs((IFolder) parent);
        }
        else if (parent instanceof IProject) {
            mkdirs( ((IProject)parent).getFolder(".") );
        }
    }
    try {
        destPath.create(/*force*/true, /*local*/true, Constants.NULL_PROGRESS_MONITOR);
    } catch (CoreException e) {
        e.printStackTrace();
    }
}

/**
 * Collects all compilation units within the project.
 * @return the collection of the compilation units
 */
public static List<ICompilationUnit> collectAllCompilationUnits() {
    List<ICompilationUnit> units = new ArrayList<ICompilationUnit>();

    try {
        IProject[] projects =  getWorkspace().getRoot().getProjects();
        for (int i = 0; i < projects.length; i++) {
            IJavaProject project = (IJavaProject)JavaCore.create((IProject)projects[i]);

            IPackageFragment[] packages = project.getPackageFragments();
            for (int j = 0; j < packages.length; j++) {

                ICompilationUnit[] cus = packages[j].getCompilationUnits();
                for (int k = 0; k < cus.length; k++) {
                    IResource res = cus[k].getResource();
                    if (res.getType() == IResource.FILE) {
                        String name = cus[k].getPath().toString();
                        if (name.endsWith(".java")) { 
                            units.add(cus[k]);
                        }
                    }
                }
            }
        }
    } catch (JavaModelException e) {
        e.printStackTrace();
    }

    return units;
}

public void openXMLTransactionStepEditor(IProject project)
{
    TransactionStep transactionStep = (TransactionStep)this.getObject();

    IFile   file = project.getFile("_private/"+transactionStep.getName()+".xml");


    IWorkbenchPage activePage = PlatformUI
                                    .getWorkbench()
                                    .getActiveWorkbenchWindow()
                                    .getActivePage();
    if (activePage != null) {
        try {
            activePage.openEditor(new XMLTransactionStepEditorInput(file,transactionStep),
                                    "com.twinsoft.convertigo.eclipse.editors.xml.XMLTransactionStepEditor");
        }
        catch(PartInitException e) {
            ConvertigoPlugin.logException(e, "Error while loading the step editor '" + transactionStep.getName() + "'");
        } 
    }
}

protected IFileSystemAccess2 getFileSystemAccess(final IProject project, final IProgressMonitor monitor) {
    EclipseResourceFileSystemAccess2 access = fileSystemAccessProvider.get();
    access.setContext(project);
    access.setMonitor(monitor);
    OutputConfiguration defaultOutput = new OutputConfiguration(IFileSystemAccess.DEFAULT_OUTPUT);
    defaultOutput.setDescription("Output Folder");
    defaultOutput.setOutputDirectory("./");
    defaultOutput.setOverrideExistingResources(true);
    defaultOutput.setCreateOutputDirectory(true);
    defaultOutput.setCleanUpDerivedResources(false);
    defaultOutput.setSetDerivedProperty(false);
    defaultOutput.setKeepLocalHistory(false);
    HashMap<String, OutputConfiguration> outputConfigurations = new HashMap<String, OutputConfiguration>();
    outputConfigurations.put(IFileSystemAccess.DEFAULT_OUTPUT, defaultOutput);
    access.setOutputConfigurations(outputConfigurations);
    return access;
}

/**
 * Runs a test module with one single class that has method with {@code Ignore} annotation.
 */
@Ignore("IDE-2270")
@Test
public void testModuleWithIgnoredMethod() {
    final IProject project = getProjectByName(PROJECT_NAME);
    assertTrue("Project is not accessible.", project.isAccessible());
    final IFile module = project.getFile("test/X1.n4js");
    assertTrue("Module is not accessible.", module.isAccessible());

    runTestWaitResult(module);

    final String[] expected = { "X1#x12Test" };
    final String[] actual = getConsoleContentLines();

    assertArrayEquals(expected, actual);
}

/**
 * Runs a test module with one single class that has neither super class nor {@code @Ignore} annotation.
 */
@Ignore("IDE-2270")
@Test
public void testModuleWithoutSuperClass() {
    final IProject project = getProjectByName(PROJECT_NAME);
    assertTrue("Project is not accessible.", project.isAccessible());
    final IFile module = project.getFile("test/A.n4js");
    assertTrue("Module is not accessible.", module.isAccessible());

    runTestWaitResult(module);

    final String[] expected = { "A#aTest" };
    final String[] actual = getConsoleContentLines();

    assertArrayEquals(expected, actual);
}

@Override
public IAdaptable[] getElements() {
    final IProject[] projects = ResourcesPlugin.getWorkspace().getRoot().getProjects();
    final IProject[] elements = new IProject[projects.length];
    int elementCount = 0;
    for (int i = 0, size = projects.length; i < size; i++) {
        final IProject project = projects[i];
        final IN4JSProject n4Project = core.findProject(toUri(project)).orNull();
        if (type == null) { // Other Projects
            if (n4Project == null || !n4Project.exists()) {
                elements[elementCount++] = project;
            }
        } else {
            if (n4Project != null && n4Project.exists() && type.equals(n4Project.getProjectType())) {
                elements[elementCount++] = project;
            }
        }
    }
    return Arrays.copyOfRange(elements, 0, elementCount);
}

@Override
public Iterable<Pair<IStorage, IProject>> getStorages(URI uri) {
    if (uri.isArchive()) {
        URIBasedStorage storage = new URIBasedStorage(uri);
        String authority = uri.authority();
        URI archiveFileURI = URI.createURI(authority.substring(0, authority.length() - 1));
        Optional<? extends IN4JSEclipseProject> optionalProject = eclipseCore.findProject(archiveFileURI);
        if (optionalProject.isPresent()) {
            return Collections.singletonList(Tuples.<IStorage, IProject> create(storage, optionalProject.get()
                    .getProject()));
        } else {
            return Collections.singletonList(Tuples.create(storage, null));
        }
    } else {
        return Collections.emptyList();
    }
}

public void launchEditor(String editorType) {
    // Retrieve the workspace project
    try {
        String projectName = ((DatabaseObject) parent.getObject()).getProject().getName();

        // Refresh project resource
        IProject project = ConvertigoPlugin.getDefault().getProjectPluginResource(projectName);

        Sheet sheet = (Sheet) parent.getObject();
        //String parentStyleSheet = sheet.getUrl();

        // Gets the xsl file to be edited
        IFile file = project.getFile(new Path(xslPath));

        // Launch the XslStyleSheet Editor
        PlatformUI
                .getWorkbench()
                .getActiveWorkbenchWindow()
                .getActivePage()
                .openEditor(new XslFileEditorInput(file, projectName, sheet),
                        "com.twinsoft.convertigo.eclipse.editors.xsl.XslRuleEditor");
    } catch (Exception pei) {
        ConvertigoPlugin.logException(pei, "Unexpceted exception");
    }
}

protected void validateAll ( final IProject project, final ComposedAdapterFactory adapterFactory, final Set<String> extensions, final IProgressMonitor monitor )
{
    logger.debug ( "Validating all resources of {}", project );

    try
    {
        project.accept ( new IResourceVisitor () {

            @Override
            public boolean visit ( final IResource resource ) throws CoreException
            {
                return handleResource ( null, resource, adapterFactory, extensions, monitor );
            }
        } );
    }
    catch ( final CoreException e )
    {
        StatusManager.getManager ().handle ( e.getStatus () );
    }
}

/**
 * Handles the given resource delta.
 *
 * Fires workspace repository changed event if a project was opened/closed or a project was added/removed.
 */
private boolean handleResourceDelta(IResourceDelta delta) {
    IResource affectedResource = delta.getResource();

    if (affectedResource instanceof IProject) {
        // check if kind is CHANGED
        if ((delta.getKind() & IResourceDelta.CHANGED) == IResourceDelta.CHANGED) {
            // if project was opened/closed
            if ((delta.getFlags() & IResourceDelta.OPEN) == IResourceDelta.OPEN) {
                fireWorkspaceRepositoriesChanged();
                return false;
            }
        }
        // check if kind is ADDED or REMOVED
        else if ((delta.getKind() & IResourceDelta.ADDED | IResourceDelta.REMOVED) != 0) {
            fireWorkspaceRepositoriesChanged();
            return false;
        }
    }
    return true;
}

public void launchEditor(String editorType) {
    // Retrieve the project name
    String projectName = getObject().getProject().getName();
    try {
        // Refresh project resource
        IProject project = ConvertigoPlugin.getDefault().getProjectPluginResource(projectName);

        // Get editor type
        if (editorType == null) {
            editorType = "UnknownEditor";
            if (getObject() instanceof SimpleStatement)
                editorType = "JscriptStatementEditor";
        }

        // Open editor
        if (editorType.equals("JscriptStatementEditor"))
            openJscriptStatementEditor(project);

    } catch (CoreException e) {
        ConvertigoPlugin.logException(e, "Unable to open project named '" + projectName + "'!");
    }
}

@Override
public Object executeForSelectedLanguage(ExecutionEvent event,
        IProject updatedGemocLanguageProject, Language language)
        throws ExecutionException {
    CreateEditorProjectWizardContextAction action = new CreateEditorProjectWizardContextAction(
            updatedGemocLanguageProject);
    action.actionToExecute = CreateEditorProjectAction.CREATE_NEW_XTEXT_PROJECT;
    action.execute();

    if(action.getSiriusPath() != null){
        waitForAutoBuild();
        updateMelange(event,language,action.getXtextPath());
    }

    return null;
}

/**
 * Execute command.
 *
 * @param job the job
 * @param project the project
 * @param gradleCommand the gradle command
 * @param gefCanvas the gef canvas
 */
private void executeCommand(Job job, IProject project, String gradleCommand, DefaultGEFCanvas gefCanvas) {
    ProcessBuilder processBuilder = JobScpAndProcessUtility.INSTANCE.getProcess(project, gradleCommand);
    try {
        Process process = processBuilder.start();

        job.setLocalJobProcess(process);
        JobLogger joblogger = initJobLogger(gefCanvas,job.getUniqueJobId());

        JobManager.INSTANCE.addJob(job);
        logProcessLogsAsynchronously(joblogger, process, job);

    } catch (IOException e) {
        logger.debug("Unable to execute the job", e);
    }
}

@Override
public Object execute(ExecutionEvent event) throws ExecutionException {
    List<IFile> jobFiles = new ArrayList<>();
    List<IFile> pastedFileList = new ArrayList<>();
    IWorkbenchPart part = HandlerUtil.getActivePart(event);
    if(part instanceof CommonNavigator){
        PasteAction action = new PasteAction(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActivePart().getSite());
        action.run();
        IWorkspaceRoot workSpaceRoot = ResourcesPlugin.getWorkspace().getRoot();
        IProject project = workSpaceRoot.getProject(JobCopyParticipant.getCopyToPath().split("/")[1]);
        IFolder jobFolder = project.getFolder(
                JobCopyParticipant.getCopyToPath().substring(JobCopyParticipant.getCopyToPath().indexOf('/', 2)));
        IFolder paramFolder = project.getFolder(PARAMETER_FOLDER_NAME);
        try {
            createCurrentJobFileList(jobFolder, jobFiles);
            pastedFileList=getPastedFileList(jobFiles);
            generateUniqueJobIdForPastedFiles(pastedFileList);
            createXmlFilesForPastedJobFiles(pastedFileList);
            List<String> copiedPropertiesList = getCopiedPropertiesList();
            createPropertiesFilesForPastedFiles(paramFolder, pastedFileList, copiedPropertiesList);
            JobCopyParticipant.cleanUpStaticResourcesAfterPasteOperation();

        } catch (CoreException  coreException) {
            logger.warn("Error while copy paste jobFiles",coreException.getMessage() );
        }

    }

    else if(part instanceof ELTGraphicalEditor){
        IEditorPart editor = HandlerUtil.getActiveEditor(event);
        ((ELTGraphicalEditor)editor).pasteSelection();
    }

    return null;
}

public Iterable<IN4JSProject> findAllProjects() {

        final Map<String, IProject> workspaceProjectMapping = newLinkedHashMap();
        for (final IProject workspaceProject : from(asList(workspace.getProjects())).filter(p -> p.isOpen())) {
            workspaceProjectMapping.put(workspaceProject.getName(), workspaceProject);
        }

        for (final IProject project : externalLibraryWorkspace.getProjects()) {
            if (!workspaceProjectMapping.containsKey(project.getName())) {
                workspaceProjectMapping.put(project.getName(), project);
            }
        }

        return from(workspaceProjectMapping.values()).transform(p -> getN4JSProject(p));
    }

/**
 * 
 * @return the list of all simqri modeling projects name available in the user's workspace
 */
public static List<String> getModelingProjects() { // ONLY the open ones !
    List<String> projectsNameList = new ArrayList<String>();
    IProject[] projects = ResourcesPlugin.getWorkspace().getRoot().getProjects();
    for(int i=0 ; i<projects.length; i++) {
        if(projects[i].getFile("representations.aird").exists()) {
            projectsNameList.add(projects[i].getName());
        }
    }
    return projectsNameList;
}

/**
 * Obtient le type JDT pour un nom complet qualifié dans un projet donné.
 * 
 * @param fullyQualifiedName Nom complet qualifié.
 * @param project Projet.
 * @return Le type JDT, <code>null</code> sinon.
 */
public static IType getJavaType(String fullyQualifiedName, IProject project) {
    IJavaProject javaProject = JavaCore.create(project);
    try {
        return javaProject.findType(fullyQualifiedName);
    } catch (Exception e) {
        ErrorUtils.handle(e);
    }
    return null;
}

@Override
protected boolean initialize(Object element) {
    this.modifiedResource = (IFile) element;
    if (modifiedResource.getParent() != null && modifiedResource.getParent().getParent() instanceof IProject) {
        if (StringUtils.equalsIgnoreCase(Messages.PROPERTIES_EXT, modifiedResource.getFileExtension())) {
            if (!StringUtils.equalsIgnoreCase(modifiedResource.getParent().getName(), Messages.PARAM)) {
                return false;
            }
        }
    }
    return true;
}

public static IPath buildModelAnnotationValue (IFile in) {
    IPath ret = null;
    if (!PreferenceManager.isGraphModelFile(in)) return null;
    IProject project = in.getProject();
    String[] folders = PreferenceManager.getAuthorizedFolderForGraphDefinition();
    for (int i = 0; i < folders.length; i++) {
        IPath base = project.getFullPath().append(folders[i]);
        if (base.isPrefixOf(in.getFullPath())) {
            ret = in.getFullPath().makeRelativeTo(base);
            break;
        }
    }
    return ret;
}

protected void selectExistingEMFProject() {
    // launch the appropriate wizard
    SelectEMFIProjectDialog dialog = new SelectEMFIProjectDialog(PlatformUI
            .getWorkbench().getActiveWorkbenchWindow().getShell());
    int res = dialog.open();
    if (res == WizardDialog.OK) {
        // update the project model
        addEMFProjectToConf(((IProject) dialog.getResult()[0]));
    }
}

private boolean isInterestingProject ( final IProject project )
{
    try
    {
        final boolean result = project.hasNature ( Constants.PROJECT_NATURE_CONFIGURATION );
        logger.debug ( "Checking project - project: {}, result: {}", project, result );
        return result;
    }
    catch ( final CoreException e )
    {
        StatusManager.getManager ().handle ( e.getStatus () );
        return false;
    }

}

/**
 * Implement a full build 
 * @param monitor
 * @throws CoreException
 */
protected void fullBuild(final IProgressMonitor monitor) throws CoreException {
    try {

        IProject project = getProject();
        deleteMarkers(project);
        if (!PreferenceManager.isBuildEnabled(project.getName())) return;
        getProject().accept(new GW4EResourceVisitor());
    } catch (CoreException e) {
        ResourceManager.logException(e);
    }
}

@Test
public void projectSlash() throws Exception {
    URI uri = URI.createPlatformResourceURI("/myProject/", true);
    IResource iResource = UriUtils.toIResource(uri);

    assertTrue(iResource instanceof IProject);
    assertTrue(iResource.exists());
    assertEquals("/myProject", iResource.getFullPath().toString());
}

@Override
public void resourceChanged(IResourceChangeEvent event) {
    IResourceDelta delta = event.getDelta();
    if (delta.getResource().getType() == IResource.ROOT) {
        List<IProject> projects = getProjects(event.getDelta());
        // do something with new projects
        for (IProject project : projects) {
            try {
                triggerBuild(project);
            } catch (CoreException e) {
                e.printStackTrace();
            }
        }
    }
}

public void launchEditor(String editorType) {
    // Retrieve the project name
    String projectName = getObject().getProject().getName();
    try {
        // Refresh project resource
        IProject project = ConvertigoPlugin.getDefault().getProjectPluginResource(projectName);

        // Open editor
        openXslEditor(project);

    } catch (CoreException e) {
        ConvertigoPlugin.logException(e, "Unable to open project named '" + projectName + "'!");
    }
}

/**
 * Add a new entry to the existing java project
 *  you can use JavaCore factory to create the entry itself
 *  ex : JavaCore.newProjectEntry(ecoreIFile.getProject().getFullPath())
 * If the entry is already there, the method will do nothing.
 */
public static void addEntry(IProject project, IClasspathEntry newEntry, IProgressMonitor monitor) throws CoreException{
    IJavaProject javaProject = (IJavaProject)project.getNature(JavaCore.NATURE_ID);
    ArrayList<IClasspathEntry> newClassPathArrayList = new ArrayList<IClasspathEntry>();
    IClasspathEntry[] previousentries = javaProject.getRawClasspath();
    for(IClasspathEntry previousentry : previousentries){
        newClassPathArrayList.add(previousentry);
    }
    if(!newClassPathArrayList.contains(newEntry)){
        newClassPathArrayList.add(newEntry);
        IClasspathEntry[] newClassPath = new IClasspathEntry[newClassPathArrayList.size()];
        javaProject.setRawClasspath(newClassPathArrayList.toArray(newClassPath), monitor);
    }
}

@Test
public void project() throws Exception {
    URI uri = URI.createPlatformResourceURI("/myProject", true);
    IResource iResource = UriUtils.toIResource(uri);

    assertTrue(iResource instanceof IProject);
    assertTrue(iResource.exists());
    assertEquals("/myProject", iResource.getFullPath().toString());
}

private Pair<Collection<String>, Iterable<java.net.URI>> getChangedDependencies(final IProgressMonitor monitor,
        Set<String> oldNPMs) {

    logger.logInfo(LINE_SINGLE);
    logger.logInfo("Calculating dependency changes... [step 2 of 4]");
    monitor.setTaskName("Calculating dependency changes... [step 2 of 4]");

    externalLibraryWorkspace.updateState();
    URI targetPlatformNodeModulesLocation = locationProvider.getTargetPlatformNodeModulesLocation();

    Map<String, String> afterDependencies = locationProvider.getTargetPlatformContent().dependencies;
    if (null == afterDependencies) {
        afterDependencies = newHashMap();
    }
    final Set<String> newDependencies = new HashSet<>(afterDependencies.keySet());

    Set<String> newNpmProjectNames = new HashSet<>();
    Iterable<IProject> newNPMs = externalLibraryWorkspace.getProjects(targetPlatformNodeModulesLocation);
    for (IProject newNPM : newNPMs) {
        newNpmProjectNames.add(newNPM.getName());
    }

    Set<String> overwrittenShippedLibNames = getOverwrittenShippedLibs(newNpmProjectNames);
    newDependencies.addAll(overwrittenShippedLibNames);

    final Collection<String> addedDependencies = difference(newDependencies, oldNPMs);
    final Collection<String> deletedDependencies = difference(oldNPMs, newDependencies);
    final File nodeModulesFolder = new File(targetPlatformNodeModulesLocation);
    final Iterable<java.net.URI> toBeDeleted = from(deletedDependencies)
            .transform(name -> new File(nodeModulesFolder, name).toURI());
    monitor.worked(1);
    logger.logInfo("Dependency changes have been successfully calculated.");

    Pair<Collection<String>, Iterable<java.net.URI>> changedDeps = Tuples.pair(addedDependencies, toBeDeleted);

    return changedDeps;
}

public static IProject getProject(final ExecutionEvent event) {
    final ISelection selection = HandlerUtil.getCurrentSelection(event);
    if (selection instanceof IStructuredSelection) {
        final Object element = ((IStructuredSelection) selection)
                .getFirstElement();

        return Platform.getAdapterManager().getAdapter(element,
                IProject.class);
    }

    return null;
}

@Override
public void earlyStartup() {
    // This will automatically register the proper listeners to keep the different working set managers in sync.
    workingSetManagerBroker.getWorkingSetManagers();

    // Listener to refresh navigator on project creation or on open/close event.
    getWorkspace().addResourceChangeListener(event -> {
        if (event != null && event.getDelta() != null) {
            try {
                event.getDelta().accept(delta -> {
                    final IResource resource = delta.getResource();
                    if (resource instanceof IWorkspaceRoot) {
                        return true;
                    } else if (resource instanceof IProject) {
                        if (ADDED == delta.getKind()
                                || (CHANGED == delta.getKind() && (delta.getFlags() & OPEN) != 0)) {
                            workingSetManagerBroker.refreshNavigator();
                        }
                    }
                    return false;
                });
            } catch (final CoreException e) {
                LOGGER.error("Error occurred while visiting resource delta.", e);
            }
        }
    });
}

protected void addDSAProjectToConf(String projectName,IProject gemocLanguageIProject) {
    ManifestChanger manifestChanger = new ManifestChanger(gemocLanguageIProject);
    try {
        manifestChanger.addPluginDependency(projectName);
        manifestChanger.commit();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

public static IJavaProject createProject(String name) throws CoreException {

        IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
        IProject project = root.getProject(name);
        if (!project.exists()) {
            project.create(new NullProgressMonitor());
        } else {
            project.refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor());
        }

        if (!project.isOpen()) {
            project.open(new NullProgressMonitor());
        }

        IFolder binFolder = project.getFolder("bin");
        if (!binFolder.exists()) {
            createFolder(binFolder, false, true, new NullProgressMonitor());
        }
        IPath outputLocation = binFolder.getFullPath();

        addNatureToProject(project, JavaCore.NATURE_ID, new NullProgressMonitor());

        IJavaProject jproject = JavaCore.create(project);
        jproject.setOutputLocation(outputLocation, new NullProgressMonitor());

        IClasspathEntry[] entries = PreferenceConstants.getDefaultJRELibrary();

        jproject.setRawClasspath(entries, new NullProgressMonitor());

        return jproject;
    }