Example usage for org.eclipse.jdt.core IJavaProject getRequiredProjectNames

List of usage examples for org.eclipse.jdt.core IJavaProject getRequiredProjectNames

  1. HOME
  2. Java
  3. org.eclipse.jdt
  4. org.eclipse.jdt.core.*
  5. IJavaProject
  6. getRequiredProjectNames

Introduction

In this page you can find the example usage for org.eclipse.jdt.core IJavaProject getRequiredProjectNames.

Prototype

String[] getRequiredProjectNames() throws JavaModelException;

Source Link

Document

Returns the names of the projects that are directly required by this project.

Usage

From source file:jp.co.dgic.eclipse.jdt.internal.junit.launcher.DJUnitLaunchConfiguration.java

License:Open Source License

private void findSourceDirs(IJavaProject javaProject, Set<IPath> sourceDirs, Set<String> checkedProjects)
        throws CoreException {

    // check cycle reference
    if (checkedProjects.contains(javaProject.getProject().getName()))
        return;//from   w ww.ja  v  a 2 s  .  com
    checkedProjects.add(javaProject.getProject().getName());

    findSourceDirFrom(javaProject, sourceDirs);
    try {
        String[] names = javaProject.getRequiredProjectNames();
        for (int i = 0; i < names.length; i++) {
            IJavaProject requiredProject = javaProject.getJavaModel().getJavaProject(names[i]);
            findSourceDirs(requiredProject, sourceDirs, checkedProjects);
        }
    } catch (JavaModelException e) {
        e.printStackTrace();
    }
}

From source file:net.rim.ejde.internal.util.ProjectUtils.java

License:Open Source License

private static void addReferencedProjects(IProject project, Set<IProject> references) throws CoreException {
    if (project.isOpen()) {
        IJavaProject javaProject = JavaCore.create(project);
        String[] requiredProjectNames = javaProject.getRequiredProjectNames();
        IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();
        IProject requiredProject = null;
        for (String projectName : requiredProjectNames) {
            requiredProject = workspaceRoot.getProject(projectName);
            if (requiredProject.exists() && requiredProject.isOpen() && !references.contains(requiredProject)) {
                references.add(requiredProject);
                addReferencedProjects(requiredProject, references);
            }/*from w  ww .java  2s  . co m*/
        }
    }
}

From source file:net.sf.refactorit.eclipse.EclipseWorkspaceManager.java

License:Open Source License

public List getReferencedInProjects(Object projectIdentificator) {
    BidirectionalMap ideProjects = getWorkspace().getIdeProjects();
    Set ideProjectSet = ideProjects.getValueSetCopy();
    ArrayList referencedProjects = new ArrayList(3);

    for (Iterator it = ideProjectSet.iterator(); it.hasNext();) {
        IProject ideProject = (IProject) it.next();

        if (hasJavaNature(ideProject)) {
            // accept only java projects
            IJavaProject javaProject = JavaCore.create(ideProject);
            try {
                String[] requiredProjectKeys = javaProject.getRequiredProjectNames();

                if (Arrays.asList(requiredProjectKeys).contains(projectIdentificator)) {
                    referencedProjects.add(getWorkspace().getProject(ideProject));
                }/*from  w  ww .j a  v a  2s .  c o m*/
            } catch (JavaModelException e) {
                // should not happen
                e.printStackTrace();
            }
        }
    }

    return referencedProjects;
}

From source file:net.sf.refactorit.eclipse.EclipseWorkspaceManager.java

License:Open Source License

public List getDependsOnProjects(Object projectIdentificator) {
    BidirectionalMap ideProjects = getWorkspace().getIdeProjects();
    IProject project = (IProject) ideProjects.getValueByKey(projectIdentificator);

    if (project == null) {
        throw new RuntimeException("Specified project (" + projectIdentificator + ") cannot be located");
    }//from  ww  w  .  ja v a 2s . com

    ArrayList dependentProjects = new ArrayList(3);

    try {
        IJavaProject javaProject = JavaCore.create(project);
        String[] requiredProjectKeys = javaProject.getRequiredProjectNames();

        for (int i = 0; i < requiredProjectKeys.length; i++) {
            Object candidateProject = ideProjects.getValueByKey(requiredProjectKeys[i]);

            if (candidateProject == null) {
                continue;
            }

            dependentProjects.add(getWorkspace().getProject(candidateProject));
        }
    } catch (JavaModelException e) {
        e.printStackTrace();
    }

    return dependentProjects;
}

