Example usage for org.eclipse.jdt.core IJavaElement JAVA_PROJECT

List of usage examples for org.eclipse.jdt.core IJavaElement JAVA_PROJECT

  1. HOME
  2. Java
  3. org.eclipse.jdt
  4. org.eclipse.jdt.core.*
  5. IJavaElement
  6. JAVA_PROJECT

Introduction

In this page you can find the example usage for org.eclipse.jdt.core IJavaElement JAVA_PROJECT.

Prototype

int JAVA_PROJECT

To view the source code for org.eclipse.jdt.core IJavaElement JAVA_PROJECT.

Click Source Link

Document

Constant representing a Java project.

Usage

From source file:org.eclipse.emf.cdo.releng.apireports.ApiReportsActor.java

License:Open Source License

public static ApiScope walkStructureSelection(List<Object> projects, IProgressMonitor monitor) {
    ApiScope scope = new ApiScope();
    IApiBaseline workspaceBaseline = ApiBaselineManager.getManager().getWorkspaceBaseline();
    if (workspaceBaseline == null) {
        return scope;
    }/*from ww  w . j av a2  s . c o  m*/

    Collections.sort(projects, new Comparator() {
        public int compare(Object o1, Object o2) {
            if (o1 instanceof IJavaElement && o2 instanceof IJavaElement) {
                IJavaElement element = (IJavaElement) o1;
                IJavaElement element2 = (IJavaElement) o2;
                return element.getElementType() - element2.getElementType();
            }

            return 0;
        }
    });

    for (Object project : projects) {
        if (project instanceof IJavaElement) {
            IJavaElement element = (IJavaElement) project;
            IJavaProject javaProject = element.getJavaProject();
            try {
                switch (element.getElementType()) {
                case IJavaElement.COMPILATION_UNIT: {
                    ICompilationUnit compilationUnit = (ICompilationUnit) element;
                    IApiComponent apiComponent = workspaceBaseline
                            .getApiComponent(javaProject.getElementName());
                    if (apiComponent != null) {
                        addElementFor(compilationUnit, apiComponent, scope);
                    }

                    break;
                }
                case IJavaElement.PACKAGE_FRAGMENT: {
                    IPackageFragment fragment = (IPackageFragment) element;
                    IApiComponent apiComponent = workspaceBaseline
                            .getApiComponent(javaProject.getElementName());
                    IPackageFragmentRoot packageFragmentRoot = (IPackageFragmentRoot) fragment
                            .getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
                    boolean isArchive = false;
                    if (packageFragmentRoot != null) {
                        isArchive = packageFragmentRoot.isArchive();
                    }

                    if (apiComponent != null) {
                        addElementFor(fragment, isArchive, apiComponent, scope);
                    }

                    break;
                }
                case IJavaElement.PACKAGE_FRAGMENT_ROOT: {
                    IPackageFragmentRoot fragmentRoot = (IPackageFragmentRoot) element;
                    IApiComponent apiComponent = workspaceBaseline
                            .getApiComponent(javaProject.getElementName());
                    if (apiComponent != null) {
                        addElementFor(fragmentRoot, apiComponent, scope);
                    }

                    break;
                }
                case IJavaElement.JAVA_PROJECT:
                    IApiComponent apiComponent = workspaceBaseline
                            .getApiComponent(javaProject.getElementName());
                    if (apiComponent != null) {
                        scope.addElement(apiComponent);
                    }

                    break;
                }
            } catch (JavaModelException e) {
                ApiPlugin.log(e);
            } catch (CoreException e) {
                ApiPlugin.log(e);
            }
        }
    }

    return scope;
}

From source file:org.eclipse.fx.ide.jdt.core.internal.JavaFXClasspathContainerInitializer.java

License:Open Source License

