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

Introduction

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

Prototype

int JAVA_MODEL

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

Click Source Link

Document

Constant representing a Java model (workspace level object).

Usage

From source file:at.bestsolution.fxide.jdt.text.viewersupport.JavaElementLabelComposer.java

License:Open Source License

/**
 * Appends the label for a Java element with the flags as defined by this class.
 *
 * @param element the element to render/*from  w  ww  . ja v  a2 s  . co  m*/
 * @param flags the rendering flags.
 */
public void appendElementLabel(IJavaElement element, long flags) {
    int type = element.getElementType();
    IPackageFragmentRoot root = null;

    if (type != IJavaElement.JAVA_MODEL && type != IJavaElement.JAVA_PROJECT
            && type != IJavaElement.PACKAGE_FRAGMENT_ROOT)
        root = JavaModelUtil.getPackageFragmentRoot(element);
    if (root != null && getFlag(flags, JavaElementLabels.PREPEND_ROOT_PATH)) {
        appendPackageFragmentRootLabel(root, JavaElementLabels.ROOT_QUALIFIED);
        fBuffer.append(JavaElementLabels.CONCAT_STRING);
    }

    switch (type) {
    case IJavaElement.METHOD:
        appendMethodLabel((IMethod) element, flags);
        break;
    case IJavaElement.FIELD:
        appendFieldLabel((IField) element, flags);
        break;
    case IJavaElement.LOCAL_VARIABLE:
        appendLocalVariableLabel((ILocalVariable) element, flags);
        break;
    case IJavaElement.TYPE_PARAMETER:
        appendTypeParameterLabel((ITypeParameter) element, flags);
        break;
    case IJavaElement.INITIALIZER:
        appendInitializerLabel((IInitializer) element, flags);
        break;
    case IJavaElement.TYPE:
        appendTypeLabel((IType) element, flags);
        break;
    case IJavaElement.CLASS_FILE:
        appendClassFileLabel((IClassFile) element, flags);
        break;
    case IJavaElement.COMPILATION_UNIT:
        appendCompilationUnitLabel((ICompilationUnit) element, flags);
        break;
    case IJavaElement.PACKAGE_FRAGMENT:
        appendPackageFragmentLabel((IPackageFragment) element, flags);
        break;
    case IJavaElement.PACKAGE_FRAGMENT_ROOT:
        appendPackageFragmentRootLabel((IPackageFragmentRoot) element, flags);
        break;
    case IJavaElement.IMPORT_CONTAINER:
    case IJavaElement.IMPORT_DECLARATION:
    case IJavaElement.PACKAGE_DECLARATION:
        appendDeclarationLabel(element, flags);
        break;
    case IJavaElement.JAVA_PROJECT:
    case IJavaElement.JAVA_MODEL:
        fBuffer.append(element.getElementName());
        break;
    default:
        fBuffer.append(element.getElementName());
    }

    if (root != null && getFlag(flags, JavaElementLabels.APPEND_ROOT_PATH)) {
        int offset = fBuffer.length();
        fBuffer.append(JavaElementLabels.CONCAT_STRING);
        appendPackageFragmentRootLabel(root, JavaElementLabels.ROOT_QUALIFIED);

        //         if (getFlag(flags, JavaElementLabels.COLORIZE)) {
        //            fBuffer.setStyle(offset, fBuffer.length() - offset, QUALIFIER_STYLE);
        //         }

    }
}

---

From source file:ca.uvic.chisel.diver.mylyn.logger.logging.PageSelectionListener.java

License:Open Source License

/**
 * @param je/*from w  ww  . j  a va  2s.c om*/
 * @return
 */
private String getElementType(IJavaElement je) {
    switch (je.getElementType()) {
    case IJavaElement.ANNOTATION:
        return "annotation";
    case IJavaElement.CLASS_FILE:
        return "classfile";
    case IJavaElement.COMPILATION_UNIT:
        return "compilationunit";
    case IJavaElement.FIELD:
        return "field";
    case IJavaElement.IMPORT_CONTAINER:
        return "importcontainer";
    case IJavaElement.IMPORT_DECLARATION:
        return "importdeclaration";
    case IJavaElement.INITIALIZER:
        return "initializer";
    case IJavaElement.JAVA_MODEL:
        return "javamodel";
    case IJavaElement.JAVA_PROJECT:
        return "javaproject";
    case IJavaElement.LOCAL_VARIABLE:
        return "localvariable";
    case IJavaElement.METHOD:
        return "method";
    case IJavaElement.PACKAGE_DECLARATION:
        return "packagedeclaration";
    case IJavaElement.PACKAGE_FRAGMENT:
        return "packagefragment";
    case IJavaElement.TYPE:
        return "type";
    case IJavaElement.TYPE_PARAMETER:
        return "typeparameter";
    }
    return "null";
}