From source file:org.cloudfoundry.ide.eclipse.server.standalone.internal.application.JavaPackageFragmentRootHandler.java

License:Open Source License

protected void getOrderedJavaProjectNames(List<String> sameLevelRequiredProjects,
        List<String> collectedProjects) {
    // The order in which required projects are collected is as follows,
    // with the RHS
    // being required projects of the LHS
    // A -> BC
    // B -> D/*w  ww .  j  a v a  2 s  .  c  o  m*/
    // C -> E
    // = total 5 projects, added in the order that they are encountered.
    // so final ordered list should be ABCDE
    if (sameLevelRequiredProjects == null) {
        return;
    }
    List<String> nextLevelRequiredProjects = new ArrayList<String>();
    // First add the current level java projects in the order they appear
    // and also collect each one's required names.
    for (String name : sameLevelRequiredProjects) {
        try {
            IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(name);
            if (project != null) {
                IJavaProject jvPrj = JavaCore.create(project);
                if (jvPrj != null && jvPrj.exists()) {
                    if (!collectedProjects.contains(name)) {
                        collectedProjects.add(name);
                    }
                    String[] names = jvPrj.getRequiredProjectNames();
                    if (names != null && names.length > 0) {
                        for (String reqName : names) {
                            if (!nextLevelRequiredProjects.contains(reqName)) {
                                nextLevelRequiredProjects.add(reqName);
                            }
                        }
                    }
                }
            }

        } catch (JavaModelException e) {
            CloudFoundryPlugin.logError(e);
        }

    }

    // Now recurse to fetch the required projects for the
    // list of java projects that were added at the current level above
    if (!nextLevelRequiredProjects.isEmpty()) {
        getOrderedJavaProjectNames(nextLevelRequiredProjects, collectedProjects);

    }
}

From source file:org.compiere.mfg_scm.eclipse.db.DbfLauncherPlugin.java

License:Apache License

private List computeProjectsInSourcePath() {
    IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
    IProject[] allProjects = root.getProjects();
    ArrayList tempList = new ArrayList(allProjects.length);

    ArrayList alreadyAdded = new ArrayList();

    for (int i = 0; i < allProjects.length; i++) {
        IProject project = allProjects[i];
        try {/*w w  w  .  ja  v  a2s.  c o  m*/
            if ((project.isOpen()) && project.hasNature(NATURE_ID)) {
                IJavaProject javaProject = (IJavaProject) project.getNature(JavaCore.NATURE_ID);
                if (!alreadyAdded.contains(project)) {
                    tempList.add(new ProjectListElement(javaProject.getProject()));
                    alreadyAdded.add(project);
                }
                String[] reqProjects = javaProject.getRequiredProjectNames();

                for (int j = 0; j < allProjects.length; j++) {
                    for (int k = 0; k < reqProjects.length; k++) {
                        if (allProjects[j].getName().equals(reqProjects[k])) {
                            if ((allProjects[j].isOpen()) && allProjects[j].hasNature(JavaCore.NATURE_ID)) {
                                if (!alreadyAdded.contains(allProjects[j])) {
                                    tempList.add(new ProjectListElement(
                                            allProjects[j].getNature(JavaCore.NATURE_ID).getProject()));
                                    alreadyAdded.add(allProjects[j]);
                                }
                            }
                        }
                    }
                }

            }
        } catch (CoreException e) {
            DbfLauncherPlugin.log(e);
        }
    }
    return tempList;
}

From source file:org.drools.eclipse.util.ProjectClassLoader.java

License:Apache License

