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:com.android.ide.eclipse.adt.internal.refactorings.core.AndroidPackageRenameParticipant.java

License:Open Source License

@Override
protected boolean initialize(final Object element) {
    mRefactoringAppPackage = false;//from  www .j  a v  a  2  s .c  o m
    try {
        // Only propose this refactoring if the "Update References" checkbox is set.
        if (!getArguments().getUpdateReferences()) {
            return false;
        }

        if (element instanceof IPackageFragment) {
            mPackageFragment = (IPackageFragment) element;
            if (!mPackageFragment.containsJavaResources()) {
                return false;
            }
            IJavaProject javaProject = (IJavaProject) mPackageFragment.getAncestor(IJavaElement.JAVA_PROJECT);
            mProject = javaProject.getProject();
            IResource manifestResource = mProject
                    .findMember(AdtConstants.WS_SEP + SdkConstants.FN_ANDROID_MANIFEST_XML);

            if (manifestResource == null || !manifestResource.exists()
                    || !(manifestResource instanceof IFile)) {
                RefactoringUtil.logInfo("Invalid or missing the " + SdkConstants.FN_ANDROID_MANIFEST_XML
                        + " in the " + mProject.getName() + " project.");
                return false;
            }
            mManifestFile = (IFile) manifestResource;
            String packageName = mPackageFragment.getElementName();
            ManifestData manifestData;
            manifestData = AndroidManifestHelper.parseForData(mManifestFile);
            if (manifestData == null) {
                return false;
            }
            mAppPackage = manifestData.getPackage();
            mOldPackage = packageName;
            mNewPackage = getArguments().getNewName();
            if (mOldPackage == null || mNewPackage == null) {
                return false;
            }

            if (RefactoringUtil.isRefactorAppPackage() && mAppPackage != null
                    && mAppPackage.equals(packageName)) {
                mRefactoringAppPackage = true;
            }

            return true;
        }
    } catch (JavaModelException ignore) {
    }
    return false;
}

From source file:com.android.ide.eclipse.adt.internal.refactorings.core.AndroidPackageRenameParticipant.java

License:Open Source License

/**
 * Return the gen package fragment/*from ww  w  .ja va  2s. c o m*/
 */
private IPackageFragment getGenPackageFragment() throws JavaModelException {
    IJavaProject javaProject = (IJavaProject) mPackageFragment.getAncestor(IJavaElement.JAVA_PROJECT);
    if (javaProject != null && javaProject.isOpen()) {
        IProject project = javaProject.getProject();
        IFolder genFolder = project.getFolder(SdkConstants.FD_GEN_SOURCES);
        if (genFolder.exists()) {
            String javaPackagePath = mAppPackage.replace('.', '/');
            IPath genJavaPackagePath = genFolder.getFullPath().append(javaPackagePath);
            IPackageFragment genPackageFragment = javaProject.findPackageFragment(genJavaPackagePath);
            return genPackageFragment;
        }
    }
    return null;
}

From source file:com.android.ide.eclipse.adt.internal.refactorings.core.AndroidTypeMoveParticipant.java

License:Open Source License

@Override
protected boolean initialize(Object element) {
    if (element instanceof IType) {
        IType type = (IType) element;//from w  ww.  ja v a2s  .c  o m
        IJavaProject javaProject = (IJavaProject) type.getAncestor(IJavaElement.JAVA_PROJECT);
        mProject = javaProject.getProject();
        IResource manifestResource = mProject
                .findMember(AdtConstants.WS_SEP + SdkConstants.FN_ANDROID_MANIFEST_XML);

        if (manifestResource == null || !manifestResource.exists() || !(manifestResource instanceof IFile)) {
            RefactoringUtil.logInfo("Invalid or missing the " + SdkConstants.FN_ANDROID_MANIFEST_XML
                    + " in the " + mProject.getName() + " project.");
            return false;
        }
        mManifestFile = (IFile) manifestResource;
        ManifestData manifestData;
        manifestData = AndroidManifestHelper.parseForData(mManifestFile);
        if (manifestData == null) {
            return false;
        }
        mAppPackage = manifestData.getPackage();
        mOldFqcn = type.getFullyQualifiedName();
        Object destination = getArguments().getDestination();
        if (destination instanceof IPackageFragment) {
            IPackageFragment packageFragment = (IPackageFragment) destination;
            mNewFqcn = packageFragment.getElementName() + "." + type.getElementName();
        } else if (destination instanceof IResource) {
            try {
                IPackageFragment[] fragments = javaProject.getPackageFragments();
                for (IPackageFragment fragment : fragments) {
                    IResource resource = fragment.getResource();
                    if (resource.equals(destination)) {
                        mNewFqcn = fragment.getElementName() + '.' + type.getElementName();
                        break;
                    }
                }
            } catch (JavaModelException e) {
                // pass
            }
        }
        return mOldFqcn != null && mNewFqcn != null;
    }

    return false;
}