---

From source file:com.blackducksoftware.integration.eclipseplugin.internal.listeners.ProjectDependenciesChangedListener.java

License:Apache License

private void visit(final IJavaElementDelta delta) {
    final IJavaElement el = delta.getElement();
    switch (el.getElementType()) {
    case IJavaElement.JAVA_MODEL: {
        visitChildren(delta);/*  w ww.  j  a  v a 2s  .  c  o  m*/
        break;
    }
    case IJavaElement.JAVA_PROJECT: {
        if (isClasspathChanged(delta.getFlags())) {
            visitChildren(delta);
        }
        break;
    }
    case IJavaElement.PACKAGE_FRAGMENT_ROOT: {
        if ((delta.getFlags() & IJavaElementDelta.F_REMOVED_FROM_CLASSPATH) != 0
                || (delta.getKind() & IJavaElementDelta.REMOVED) != 0) {
            try {
                removeDependency(el);
            } catch (final CoreException | MalformedURLException e) {
                e.printStackTrace();
            }
        }
        if ((delta.getFlags() & IJavaElementDelta.F_ADDED_TO_CLASSPATH) != 0
                || (delta.getKind() & IJavaElementDelta.ADDED) != 0) {
            try {
                addDependency(el);
            } catch (final CoreException | MalformedURLException e) {
                e.printStackTrace();
            }
        }
        break;
    }
    default: {
        break;
    }
    }

}

---

From source file:com.blackducksoftware.integration.eclipseplugin.internal.listeners.ProjectDependenciesChangedListenerTest.java

License:Apache License

private void setUpAllStubs() throws CoreException, MalformedURLException {
    Mockito.when(model.getElementType()).thenReturn(IJavaElement.JAVA_MODEL);
    Mockito.when(project.getElementType()).thenReturn(IJavaElement.JAVA_PROJECT);
    Mockito.when(mavenRoot.getElementType()).thenReturn(IJavaElement.PACKAGE_FRAGMENT_ROOT);
    Mockito.when(gradleRoot.getElementType()).thenReturn(IJavaElement.PACKAGE_FRAGMENT_ROOT);
    Mockito.when(nonBinaryRoot.getElementType()).thenReturn(IJavaElement.PACKAGE_FRAGMENT_ROOT);
    Mockito.when(e.getDelta()).thenReturn(modelDelta);
    Mockito.when(modelDelta.getElement()).thenReturn(model);
    Mockito.when(projectDelta.getElement()).thenReturn(project);
    Mockito.when(mavenRootDelta.getElement()).thenReturn(mavenRoot);
    Mockito.when(gradleRootDelta.getElement()).thenReturn(gradleRoot);
    Mockito.when(nonBinaryRootDelta.getElement()).thenReturn(nonBinaryRoot);
    Mockito.when(modelDelta.getAffectedChildren()).thenReturn(new IJavaElementDelta[] { projectDelta });
    Mockito.when(projectDelta.getAffectedChildren())
            .thenReturn(new IJavaElementDelta[] { mavenRootDelta, gradleRootDelta, nonBinaryRootDelta });
    Mockito.when(mavenRoot.getJavaProject()).thenReturn(project);
    Mockito.when(gradleRoot.getJavaProject()).thenReturn(project);
    Mockito.when(nonBinaryRoot.getJavaProject()).thenReturn(project);
    Mockito.when(project.getProject()).thenReturn(parentProject);
    Mockito.when(parentProject.getDescription()).thenReturn(projectDescription);
    Mockito.when(projectDescription.getName()).thenReturn(PROJECT_NAME);
    Mockito.when(gradleRoot.getPath()).thenReturn(gradlePath);
    Mockito.when(mavenRoot.getPath()).thenReturn(mavenPath);
    Mockito.when(nonBinaryRoot.getPath()).thenReturn(nonBinaryPath);
    Mockito.when(gradlePath.toFile().toURI().toURL()).thenReturn(GRADLE_PATH_URL);
    Mockito.when(mavenPath.toFile().toURI().toURL()).thenReturn(MAVEN_PATH_URL);
    Mockito.when(nonBinaryPath.toFile().toURI().toURL()).thenReturn(NON_BINARY_PATH_URL);
    Mockito.when(depService.isMavenDependency(GRADLE_PATH_URL)).thenReturn(false);
    Mockito.when(depService.isGradleDependency(GRADLE_PATH_URL)).thenReturn(true);
    Mockito.when(depService.isMavenDependency(MAVEN_PATH_URL)).thenReturn(true);
    Mockito.when(depService.isGradleDependency(MAVEN_PATH_URL)).thenReturn(false);
    Mockito.when(depService.isMavenDependency(NON_BINARY_PATH_URL)).thenReturn(false);
    Mockito.when(depService.isGradleDependency(NON_BINARY_PATH_URL)).thenReturn(false);
    PowerMockito.mockStatic(JavaCore.class);
    Mockito.when(JavaCore.getClasspathVariable(ClasspathVariables.MAVEN)).thenReturn(mavenRepoPath);
    Mockito.when(mavenRepoPath.toFile().toURI().toURL()).thenReturn(MAVEN_REPO_PATH_URL);
    Mockito.when(extractor.getMavenPathGav(MAVEN_PATH_URL, MAVEN_REPO_PATH_URL)).thenReturn(mavenGav);
    Mockito.when(extractor.getGradlePathGav(GRADLE_PATH_URL)).thenReturn(gradleGav);
    Mockito.when(mavenGav.getGroupId()).thenReturn(MAVEN_GROUP_STRING);
    Mockito.when(mavenGav.getArtifactId()).thenReturn(MAVEN_ARTIFACT_STRING);
    Mockito.when(mavenGav.getVersion()).thenReturn(MAVEN_VERSION_STRING);
    Mockito.when(gradleGav.getGroupId()).thenReturn(GRADLE_GROUP_STRING);
    Mockito.when(gradleGav.getArtifactId()).thenReturn(GRADLE_ARTIFACT_STRING);
    Mockito.when(gradleGav.getVersion()).thenReturn(GRADLE_VERSION_STRING);
}