public static List<URL> getProjectClassPathURLs(IJavaProject project, List<String> alreadyLoadedProjects) {
    List<URL> pathElements = new ArrayList<URL>();
    try {/*from   ww  w  .  jav a 2 s. c o  m*/
        IClasspathEntry[] paths = project.getResolvedClasspath(true);
        Set<IPath> outputPaths = new HashSet<IPath>();
        if (paths != null) {
            for (int i = 0; i < paths.length; i++) {
                IClasspathEntry path = paths[i];
                if (path.getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
                    URL url = getRawLocationURL(path.getPath());
                    pathElements.add(url);
                } else if (path.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
                    IPath output = path.getOutputLocation();
                    if (path.getOutputLocation() != null) {
                        outputPaths.add(output);
                    }
                }
            }
        }
        IPath location = getProjectLocation(project.getProject());
        IPath outputPath = location.append(project.getOutputLocation().removeFirstSegments(1));
        pathElements.add(0, outputPath.toFile().toURI().toURL());
        for (IPath path : outputPaths) {
            outputPath = location.append(path.removeFirstSegments(1));
            pathElements.add(0, outputPath.toFile().toURI().toURL());
        }

        // also add classpath of required projects
        for (String projectName : project.getRequiredProjectNames()) {
            if (!alreadyLoadedProjects.contains(projectName)) {
                alreadyLoadedProjects.add(projectName);
                IProject reqProject = project.getProject().getWorkspace().getRoot().getProject(projectName);
                if (reqProject != null) {
                    IJavaProject reqJavaProject = JavaCore.create(reqProject);
                    pathElements.addAll(getProjectClassPathURLs(reqJavaProject, alreadyLoadedProjects));
                }
            }
        }
    } catch (JavaModelException e) {
        DroolsEclipsePlugin.log(e);
    } catch (MalformedURLException e) {
        DroolsEclipsePlugin.log(e);
    } catch (Throwable t) {
        DroolsEclipsePlugin.log(t);
    }
    return pathElements;
}

From source file:org.eclipse.acceleo.internal.ide.ui.builders.AcceleoBuilder.java

License:Open Source License

/**
 * Computes the project dependencies of the given Acceleo project matching the given Java project.
 * /*from  w w w  .j ava 2s.  c  o  m*/
 * @param acceleoProject
 *            The Acceleo project.
 * @param javaProject
 *            The Java project.
 * @return The Acceleo project with its dependencies resolved.
 */
private org.eclipse.acceleo.internal.parser.compiler.AcceleoProject computeProjectDependencies(
        org.eclipse.acceleo.internal.parser.compiler.AcceleoProject acceleoProject, IJavaProject javaProject) {
    this.mappedProjects.put(javaProject, acceleoProject);
    try {
        // Required projects
        String[] requiredProjectNames = javaProject.getRequiredProjectNames();
        for (String requiredProjectName : requiredProjectNames) {
            IProject requiredProject = ResourcesPlugin.getWorkspace().getRoot().getProject(requiredProjectName);
            try {
                if (requiredProject.isAccessible() && requiredProject.hasNature(JavaCore.NATURE_ID)
                        && requiredProject.hasNature(IAcceleoConstants.ACCELEO_NATURE_ID)) {
                    IJavaProject requiredJavaProject = JavaCore.create(requiredProject);
                    File projectRoot = requiredProject.getLocation().toFile();

                    org.eclipse.acceleo.internal.parser.compiler.AcceleoProject mappedProject = this.mappedProjects
                            .get(requiredJavaProject);
                    if (mappedProject != null) {
                        acceleoProject.addProjectDependencies(Sets.newHashSet(mappedProject));
                    } else {
                        Set<AcceleoProjectClasspathEntry> entries = this
                                .computeProjectClassPath(requiredJavaProject);
                        org.eclipse.acceleo.internal.parser.compiler.AcceleoProject requiredAcceleoProject = new org.eclipse.acceleo.internal.parser.compiler.AcceleoProject(
                                projectRoot, entries);
                        if (!acceleoProject.getProjectDependencies().contains(requiredAcceleoProject)) {
                            acceleoProject.addProjectDependencies(Sets.newHashSet(requiredAcceleoProject));
                            requiredAcceleoProject = this.computeProjectDependencies(requiredAcceleoProject,
                                    requiredJavaProject);
                        }
                    }

                }
            } catch (CoreException e) {
                AcceleoUIActivator.log(e, true);
            }
        }

        // Requiring projects
        IProject[] projects = ResourcesPlugin.getWorkspace().getRoot().getProjects();
        for (IProject iProject : projects) {
            try {
                if (iProject.isAccessible() && iProject.hasNature(JavaCore.NATURE_ID)
                        && iProject.hasNature(IAcceleoConstants.ACCELEO_NATURE_ID)) {
                    IJavaProject iJavaProject = JavaCore.create(iProject);
                    boolean requiring = false;

                    String[] projectNames = iJavaProject.getRequiredProjectNames();
                    for (String projectName : projectNames) {
                        IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName);
                        if (acceleoProject.getProjectRoot().equals(project.getLocation().toFile())) {
                            requiring = true;
                        }
                    }

                    org.eclipse.acceleo.internal.parser.compiler.AcceleoProject mappedProject = this.mappedProjects
                            .get(iJavaProject);
                    if (requiring && mappedProject != null) {
                        acceleoProject.addDependentProjects(Sets.newHashSet(mappedProject));
                    } else if (requiring && mappedProject == null) {
                        Set<AcceleoProjectClasspathEntry> entries = this.computeProjectClassPath(iJavaProject);
                        org.eclipse.acceleo.internal.parser.compiler.AcceleoProject requiringAcceleoProject = new org.eclipse.acceleo.internal.parser.compiler.AcceleoProject(
                                iProject.getLocation().toFile(), entries);
                        if (!acceleoProject.getDependentProjects().contains(requiringAcceleoProject)) {
                            acceleoProject.addDependentProjects(Sets.newHashSet(requiringAcceleoProject));
                            requiringAcceleoProject = this.computeProjectDependencies(requiringAcceleoProject,
                                    iJavaProject);
                        }
                    }

                }
            } catch (CoreException e) {
                AcceleoUIActivator.log(e, true);
            }
        }
    } catch (JavaModelException e) {
        AcceleoUIActivator.log(e, true);
    }
    return acceleoProject;
}

