* Copyright (c) 2000, 2007 IBM Corporation and others.

* All rights reserved. This program and the accompanying materials

* are made available under the terms of the Eclipse Public License v1.0

* which accompanies this distribution, and is available at

* http://www.eclipse.org/legal/epl-v10.html

*

* Contributors:

*     IBM Corporation - initial API and implementation

*******************************************************************************/

* Handle for a Java Project.

*

* <p>A Java Project internally maintains a devpath that corresponds

* to the project's classpath. The classpath may include source folders

* from the current project; jars in the current project, other projects,

* and the local file system; and binary folders (output location) of other

* projects. The Java Model presents source elements corresponding to output

* .class files in other projects, and thus uses the devpath rather than

* the classpath (which is really a compilation path). The devpath mimics

* the classpath, except has source folder entries in place of output

* locations in external projects.

*

* <p>Each JavaProject has a NameLookup facility that locates elements

* on by name, based on the devpath.

*

* @see IJavaProject

*/

  extends Openable

  implements IJavaProject, IProjectNature, SuffixConstants {

 

  /**

   * Name of file containing project classpath

   */

  public static final String CLASSPATH_FILENAME = ".classpath";  //$NON-NLS-1$

 

  /**

   * Value of the project's raw classpath if the .classpath file contains invalid entries.

   */

  public static final IClasspathEntry[] INVALID_CLASSPATH = new IClasspathEntry[0];

  /**

   * Whether the underlying file system is case sensitive.

   */

  protected static final boolean IS_CASE_SENSITIVE = !new File("Temp").equals(new File("temp")); //$NON-NLS-1$ //$NON-NLS-2$

  /**

   * An empty array of strings indicating that a project doesn't have any prerequesite projects.

   */

  protected static final String[] NO_PREREQUISITES = CharOperation.NO_STRINGS;

  /**

   * Name of file containing custom project preferences

   * @see <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=59258">bug 59258</a>

   */

  private static final String PREF_FILENAME = ".jprefs";  //$NON-NLS-1$

 

  /**

   * Name of directory containing preferences file

   */

  public static final String DEFAULT_PREFERENCES_DIRNAME = ".settings"; //$NON-NLS-1$

 

  /**

   * Extension for file containing custom project preferences

   */

  public static final String JAVA_CORE_PREFS_FILE = JavaCore.PLUGIN_ID+".prefs"; //$NON-NLS-1$

 

  /*

   * Value of project's resolved classpath while it is being resolved

   */

  private static final IClasspathEntry[] RESOLUTION_IN_PROGRESS = new IClasspathEntry[0];

  /**

   * The platform project this <code>IJavaProject</code> is based on

   */

  protected IProject project;

 

  /**

   * Constructor needed for <code>IProject.getNature()</code> and <code>IProject.addNature()</code>.

   *

   * @see #setProject(IProject)

   */

  public JavaProject() {

    super(null);

  }

 

  public JavaProject(IProject project, JavaElement parent) {

    super(parent);

    this.project = project;

  }

  public static boolean areClasspathsEqual(

      IClasspathEntry[] firstClasspath, IClasspathEntry[] secondClasspath,

      IPath firstOutputLocation, IPath secondOutputLocation) {

    int length = firstClasspath.length;

    if (length != secondClasspath.length) return false;

    for (int i = 0; i < length; i++) {

      if (!firstClasspath[i].equals(secondClasspath[i]))

        return false;

    }

    if (firstOutputLocation == null)

      return secondOutputLocation == null;

    return firstOutputLocation.equals(secondOutputLocation);

  }

  /**

   * Compare current classpath with given one to see if any different.

   * Note that the argument classpath contains its binary output.

   * @param newClasspath IClasspathEntry[]

   * @param newOutputLocation IPath

   * @param otherClasspathWithOutput IClasspathEntry[]

   * @return boolean

   */

  private static boolean areClasspathsEqual(IClasspathEntry[] newClasspath, IPath newOutputLocation, IClasspathEntry[] otherClasspathWithOutput) {

    if (otherClasspathWithOutput == null || otherClasspathWithOutput.length == 0)

      return false;

    int length = otherClasspathWithOutput.length;

    if (length != newClasspath.length + 1)

        // output is amongst file entries (last one)

        return false;

   

   

    // compare classpath entries

    for (int i = 0; i < length - 1; i++) {

      if (!otherClasspathWithOutput[i].equals(newClasspath[i]))

        return false;

    }

    // compare binary outputs

    IClasspathEntry output = otherClasspathWithOutput[length - 1];

    if (output.getContentKind() != ClasspathEntry.K_OUTPUT

        || !output.getPath().equals(newOutputLocation))

      return false;

    return true;

  }

  /**

   * Returns a canonicalized path from the given external path.

   * Note that the return path contains the same number of segments

   * and it contains a device only if the given path contained one.

   * @param externalPath IPath

   * @see java.io.File for the definition of a canonicalized path

   * @return IPath

   */

  public static IPath canonicalizedPath(IPath externalPath) {

   

    if (externalPath == null)

      return null;

//      System.out.println("JAVA MODEL - Canonicalizing " + externalPath.toString());

//    }

    if (IS_CASE_SENSITIVE) {

//        System.out.println("JAVA MODEL - Canonical path is original path (file system is case sensitive)");

//      }

      return externalPath;

    }

    // if not external path, return original path

    IWorkspace workspace = ResourcesPlugin.getWorkspace();

    if (workspace == null) return externalPath; // protection during shutdown (30487)

    if (workspace.getRoot().findMember(externalPath) != null) {

//        System.out.println("JAVA MODEL - Canonical path is original path (member of workspace)");

//      }

      return externalPath;

    }

    IPath canonicalPath = null;

    try {

      canonicalPath =

        new Path(new File(externalPath.toOSString()).getCanonicalPath());

    } catch (IOException e) {

      // default to original path

//      if (JavaModelManager.VERBOSE) {

//        System.out.println("JAVA MODEL - Canonical path is original path (IOException)");

//      }

      return externalPath;

    }

   

    IPath result;

    int canonicalLength = canonicalPath.segmentCount();

    if (canonicalLength == 0) {

      // the java.io.File canonicalization failed

//      if (JavaModelManager.VERBOSE) {

//        System.out.println("JAVA MODEL - Canonical path is original path (canonical path is empty)");

//      }

      return externalPath;

    } else if (externalPath.isAbsolute()) {

      result = canonicalPath;

    } else {

      // if path is relative, remove the first segments that were added by the java.io.File canonicalization

      // e.g. 'lib/classes.zip' was converted to 'd:/myfolder/lib/classes.zip'

      int externalLength = externalPath.segmentCount();

      if (canonicalLength >= externalLength) {

        result = canonicalPath.removeFirstSegments(canonicalLength - externalLength);

      } else {

//          System.out.println("JAVA MODEL - Canonical path is original path (canonical path is " + canonicalPath.toString() + ")");

//        }

        return externalPath;

      }

    }

   

    // keep device only if it was specified (this is because File.getCanonicalPath() converts '/lib/classed.zip' to 'd:/lib/classes/zip')

    if (externalPath.getDevice() == null) {

      result = result.setDevice(null);

    }

//      System.out.println("JAVA MODEL - Canonical path is " + result.toString());

//    }

    return result;

  }

  /**

   * Returns true if the given project is accessible and it has

   * a java nature, otherwise false.

   * @param project IProject

   * @return boolean

   */

  public static boolean hasJavaNature(IProject project) {

    try {

      return project.hasNature(JavaCore.NATURE_ID);

    } catch (CoreException e) {

      if (ExternalJavaProject.EXTERNAL_PROJECT_NAME.equals(project.getName()))

        return true;

      // project does not exist or is not open

    }

    return false;

  }

  /*

   * Detect cycles in the classpath of the workspace's projects

   * and create markers if necessary.

   * @param preferredClasspaths Map

   * @throws JavaModelException

   */

  public static void validateCycles(Map preferredClasspaths) throws JavaModelException {

    //long start = System.currentTimeMillis();

    IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();

    IProject[] rscProjects = workspaceRoot.getProjects();

    int length = rscProjects.length;

    JavaProject[] projects = new JavaProject[length];

       

    HashSet cycleParticipants = new HashSet();

    HashSet traversed = new HashSet();

   

    // compute cycle participants

    ArrayList prereqChain = new ArrayList();

    for (int i = 0; i < length; i++){

      if (hasJavaNature(rscProjects[i])) {

        JavaProject project = (projects[i] = (JavaProject)JavaCore.create(rscProjects[i]));

        if (!traversed.contains(project.getPath())){

          prereqChain.clear();

          project.updateCycleParticipants(prereqChain, cycleParticipants, workspaceRoot, traversed, preferredClasspaths);

        }

      }

    }

    //System.out.println("updateAllCycleMarkers: " + (System.currentTimeMillis() - start) + " ms");

    for (int i = 0; i < length; i++){

      JavaProject project = projects[i];

      if (project != null) {

        if (cycleParticipants.contains(project.getPath())){

          IMarker cycleMarker = project.getCycleMarker();

          String circularCPOption = project.getOption(JavaCore.CORE_CIRCULAR_CLASSPATH, true);

          int circularCPSeverity = JavaCore.ERROR.equals(circularCPOption) ? IMarker.SEVERITY_ERROR : IMarker.SEVERITY_WARNING;

          if (cycleMarker != null) {

            // update existing cycle marker if needed

            try {

              int existingSeverity = ((Integer)cycleMarker.getAttribute(IMarker.SEVERITY)).intValue();

              if (existingSeverity != circularCPSeverity) {

                cycleMarker.setAttribute(IMarker.SEVERITY, circularCPSeverity);

              }

            } catch (CoreException e) {

              throw new JavaModelException(e);

            }

          } else {

            // create new marker

            project.createClasspathProblemMarker(

              new JavaModelStatus(IJavaModelStatusConstants.CLASSPATH_CYCLE, project));

          }

        } else {

          project.flushClasspathProblemMarkers(true, false);

        }     

      }

    }

  }

  /**

   * Adds a builder to the build spec for the given project.

   */

  protected void addToBuildSpec(String builderID) throws CoreException {

    IProjectDescription description = this.project.getDescription();

    int javaCommandIndex = getJavaCommandIndex(description.getBuildSpec());

    if (javaCommandIndex == -1) {

      // Add a Java command to the build spec

      ICommand command = description.newCommand();

      command.setBuilderName(builderID);

      setJavaCommand(description, command);

    }

  }

  /**

   * @see Openable

   */

  protected boolean buildStructure(OpenableElementInfo info, IProgressMonitor pm, Map newElements, IResource underlyingResource) throws JavaModelException {

 

    // check whether the java project can be opened

    if (!hasJavaNature((IProject) underlyingResource)) {

      throw newNotPresentException();

    }

   

    // cannot refresh cp markers on opening (emulate cp check on startup) since can create deadlocks (see bug 37274)

    IClasspathEntry[] resolvedClasspath = getResolvedClasspath();

    // compute the pkg fragment roots

    info.setChildren(computePackageFragmentRoots(resolvedClasspath, false, null /*no reverse map*/)); 

   

    // remember the timestamps of external libraries the first time they are looked up

    getPerProjectInfo().rememberExternalLibTimestamps();     

    return true;

  }

  /**

   * Computes the collection of package fragment roots (local ones) and set it on the given info.

   * Need to check *all* package fragment roots in order to reset NameLookup

   * @param info JavaProjectElementInfo

   * @throws JavaModelException

   */

  public void computeChildren(JavaProjectElementInfo info) throws JavaModelException {

    IClasspathEntry[] classpath = getResolvedClasspath();

    JavaProjectElementInfo.ProjectCache projectCache = info.projectCache;

    if (projectCache != null) {

      IPackageFragmentRoot[] newRoots = computePackageFragmentRoots(classpath, true, null /*no reverse map*/);

      checkIdentical: { // compare all pkg fragment root lists

        IPackageFragmentRoot[] oldRoots = projectCache.allPkgFragmentRootsCache;

        if (oldRoots.length == newRoots.length){

          for (int i = 0, length = oldRoots.length; i < length; i++){

            if (!oldRoots[i].equals(newRoots[i])){

              break checkIdentical;

            }

          }

          return; // no need to update

        } 

      }

    }

    info.setNonJavaResources(null);

    info.setChildren(

      computePackageFragmentRoots(classpath, false, null /*no reverse map*/));   

  }

 

  /**

   * Internal computation of an expanded classpath. It will eliminate duplicates, and produce copies

   * of exported or restricted classpath entries to avoid possible side-effects ever after.

   */     

  private void computeExpandedClasspath(

    ClasspathEntry referringEntry,

    HashSet rootIDs,

    ObjectVector accumulatedEntries) throws JavaModelException {

   

    String projectRootId = this.rootID();

    if (rootIDs.contains(projectRootId)){

      return; // break cycles if any

    }

    rootIDs.add(projectRootId);

    IClasspathEntry[] resolvedClasspath = getResolvedClasspath();

     

    IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();

    boolean isInitialProject = referringEntry == null;

    for (int i = 0, length = resolvedClasspath.length; i < length; i++){

      ClasspathEntry entry = (ClasspathEntry) resolvedClasspath[i];

      if (isInitialProject || entry.isExported()){

        String rootID = entry.rootID();

        if (rootIDs.contains(rootID)) {

          continue;

        }

        // combine restrictions along the project chain

        ClasspathEntry combinedEntry = entry.combineWith(referringEntry);

        accumulatedEntries.add(combinedEntry);

       

        // recurse in project to get all its indirect exports (only consider exported entries from there on)       

        if (entry.getEntryKind() == IClasspathEntry.CPE_PROJECT) {

          IResource member = workspaceRoot.findMember(entry.getPath());

          if (member != null && member.getType() == IResource.PROJECT){ // double check if bound to project (23977)

            IProject projRsc = (IProject) member;

            if (JavaProject.hasJavaNature(projRsc)) {

              JavaProject javaProject = (JavaProject) JavaCore.create(projRsc);

              javaProject.computeExpandedClasspath(

                combinedEntry,

                rootIDs,

                accumulatedEntries);

            }

          }

        } else {

          rootIDs.add(rootID);

        }

      }     

    }

  }

 

  /**

   * Computes the package fragment roots identified by the given entry.

   * Only works with resolved entry

   * @param resolvedEntry IClasspathEntry

   * @return IPackageFragmentRoot[]

   */

  public IPackageFragmentRoot[] computePackageFragmentRoots(IClasspathEntry resolvedEntry) {

    try {

      return

        computePackageFragmentRoots(

          new IClasspathEntry[]{ resolvedEntry },

          false, // don't retrieve exported roots

          null /* no reverse map */

        );

    } catch (JavaModelException e) {

      return new IPackageFragmentRoot[] {};

    }

  }

  /**

   * Returns the package fragment roots identified by the given entry. In case it refers to

   * a project, it will follow its classpath so as to find exported roots as well.

   * Only works with resolved entry

   * @param resolvedEntry IClasspathEntry

   * @param accumulatedRoots ObjectVector

   * @param rootIDs HashSet

   * @param referringEntry the CP entry (project) referring to this entry, or null if initial project

   * @param checkExistency boolean

   * @param retrieveExportedRoots boolean

   * @throws JavaModelException

   */

  public void computePackageFragmentRoots(

    IClasspathEntry resolvedEntry,

    ObjectVector accumulatedRoots,

    HashSet rootIDs,

    IClasspathEntry referringEntry,

    boolean checkExistency,

    boolean retrieveExportedRoots,

    Map rootToResolvedEntries) throws JavaModelException {

     

    String rootID = ((ClasspathEntry)resolvedEntry).rootID();

    if (rootIDs.contains(rootID)) return;

    IPath projectPath = this.project.getFullPath();

    IPath entryPath = resolvedEntry.getPath();

    IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();

    IPackageFragmentRoot root = null;

   

    switch(resolvedEntry.getEntryKind()){

     

      // source folder

      case IClasspathEntry.CPE_SOURCE :

        if (projectPath.isPrefixOf(entryPath)){

          if (checkExistency) {

            Object target = JavaModel.getTarget(workspaceRoot, entryPath, checkExistency);

            if (target == null) return;

 

            if (target instanceof IFolder || target instanceof IProject){

              root = getPackageFragmentRoot((IResource)target);

            }

          } else {

            root = getFolderPackageFragmentRoot(entryPath);

          }

        }

        break;

      // internal/external JAR or folder

      case IClasspathEntry.CPE_LIBRARY :

     

        if (referringEntry != null  && !resolvedEntry.isExported()) return;

       

        if (checkExistency) {

          Object target = JavaModel.getTarget(workspaceRoot, entryPath, checkExistency);

          if (target == null) return;

 

          if (target instanceof IResource){

            // internal target

            root = getPackageFragmentRoot((IResource) target);

          } else {

            // external target - only JARs allowed

            if (JavaModel.isFile(target) && (org.aspectj.org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(entryPath.lastSegment()))) {

              root = new JarPackageFragmentRoot(entryPath, this);

            }

          }

        } else {

          root = getPackageFragmentRoot(entryPath);

        }

        break;

      // recurse into required project

      case IClasspathEntry.CPE_PROJECT :

        if (!retrieveExportedRoots) return;

        if (referringEntry != null && !resolvedEntry.isExported()) return;

        IResource member = workspaceRoot.findMember(entryPath);

        if (member != null && member.getType() == IResource.PROJECT){// double check if bound to project (23977)

          IProject requiredProjectRsc = (IProject) member;

          if (JavaProject.hasJavaNature(requiredProjectRsc)){ // special builder binary output

            rootIDs.add(rootID);

            JavaProject requiredProject = (JavaProject)JavaCore.create(requiredProjectRsc);

            requiredProject.computePackageFragmentRoots(

              requiredProject.getResolvedClasspath(),

              accumulatedRoots,

              rootIDs,

              rootToResolvedEntries == null ? resolvedEntry : ((ClasspathEntry)resolvedEntry).combineWith((ClasspathEntry) referringEntry), // only combine if need to build the reverse map

              checkExistency,

              retrieveExportedRoots,

              rootToResolvedEntries);

          }

        break;

      }