@Override
public void initialize(IPath containerPath, IJavaProject project) throws CoreException {
    if (isValidJUnitContainerPath(containerPath)) {
        final JavaFXContainer container = getNewContainer(containerPath, project);
        JavaCore.setClasspathContainer(containerPath, new IJavaProject[] { project },
                new IClasspathContainer[] { container }, null);
    }//from  w ww.  j a v  a2s . c  o  m

    // register update hook
    IElementChangedListener listener = new IElementChangedListener() {

        @Override
        public void elementChanged(ElementChangedEvent event) {
            if (event.getDelta().getKind() == IJavaElementDelta.CHANGED && (event.getDelta().getFlags()
                    & IJavaElementDelta.F_CHILDREN) == IJavaElementDelta.F_CHILDREN) {
                // change on JavaModel
                for (IJavaElementDelta delta : event.getDelta().getAffectedChildren()) {
                    if ((delta.getFlags()
                            & IJavaElementDelta.F_CLASSPATH_CHANGED) == IJavaElementDelta.F_CLASSPATH_CHANGED) {
                        // classpath change on ??
                        if (delta.getElement().getElementType() == IJavaElement.JAVA_PROJECT
                                && delta.getElement().getJavaProject().equals(project)) {
                            // classpath change
                            try {
                                requestClasspathContainerUpdate(containerPath, project, null);
                            } catch (CoreException e) {
                                e.printStackTrace();
                            }
                        }

                    }
                }

            }
        }
    };
    JavaCore.addElementChangedListener(listener);
    // TODO remove listener

}

From source file:org.eclipse.gmf.tests.JDTUtil.java

License:Open Source License

private void collectProblems(IJavaElement jElement, IMemberProcessor[] processors) {
    try {//from www. j a  v  a 2  s  . c om
        switch (jElement.getElementType()) {
        case IJavaElement.JAVA_PROJECT: {
            IJavaProject jProject = (IJavaProject) jElement;
            IPackageFragmentRoot[] roots = jProject.getPackageFragmentRoots();
            for (int i = 0; i < roots.length; i++) {
                if (roots[i].getKind() == IPackageFragmentRoot.K_SOURCE) {
                    collectProblems(roots[i], processors);
                }
            }
        }
            break;
        case IJavaElement.PACKAGE_FRAGMENT_ROOT: {
            IPackageFragmentRoot root = (IPackageFragmentRoot) jElement;
            IJavaElement[] children = root.getChildren();
            for (int i = 0; i < children.length; i++) {
                collectProblems(children[i], processors);
            }
        }
            break;
        case IJavaElement.PACKAGE_FRAGMENT: {
            IPackageFragment pf = (IPackageFragment) jElement;
            ICompilationUnit[] compilationUnits = pf.getCompilationUnits();
            for (int i = 0; i < compilationUnits.length; i++) {
                collectProblems(compilationUnits[i], processors);
            }
        }
            break;
        case IJavaElement.COMPILATION_UNIT: {
            ICompilationUnit compilationUnit = (ICompilationUnit) jElement;
            IType[] types = compilationUnit.getTypes();
            for (int i = 0; i < types.length; i++) {
                collectProblems(types[i], processors);
            }
        }
            break;
        case IJavaElement.TYPE: {
            IMember member = (IMember) jElement;
            collectProblems(member, processors, false);
        }
            break;
        }
    } catch (JavaModelException e) {
        myAggregator.add(e.getStatus());
    }
}

From source file:org.eclipse.gmt.modisco.jm2t.modelconverter.javamodisco.internal.core.DiscovererFactory.java

License:Open Source License

public IExtendedDiscover createDiscoverer(IJavaElement element) {
    int type = element.getElementType();
    switch (type) {
    case IJavaElement.JAVA_PROJECT:
        return new ExtendedDiscoverJavaModelFromJavaProject((IJavaProject) element);
    case IJavaElement.COMPILATION_UNIT:
        return new ExtendedDiscoverJavaModelFromCompilationUnit((ICompilationUnit) element);
    case IJavaElement.CLASS_FILE:
        return new ExtendedDiscoverJavaModelFromClassFile((IClassFile) element);
    case IJavaElement.TYPE:
        return createDiscoverer(element.getParent());
    case IJavaElement.PACKAGE_FRAGMENT:
        IPackageFragment packageFragment = (IPackageFragment) element;
        break;/*from w  w w  .  j  a v a  2s . c  o m*/
    case IJavaElement.PACKAGE_FRAGMENT_ROOT:
        // src folder is selected
        IPackageFragmentRoot packageFragmentRoot = (IPackageFragmentRoot) element;
        return createDiscoverer(packageFragmentRoot.getParent());
    }
    return null;
}

From source file:org.eclipse.imp.ui.explorer.ProjectExplorerActionGroup.java

License:Open Source License