From source file:org.eclipse.andmore.internal.project.ProjectHelper.java

License:Open Source License

/**
 * Find the list of projects on which this JavaProject is dependent on at the compilation level.
 *
 * @param javaProject Java project that we are looking for the dependencies.
 * @return A list of Java projects for which javaProject depend on.
 * @throws JavaModelException/*from  w w  w.ja  v  a 2  s  .c  o  m*/
 */
public static List<IJavaProject> getAndroidProjectDependencies(IJavaProject javaProject)
        throws JavaModelException {
    String[] requiredProjectNames = javaProject.getRequiredProjectNames();

    // Go from java project name to JavaProject name
    IJavaModel javaModel = javaProject.getJavaModel();

    // loop through all dependent projects and keep only those that are Android projects
    List<IJavaProject> projectList = new ArrayList<IJavaProject>(requiredProjectNames.length);
    for (String javaProjectName : requiredProjectNames) {
        IJavaProject androidJavaProject = javaModel.getJavaProject(javaProjectName);

        //Verify that the project has also the Android Nature
        try {
            if (!androidJavaProject.getProject().hasNature(AndmoreAndroidConstants.NATURE_DEFAULT)) {
                continue;
            }
        } catch (CoreException e) {
            continue;
        }

        projectList.add(androidJavaProject);
    }

    return projectList;
}

From source file:org.eclipse.jst.j2ee.internal.common.operations.UpdateJavaBuildPathOperation.java

License:Open Source License

protected void updateRequiredProjects(IJavaProject jproject, String[] prevRequiredProjects,
        IProgressMonitor monitor) throws CoreException {
    String[] newRequiredProjects = jproject.getRequiredProjectNames();

    ArrayList prevEntries = new ArrayList(Arrays.asList(prevRequiredProjects));
    ArrayList newEntries = new ArrayList(Arrays.asList(newRequiredProjects));

    IProject proj = jproject.getProject();
    IProjectDescription projDesc = proj.getDescription();

    ArrayList newRefs = new ArrayList();
    IProject[] referencedProjects = projDesc.getReferencedProjects();
    for (int i = 0; i < referencedProjects.length; i++) {
        String curr = referencedProjects[i].getName();
        if (newEntries.remove(curr) || !prevEntries.contains(curr)) {
            newRefs.add(referencedProjects[i]);
        }/*from  w w w. j  a v  a2s  .c o m*/
    }
    IWorkspaceRoot root = proj.getWorkspace().getRoot();
    for (int i = 0; i < newEntries.size(); i++) {
        String curr = (String) newEntries.get(i);
        newRefs.add(root.getProject(curr));
    }
    projDesc.setReferencedProjects((IProject[]) newRefs.toArray(new IProject[newRefs.size()]));
    proj.setDescription(projDesc, monitor);
}