From source file:com.android.ide.eclipse.adt.internal.refactorings.core.AndroidTypeRenameParticipant.java

License:Open Source License

@Override
protected boolean initialize(Object element) {
    if (sIgnore) {
        return false;
    }/*  w  w w. jav a2  s  .  co m*/

    if (element instanceof IType) {
        IType type = (IType) element;
        IJavaProject javaProject = (IJavaProject) type.getAncestor(IJavaElement.JAVA_PROJECT);
        mProject = javaProject.getProject();
        IResource manifestResource = mProject
                .findMember(AdtConstants.WS_SEP + SdkConstants.FN_ANDROID_MANIFEST_XML);

        if (manifestResource == null || !manifestResource.exists() || !(manifestResource instanceof IFile)) {
            RefactoringUtil.logInfo(String.format("Invalid or missing file %1$s in project %2$s",
                    SdkConstants.FN_ANDROID_MANIFEST_XML, mProject.getName()));
            return false;
        }

        try {
            IType classView = javaProject.findType(CLASS_VIEW);
            if (classView != null) {
                ITypeHierarchy hierarchy = type.newSupertypeHierarchy(new NullProgressMonitor());
                if (hierarchy.contains(classView)) {
                    mIsCustomView = true;
                }
            }
        } catch (CoreException e) {
            AdtPlugin.log(e, null);
        }

        mManifestFile = (IFile) manifestResource;
        ManifestData manifestData;
        manifestData = AndroidManifestHelper.parseForData(mManifestFile);
        if (manifestData == null) {
            return false;
        }
        mOldSimpleName = type.getElementName();
        mOldDottedName = '.' + mOldSimpleName;
        mOldFqcn = type.getFullyQualifiedName();
        String packageName = type.getPackageFragment().getElementName();
        mNewSimpleName = getArguments().getNewName();
        mNewDottedName = '.' + mNewSimpleName;
        if (packageName != null) {
            mNewFqcn = packageName + mNewDottedName;
        } else {
            mNewFqcn = mNewSimpleName;
        }
        if (mOldFqcn == null || mNewFqcn == null) {
            return false;
        }
        if (!RefactoringUtil.isRefactorAppPackage() && mNewFqcn.indexOf('.') == -1) {
            mNewFqcn = packageName + mNewDottedName;
        }
        return true;
    }
    return false;
}

From source file:com.android.ide.eclipse.adt.internal.refactorings.core.RenameResourceParticipant.java

License:Open Source License