---

From source file:com.codenvy.ide.ext.java.server.internal.core.DeltaProcessor.java

License:Open Source License

private boolean createExternalArchiveDelta(HashSet refreshedElements, IProgressMonitor monitor) {

    HashMap externalArchivesStatus = new HashMap();
    boolean hasDelta = false;

    // find JARs to refresh
    HashSet archivePathsToRefresh = new HashSet();
    Iterator iterator = refreshedElements.iterator();
    while (iterator.hasNext()) {
        IJavaElement element = (IJavaElement) iterator.next();
        switch (element.getElementType()) {
        case IJavaElement.PACKAGE_FRAGMENT_ROOT:
            archivePathsToRefresh.add(element.getPath());
            break;
        case IJavaElement.JAVA_PROJECT:
            JavaProject javaProject = (JavaProject) element;
            if (!JavaProject.hasJavaNature(javaProject.getProject())) {
                // project is not accessible or has lost its Java nature
                break;
            }/* w  w  w. j  a v a  2s.com*/
            IClasspathEntry[] classpath;
            try {
                classpath = javaProject.getResolvedClasspath();
                for (int j = 0, cpLength = classpath.length; j < cpLength; j++) {
                    if (classpath[j].getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
                        archivePathsToRefresh.add(classpath[j].getPath());
                    }
                }
            } catch (JavaModelException e) {
                // project doesn't exist -> ignore
            }
            break;
        case IJavaElement.JAVA_MODEL:
            //               Iterator projectNames = this.state.getOldJavaProjecNames().iterator();
            //               while (projectNames.hasNext()) {
            //                  String projectName = (String) projectNames.next();
            //                  IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName);
            //                  if (!JavaProject.hasJavaNature(project)) {
            //                     // project is not accessible or has lost its Java nature
            //                     continue;
            //                  }
            //                  javaProject = (JavaProject) JavaCore.create(project);
            //                  try {
            //                     classpath = javaProject.getResolvedClasspath();
            //                     for (int k = 0, cpLength = classpath.length; k < cpLength; k++){
            //                        if (classpath[k].getEntryKind() == IClasspathEntry.CPE_LIBRARY){
            //                           archivePathsToRefresh.add(classpath[k].getPath());
            //                        }
            //                     }
            //                  } catch (JavaModelException e2) {
            //                     // project doesn't exist -> ignore
            //                     continue;
            //                  }
            //               }
            throw new UnsupportedOperationException();
            //               break;
        }
    }

    //      // perform refresh
    //      Iterator projectNames = this.state.getOldJavaProjecNames().iterator();
    //      IWorkspaceRoot wksRoot = ResourcesPlugin.getWorkspace().getRoot();
    //      while (projectNames.hasNext()) {
    //
    //         if (monitor != null && monitor.isCanceled()) break;
    //
    //         String projectName = (String) projectNames.next();
    //         IProject project = wksRoot.getProject(projectName);
    //         if (!JavaProject.hasJavaNature(project)) {
    //            // project is not accessible or has lost its Java nature
    //            continue;
    //         }
    //         JavaProject javaProject = (JavaProject) JavaCore.create(project);
    //         IClasspathEntry[] entries;
    //         try {
    //            entries = javaProject.getResolvedClasspath();
    //         } catch (JavaModelException e1) {
    //            // project does not exist -> ignore
    //            continue;
    //         }
    //         boolean deltaContainsModifiedJar = false;
    //         for (int j = 0; j < entries.length; j++){
    //            if (entries[j].getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
    //               IPath entryPath = entries[j].getPath();
    //
    //               if (!archivePathsToRefresh.contains(entryPath)) continue; // not supposed to be refreshed
    //
    //               String status = (String)externalArchivesStatus.get(entryPath);
    //               if (status == null){
    //
    //                  // Clear the external file state for this path, since this method is responsible for updating it.
    //                  this.manager.clearExternalFileState(entryPath);
    //
    //                  // compute shared status
    //                  Object targetLibrary = JavaModel.getTarget(entryPath, true);
    //
    //                  if (targetLibrary == null){ // missing JAR
    //                     if (this.state.getExternalLibTimeStamps().remove(entryPath) != null /* file was known*/
    //                           && this.state.roots.get(entryPath) != null /* and it was on the classpath*/) {
    //                        externalArchivesStatus.put(entryPath, EXTERNAL_JAR_REMOVED);
    //                        // the jar was physically removed: remove the index
    //                        this.manager.indexManager.removeIndex(entryPath);
    //                     }
    //
    //                  } else if (targetLibrary instanceof File){ // external JAR
    //
    //                     File externalFile = (File)targetLibrary;
    //
    //                     // check timestamp to figure if JAR has changed in some way
    //                     Long oldTimestamp =(Long) this.state.getExternalLibTimeStamps().get(entryPath);
    //                     long newTimeStamp = getTimeStamp(externalFile);
    //                     if (oldTimestamp != null){
    //
    //                        if (newTimeStamp == 0){ // file doesn't exist
    //                           externalArchivesStatus.put(entryPath, EXTERNAL_JAR_REMOVED);
    //                           this.state.getExternalLibTimeStamps().remove(entryPath);
    //                           // remove the index
    //                           this.manager.indexManager.removeIndex(entryPath);
    //
    //                        } else if (oldTimestamp.longValue() != newTimeStamp){
    //                           externalArchivesStatus.put(entryPath, EXTERNAL_JAR_CHANGED);
    //                           this.state.getExternalLibTimeStamps().put(entryPath, new Long(newTimeStamp));
    //                           // first remove the index so that it is forced to be re-indexed
    //                           this.manager.indexManager.removeIndex(entryPath);
    //                           // then index the jar
    //                           this.manager.indexManager.indexLibrary(entryPath, project.getProject(), ((ClasspathEntry)entries[j]).getLibraryIndexLocation(), true);
    //                        } else {
    //                           URL indexLocation = ((ClasspathEntry)entries[j]).getLibraryIndexLocation();
    //                           if (indexLocation != null) { // force reindexing, this could be faster rather than maintaining the list
    //                              this.manager.indexManager.indexLibrary(entryPath, project.getProject(), indexLocation);
    //                           }
    //                           externalArchivesStatus.put(entryPath, EXTERNAL_JAR_UNCHANGED);
    //                        }
    //                     } else {
    //                        if (newTimeStamp == 0){ // jar still doesn't exist
    //                           externalArchivesStatus.put(entryPath, EXTERNAL_JAR_UNCHANGED);
    //                        } else {
    //                           externalArchivesStatus.put(entryPath, EXTERNAL_JAR_ADDED);
    //                           this.state.getExternalLibTimeStamps().put(entryPath, new Long(newTimeStamp));
    //                           // index the new jar
    //                           this.manager.indexManager.removeIndex(entryPath);
    //                           this.manager.indexManager.indexLibrary(entryPath, project.getProject(), ((ClasspathEntry)entries[j]).getLibraryIndexLocation());
    //                        }
    //                     }
    //                  } else { // internal JAR
    //                     externalArchivesStatus.put(entryPath, INTERNAL_JAR_IGNORE);
    //                  }
    //               }
    //               // according to computed status, generate a delta
    //               status = (String)externalArchivesStatus.get(entryPath);
    //               if (status != null){
    //                  if (status == EXTERNAL_JAR_ADDED){
    //                     PackageFragmentRoot root = (PackageFragmentRoot) javaProject.getPackageFragmentRoot(entryPath.toString());
    //                     if (VERBOSE){
    //                        System.out.println("- External JAR ADDED, affecting root: "+root.getElementName()); //$NON-NLS-1$
    //                     }
    //                     elementAdded(root, null, null);
    //                     deltaContainsModifiedJar = true;
    //                     this.state.addClasspathValidation(javaProject); // see https://bugs.eclipse.org/bugs/show_bug.cgi?id=185733
    //                     hasDelta = true;
    //                  } else if (status == EXTERNAL_JAR_CHANGED) {
    //                     PackageFragmentRoot root = (PackageFragmentRoot) javaProject.getPackageFragmentRoot(entryPath.toString());
    //                     if (VERBOSE){
    //                        System.out.println("- External JAR CHANGED, affecting root: "+root.getElementName()); //$NON-NLS-1$
    //                     }
    //                     contentChanged(root);
    //                     deltaContainsModifiedJar = true;
    //                     hasDelta = true;
    //                  } else if (status == EXTERNAL_JAR_REMOVED) {
    //                     PackageFragmentRoot root = (PackageFragmentRoot) javaProject.getPackageFragmentRoot(entryPath.toString());
    //                     if (VERBOSE){
    //                        System.out.println("- External JAR REMOVED, affecting root: "+root.getElementName()); //$NON-NLS-1$
    //                     }
    //                     elementRemoved(root, null, null);
    //                     deltaContainsModifiedJar = true;
    //                     this.state.addClasspathValidation(javaProject); // see https://bugs.eclipse.org/bugs/show_bug.cgi?id=185733
    //                     hasDelta = true;
    //                  }
    //               }
    //            }
    //         }
    //
    //         if (deltaContainsModifiedJar) {
    //            javaProject.resetResolvedClasspath();
    //         }
    //      }
    //
    //      if (hasDelta){
    //         // flush jar type cache
    //         JavaModelManager.getJavaModelManager().resetJarTypeCache();
    //      }
    return hasDelta;
}