private boolean isGoIntoTarget(Object element) {
    if (element == null)
        return false;
    if (element instanceof IJavaElement) {
        int type = ((IJavaElement) element).getElementType();
        return type == IJavaElement.JAVA_PROJECT || type == IJavaElement.PACKAGE_FRAGMENT_ROOT
                || type == IJavaElement.PACKAGE_FRAGMENT;
    }//from   w w  w.  j a v  a  2  s. co  m
    if (element instanceof IWorkingSet) {
        return true;
    }
    return false;
}

From source file:org.eclipse.jdt.internal.core.JavaModelManager.java

License:Open Source License

public synchronized Object removeInfoAndChildren(JavaElement element) throws JavaModelException {
    Object info = this.cache.peekAtInfo(element);
    if (info != null) {
        boolean wasVerbose = false;
        try {/*from  ww  w  .  j  a v  a2  s .  c  om*/
            if (JavaModelCache.VERBOSE) {
                String elementType;
                switch (element.getElementType()) {
                case IJavaElement.JAVA_PROJECT:
                    elementType = "project"; //$NON-NLS-1$
                    break;
                case IJavaElement.PACKAGE_FRAGMENT_ROOT:
                    elementType = "root"; //$NON-NLS-1$
                    break;
                case IJavaElement.PACKAGE_FRAGMENT:
                    elementType = "package"; //$NON-NLS-1$
                    break;
                case IJavaElement.CLASS_FILE:
                    elementType = "class file"; //$NON-NLS-1$
                    break;
                case IJavaElement.COMPILATION_UNIT:
                    elementType = "compilation unit"; //$NON-NLS-1$
                    break;
                default:
                    elementType = "element"; //$NON-NLS-1$
                }
                System.out.println(Thread.currentThread() + " CLOSING " + elementType + " " //$NON-NLS-1$//$NON-NLS-2$
                        + element.toStringWithAncestors());
                wasVerbose = true;
                JavaModelCache.VERBOSE = false;
            }
            element.closing(info);
            if (element instanceof IParent) {
                closeChildren(info);
            }
            this.cache.removeInfo(element);
            if (wasVerbose) {
                System.out.println(this.cache.toStringFillingRation("-> ")); //$NON-NLS-1$
            }
        } finally {
            JavaModelCache.VERBOSE = wasVerbose;
        }
        return info;
    }
    return null;
}

From source file:org.eclipse.jdt.internal.core.JavaProject.java

License:Open Source License

public boolean isOnClasspath(IJavaElement element) {
    IClasspathEntry[] rawClasspath;/*from  w  w w. ja v  a2  s.com*/
    try {
        rawClasspath = getRawClasspath();
    } catch (JavaModelException e) {
        return false; // not a Java project
    }
    int elementType = element.getElementType();
    boolean isPackageFragmentRoot = false;
    boolean isFolderPath = false;
    boolean isSource = false;
    switch (elementType) {
    case IJavaElement.JAVA_MODEL:
        return false;
    case IJavaElement.JAVA_PROJECT:
        break;
    case IJavaElement.PACKAGE_FRAGMENT_ROOT:
        isPackageFragmentRoot = true;
        break;
    case IJavaElement.PACKAGE_FRAGMENT:
        isFolderPath = !((IPackageFragmentRoot) element.getParent()).isArchive();
        break;
    case IJavaElement.COMPILATION_UNIT:
        isSource = true;
        break;
    default:
        isSource = element.getAncestor(IJavaElement.COMPILATION_UNIT) != null;
        break;
    }
    IPath elementPath = element.getPath();

    // first look at unresolved entries
    int length = rawClasspath.length;
    for (int i = 0; i < length; i++) {
        IClasspathEntry entry = rawClasspath[i];
        switch (entry.getEntryKind()) {
        case IClasspathEntry.CPE_LIBRARY:
        case IClasspathEntry.CPE_PROJECT:
        case IClasspathEntry.CPE_SOURCE:
            if (isOnClasspathEntry(elementPath, isFolderPath, isPackageFragmentRoot, entry))
                return true;
            break;
        }
    }

    // no need to go further for compilation units and elements inside a compilation unit
    // it can only be in a source folder, thus on the raw classpath
    if (isSource)
        return false;

    // https://bugs.eclipse.org/bugs/show_bug.cgi?id=304081
    // All the resolved classpath entries need to be considered, including the referenced classpath entries
    IClasspathEntry[] resolvedClasspath = null;
    try {
        resolvedClasspath = getResolvedClasspath();
    } catch (JavaModelException e) {
        return false; // Perhaps, not a Java project
    }

    for (int index = 0; index < resolvedClasspath.length; index++) {
        if (isOnClasspathEntry(elementPath, isFolderPath, isPackageFragmentRoot, resolvedClasspath[index]))
            return true;
    }

    return false;
}