@Override
protected boolean initialize(Object element) {
    if (sIgnore) {
        return false;
    }// ww  w  . j a  v a  2  s  .c o m

    if (element instanceof IField) {
        IField field = (IField) element;
        IType declaringType = field.getDeclaringType();
        if (declaringType != null) {
            if (R_CLASS.equals(declaringType.getParent().getElementName())) {
                String typeName = declaringType.getElementName();
                mType = ResourceType.getEnum(typeName);
                if (mType != null) {
                    mUpdateReferences = getArguments().getUpdateReferences();
                    mFolderType = AdtUtils.getFolderTypeFor(mType);
                    IJavaProject javaProject = (IJavaProject) field.getAncestor(IJavaElement.JAVA_PROJECT);
                    mProject = javaProject.getProject();
                    mOldName = field.getElementName();
                    mNewName = getArguments().getNewName();
                    mFieldRefactoring = null;
                    mRenamedFile = null;
                    createXmlSearchPatterns();
                    return true;
                }
            }
        }

        return false;
    } else if (element instanceof IFile) {
        IFile file = (IFile) element;
        mProject = file.getProject();
        if (BaseProjectHelper.isAndroidProject(mProject)) {
            IPath path = file.getFullPath();
            int segments = path.segmentCount();
            if (segments == 4 && path.segment(1).equals(FD_RES)) {
                String parentName = file.getParent().getName();
                mFolderType = ResourceFolderType.getFolderType(parentName);
                if (mFolderType != null && mFolderType != ResourceFolderType.VALUES) {
                    mType = AdtUtils.getResourceTypeFor(mFolderType);
                    if (mType != null) {
                        mUpdateReferences = getArguments().getUpdateReferences();
                        mProject = file.getProject();
                        mOldName = AdtUtils.stripAllExtensions(file.getName());
                        mNewName = AdtUtils.stripAllExtensions(getArguments().getNewName());
                        mRenamedFile = file;
                        createXmlSearchPatterns();

                        mFieldRefactoring = null;
                        IField field = getResourceField(mProject, mType, mOldName);
                        if (field != null) {
                            mFieldRefactoring = createFieldRefactoring(field);
                        } else {
                            // no corresponding field; aapt has not run yet. Perhaps user has
                            // turned off auto build.
                            mFieldRefactoring = null;
                        }

                        return true;
                    }
                }
            }
        }
    } else if (element instanceof String) {
        String uri = (String) element;
        if (uri.startsWith(PREFIX_RESOURCE_REF) && !uri.startsWith(ANDROID_PREFIX)) {
            RenameResourceProcessor processor = (RenameResourceProcessor) getProcessor();
            mProject = processor.getProject();
            mType = processor.getType();
            mFolderType = AdtUtils.getFolderTypeFor(mType);
            mOldName = processor.getCurrentName();
            mNewName = processor.getNewName();
            assert uri.endsWith(mOldName) && uri.contains(mType.getName()) : uri;
            mUpdateReferences = getArguments().getUpdateReferences();
            if (mNewName.isEmpty()) {
                mUpdateReferences = false;
            }
            mRenamedFile = null;
            createXmlSearchPatterns();
            mFieldRefactoring = null;
            if (!mNewName.isEmpty()) {
                IField field = getResourceField(mProject, mType, mOldName);
                if (field != null) {
                    mFieldRefactoring = createFieldRefactoring(field);
                }
            }

            return true;
        }
    }

    return false;
}

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);/*from   ww w . j a va 2s .  c om*/
        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;
            }//from w  ww.j a  va 2 s . co  m
            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 elementAdded(Openable element, IResourceDelta delta, RootInfo rootInfo) {
    int elementType = element.getElementType();

    if (elementType == IJavaElement.JAVA_PROJECT) {
        // project add is handled by JavaProject.configure() because
        // when a project is created, it does not yet have a Java nature
        IProject project;//  w w  w.ja va2s.c o  m
        if (delta != null && JavaProject.hasJavaNature(project = (IProject) delta.getResource())) {
            addToParentInfo(element);
            this.manager.getPerProjectInfo(true /*create info if needed*/).rememberExternalLibTimestamps();
            if ((delta.getFlags() & IResourceDelta.MOVED_FROM) != 0) {
                Openable movedFromElement = (Openable) element.getJavaModel()
                        .getJavaProject(delta.getMovedFromPath().lastSegment());
                currentDelta().movedTo(element, movedFromElement);
            } else {
                // Force the project to be closed as it might have been opened
                // before the resource modification came in and it might have a new child
                // For example, in an IWorkspaceRunnable:
                // 1. create a Java project P (where P=src)
                // 2. open project P
                // 3. add folder f in P's pkg fragment root
                // When the resource delta comes in, only the addition of P is notified,
                // but the pkg fragment root of project P is already opened, thus its children are not recomputed
                // and it appears to contain only the default package.
                close(element);

                currentDelta().added(element);
            }
            this.state.updateRoots(element.getPath(), delta, this);

            // remember that the project's cache must be reset
            this.projectCachesToReset.add(element);
        }
    } else {
        if (delta == null || (delta.getFlags() & IResourceDelta.MOVED_FROM) == 0) {
            // regular element addition
            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 {
                addToParentInfo(element);

                // Force the element to be closed as it might have been opened
                // before the resource modification came in and it might have a new child
                // For example, in an IWorkspaceRunnable:
                // 1. create a package fragment p using a java model operation
                // 2. open package p
                // 3. add file X.java in folder p
                // When the resource delta comes in, only the addition of p is notified,
                // but the package p is already opened, thus its children are not recomputed
                // and it appears empty.
                close(element);

                currentDelta().added(element);
            }
        } else {
            // element is moved
            addToParentInfo(element);
            close(element);

            IPath movedFromPath = delta.getMovedFromPath();
            File res = delta.getFile();
            File movedFromRes;
            if (res.isFile()) {
                movedFromRes = movedFromPath.toFile();
            } else {
                movedFromRes = movedFromPath.toFile();
            }

            // find the element type of the moved from element
            IPath rootPath = externalPath(movedFromRes);
            RootInfo movedFromInfo = enclosingRootInfo(rootPath, IResourceDelta.REMOVED);
            int movedFromType = elementType(movedFromRes, IResourceDelta.REMOVED,
                    element.getParent().getElementType(), movedFromInfo);

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

            // create the moved from element
            Openable movedFromElement = elementType != IJavaElement.JAVA_PROJECT
                    && movedFromType == IJavaElement.JAVA_PROJECT ? null : // outside classpath
                            createElement(movedFromRes, movedFromType, movedFromInfo);
            if (movedFromElement == null) {
                // moved from outside classpath
                currentDelta().added(element);
            } else {
                currentDelta().movedTo(element, movedFromElement);
            }
        }

        switch (elementType) {
        case IJavaElement.PACKAGE_FRAGMENT_ROOT:
            // when a root is added, and is on the classpath, the project must be updated
            JavaProject project = (JavaProject) element.getJavaProject();

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

            break;
        case IJavaElement.PACKAGE_FRAGMENT:
            // reset project's 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 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 {//w  ww  .j av  a 2s .c  om
            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;
    }
}