---

From source file:com.codenvy.ide.ext.java.server.internal.core.DeltaProcessor.java

License:Open Source License

private void elementRemoved(Openable element, IResourceDelta delta, RootInfo rootInfo) {

    int elementType = element.getElementType();
    if (delta == null || (delta.getFlags() & IResourceDelta.MOVED_TO) == 0) {
        // regular element removal
        if (isPrimaryWorkingCopy(element, elementType)) {
            // filter out changes to primary compilation unit in working copy mode
            // just report a change to the resource (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=59500)
            currentDelta().changed(element, IJavaElementDelta.F_PRIMARY_RESOURCE);
        } else {//ww w  .  java  2  s.  c o m
            close(element);
            removeFromParentInfo(element);
            currentDelta().removed(element);
        }
    } else {
        // element is moved
        close(element);
        removeFromParentInfo(element);
        IPath movedToPath = delta.getMovedToPath();
        File res = delta.getFile();
        File movedToRes;
        movedToRes = movedToPath.toFile();
        //         switch (res.getType()) {
        //            case IResource.PROJECT:
        //               movedToRes = res.getWorkspace().getRoot().getProject(movedToPath.lastSegment());
        //               break;
        //            case IResource.FOLDER:
        //               movedToRes = res.getWorkspace().getRoot().getFolder(movedToPath);
        //               break;
        //            case IResource.FILE:
        //               movedToRes = res.getWorkspace().getRoot().getFile(movedToPath);
        //               break;
        //            default:
        //               return;
        //         }

        // find the element type of the moved from element
        IPath rootPath = externalPath(movedToRes);
        RootInfo movedToInfo = enclosingRootInfo(rootPath, IResourceDelta.ADDED);
        int movedToType = elementType(movedToRes, IResourceDelta.ADDED, element.getParent().getElementType(),
                movedToInfo);

        // reset current element as it might be inside a nested root (popUntilPrefixOf() may use the outer root)
        this.currentElement = null;

        // create the moved To element
        Openable movedToElement = elementType != IJavaElement.JAVA_PROJECT
                && movedToType == IJavaElement.JAVA_PROJECT ? null : // outside classpath
                        createElement(movedToRes, movedToType, movedToInfo);
        if (movedToElement == null) {
            // moved outside classpath
            currentDelta().removed(element);
        } else {
            currentDelta().movedFrom(element, movedToElement);
        }
    }

    switch (elementType) {
    case IJavaElement.JAVA_MODEL:
        this.manager.indexManager.reset();
        break;
    case IJavaElement.JAVA_PROJECT:
        this.state.updateRoots(element.getPath(), delta, this);

        // remember that the project's cache must be reset
        this.projectCachesToReset.add(element);

        break;
    case IJavaElement.PACKAGE_FRAGMENT_ROOT:
        JavaProject project = (JavaProject) element.getJavaProject();

        // remember that the project's cache must be reset
        this.projectCachesToReset.add(project);

        break;
    case IJavaElement.PACKAGE_FRAGMENT:
        // reset package fragment cache
        project = (JavaProject) element.getJavaProject();
        this.projectCachesToReset.add(project);

        break;
    }
}