From source file:org.eclipse.jdt.internal.core.search.matching.MatchLocator.java

License:Open Source License

private boolean filterEnum(SearchMatch match) {

    // filter org.apache.commons.lang.enum package for projects above 1.5 
    // https://bugs.eclipse.org/bugs/show_bug.cgi?id=317264   
    IJavaElement element = (IJavaElement) match.getElement();
    PackageFragment pkg = (PackageFragment) element.getAncestor(IJavaElement.PACKAGE_FRAGMENT);
    if (pkg != null) {
        // enum was found in org.apache.commons.lang.enum at index 5
        if (pkg.names.length == 5 && pkg.names[4].equals("enum")) { //$NON-NLS-1$
            if (this.options == null) {
                IJavaProject proj = (IJavaProject) pkg.getAncestor(IJavaElement.JAVA_PROJECT);
                String complianceStr = proj.getOption(CompilerOptions.OPTION_Source, true);
                if (CompilerOptions.versionToJdkLevel(complianceStr) >= ClassFileConstants.JDK1_5)
                    return true;
            } else if (this.options.sourceLevel >= ClassFileConstants.JDK1_5) {
                return true;
            }//from w  w w .  jav  a2s. co  m
        }
    }
    return false;
}

From source file:org.eclipse.jem.workbench.utility.JavaModelListener.java

License:Open Source License

/**
 * Dispatch the java element delta. This method should normally not be overridden. One
 * usage would be to add delta types that are to be processed and dispatched by the
 * subclasses. For example also dispatch on {@link IJavaElement#IMPORT_CONTAINER}. Subclasses
 * should call <code>super.processDelta(IJavaElementDelta)</code> if it is not one they
 * are interested in./*from www.  ja va  2s  .c om*/
 * 
 * @param delta
 * 
 * @since 1.2.0
 */
public void processDelta(IJavaElementDelta delta) {
    IJavaElement element = delta.getElement();
    // if the class path has changed we refresh the resolved container cache
    int flags = delta.getFlags();
    if (((flags & IJavaElementDelta.F_RESOLVED_CLASSPATH_CHANGED) != 0) && !resolvedContainers.isEmpty()) {
        resolvedContainers.clear();
    }

    switch (element.getElementType()) {
    case IJavaElement.JAVA_MODEL:
        processJavaElementChanged((IJavaModel) element, delta);
        break;
    case IJavaElement.JAVA_PROJECT:
        processJavaElementChanged((IJavaProject) element, delta);
        break;
    case IJavaElement.PACKAGE_FRAGMENT_ROOT:
        processJavaElementChanged((IPackageFragmentRoot) element, delta);
        break;
    case IJavaElement.PACKAGE_FRAGMENT:
        processJavaElementChanged((IPackageFragment) element, delta);
        break;
    case IJavaElement.COMPILATION_UNIT:
        processJavaElementChanged((ICompilationUnit) element, delta);
        processContentChanged(delta);
        break;
    case IJavaElement.CLASS_FILE:
        processJavaElementChanged((IClassFile) element, delta);
        break;
    case IJavaElement.TYPE:
        processJavaElementChanged((IType) element, delta);
        break;
    // Note: if we are to update the Method/Field adapters, we should process the
    // IJavaElement.METHOD and IJavaElement.FIELD
    }
}

From source file:org.eclipse.jpt.common.core.tests.internal.resource.java.JavaResourceModelTestCase.java

License:Open Source License

/**
 * NB: this is copied from GenericJpaProject, so it might need to be
 * kept in synch with that code if it changes... yech...
 *//* ww  w .  j a va 2 s .  c  o  m*/
protected void syncWithJavaDelta(IJavaElementDelta delta) {
    switch (delta.getElement().getElementType()) {
    case IJavaElement.JAVA_MODEL:
    case IJavaElement.JAVA_PROJECT:
    case IJavaElement.PACKAGE_FRAGMENT_ROOT:
    case IJavaElement.PACKAGE_FRAGMENT:
        this.syncWithJavaDeltaChildren(delta);
        break;
    case IJavaElement.COMPILATION_UNIT:
        this.javaCompilationUnitChanged(delta);
        break;
    default:
        break; // ignore the elements inside a compilation unit
    }
}