---

From source file:com.codenvy.ide.ext.java.server.internal.core.DeltaProcessor.java

License:Open Source License

private int elementType(File res, int kind, int parentType, RootInfo rootInfo) {
    Path path = new Path(res.getAbsolutePath());
    switch (parentType) {
    case IJavaElement.JAVA_MODEL:
        // case of a movedTo or movedFrom project (other cases are handled in processResourceDelta(...)
        return IJavaElement.JAVA_PROJECT;

    case NON_JAVA_RESOURCE:
    case IJavaElement.JAVA_PROJECT:
        if (rootInfo == null) {
            rootInfo = enclosingRootInfo(path, kind);
        }//from   w  ww.j av a 2s  . co m
        if (rootInfo != null && rootInfo.isRootOfProject(path)) {
            return IJavaElement.PACKAGE_FRAGMENT_ROOT;
        }
        // not yet in a package fragment root or root of another project
        // or package fragment to be included (see below)
        // $FALL-THROUGH$

    case IJavaElement.PACKAGE_FRAGMENT_ROOT:
    case IJavaElement.PACKAGE_FRAGMENT:
        if (rootInfo == null) {
            IPath rootPath = externalPath(res);
            rootInfo = enclosingRootInfo(rootPath, kind);
        }
        if (rootInfo == null) {
            return NON_JAVA_RESOURCE;
        }
        if (Util.isExcluded(path, rootInfo.inclusionPatterns, rootInfo.exclusionPatterns, false)) {
            return NON_JAVA_RESOURCE;
        }
        if (res.isDirectory()) {
            if (parentType == NON_JAVA_RESOURCE && !Util.isExcluded(new Path(res.getParent()),
                    rootInfo.inclusionPatterns, rootInfo.exclusionPatterns, false)) {
                // parent is a non-Java resource because it doesn't have a valid package name (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=130982)
                return NON_JAVA_RESOURCE;
            }
            String sourceLevel = rootInfo.project == null ? null
                    : rootInfo.project.getOption(JavaCore.COMPILER_SOURCE, true);
            String complianceLevel = rootInfo.project == null ? null
                    : rootInfo.project.getOption(JavaCore.COMPILER_COMPLIANCE, true);
            if (Util.isValidFolderNameForPackage(res.getName(), sourceLevel, complianceLevel)) {
                return IJavaElement.PACKAGE_FRAGMENT;
            }
            return NON_JAVA_RESOURCE;
        }
        String fileName = res.getName();
        String sourceLevel = rootInfo.project == null ? null
                : rootInfo.project.getOption(JavaCore.COMPILER_SOURCE, true);
        String complianceLevel = rootInfo.project == null ? null
                : rootInfo.project.getOption(JavaCore.COMPILER_COMPLIANCE, true);
        if (Util.isValidCompilationUnitName(fileName, sourceLevel, complianceLevel)) {
            return IJavaElement.COMPILATION_UNIT;
        } else if (Util.isValidClassFileName(fileName, sourceLevel, complianceLevel)) {
            return IJavaElement.CLASS_FILE;
        } else {
            IPath rootPath = externalPath(res);
            if ((rootInfo = rootInfo(rootPath, kind)) != null
                    && rootInfo.project.getProject().getFullPath().isPrefixOf(
                            rootPath) /*ensure root is a root of its project (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=185310) */) {
                // case of proj=src=bin and resource is a jar file on the classpath
                return IJavaElement.PACKAGE_FRAGMENT_ROOT;
            } else {
                return NON_JAVA_RESOURCE;
            }
        }

    default:
        return NON_JAVA_RESOURCE;
    }
}

---

From source file:com.codenvy.ide.ext.java.server.internal.core.JavaModelCache.java

License:Open Source License

/**
 *  Returns the info for the element./*from  ww w. j a  v a  2  s . c  o  m*/
 */
public Object getInfo(IJavaElement element) {
    switch (element.getElementType()) {
    case IJavaElement.JAVA_MODEL:
        return this.modelInfo;
    case IJavaElement.JAVA_PROJECT:
        return this.projectCache.get(element);
    case IJavaElement.PACKAGE_FRAGMENT_ROOT:
        return this.rootCache.get(element);
    case IJavaElement.PACKAGE_FRAGMENT:
        return this.pkgCache.get(element);
    case IJavaElement.COMPILATION_UNIT:
    case IJavaElement.CLASS_FILE:
        return this.openableCache.get(element);
    case IJavaElement.TYPE:
        Object result = this.jarTypeCache.get(element);
        if (result != null)
            return result;
        else
            return this.childrenCache.get(element);
    default:
        return this.childrenCache.get(element);
    }
}

---

From source file:com.codenvy.ide.ext.java.server.internal.core.JavaModelCache.java

License:Open Source License

public IJavaElement getExistingElement(IJavaElement element) {
    switch (element.getElementType()) {
    case IJavaElement.JAVA_MODEL:
        return element;
    case IJavaElement.JAVA_PROJECT:
        return element; // projectCache is a Hashtable and Hashtables don't support getKey(...)
    case IJavaElement.PACKAGE_FRAGMENT_ROOT:
        return (IJavaElement) this.rootCache.getKey(element);
    case IJavaElement.PACKAGE_FRAGMENT:
        return (IJavaElement) this.pkgCache.getKey(element);
    case IJavaElement.COMPILATION_UNIT:
    case IJavaElement.CLASS_FILE:
        return (IJavaElement) this.openableCache.getKey(element);
    case IJavaElement.TYPE:
        return element; // jarTypeCache or childrenCache are Hashtables and Hashtables don't support getKey(...)
    default://from   w w  w.  j  a va 2s . c o m
        return element; // childrenCache is a Hashtable and Hashtables don't support getKey(...)
    }
}

---

From source file:com.codenvy.ide.ext.java.server.internal.core.JavaModelCache.java

License:Open Source License

/**
 *  Returns the info for this element without
 *  disturbing the cache ordering.//from   w  w w  .j  ava  2  s. c  om
 */
protected Object peekAtInfo(IJavaElement element) {
    switch (element.getElementType()) {
    case IJavaElement.JAVA_MODEL:
        return this.modelInfo;
    case IJavaElement.JAVA_PROJECT:
        return this.projectCache.get(element);
    case IJavaElement.PACKAGE_FRAGMENT_ROOT:
        return this.rootCache.peek(element);
    case IJavaElement.PACKAGE_FRAGMENT:
        return this.pkgCache.peek(element);
    case IJavaElement.COMPILATION_UNIT:
    case IJavaElement.CLASS_FILE:
        return this.openableCache.peek(element);
    case IJavaElement.TYPE:
        Object result = this.jarTypeCache.peek(element);
        if (result != null)
            return result;
        else
            return this.childrenCache.get(element);
    default:
        return this.childrenCache.get(element);
    }
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• »