* Copyright (c) 2000, 2011 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

*     Stephan Herrmann <stephan@cs.tu-berlin.de> - inconsistent initialization of classpath container backed by external class folder, see https://bugs.eclipse.org/320618

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

* 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 = IJavaProject.CLASSPATH_FILE_NAME;

  /**

   * 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];

  /*

   * For testing purpose only

   */

  private static ArrayList CP_RESOLUTION_BP_LISTENERS;

  public static class ClasspathResolutionBreakpointListener {

    public void breakpoint(int bp) {

      // override in listener implementation

    }

  }

  /**

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

   */

  protected IProject project;

  /**

   * Preferences listeners

   */

  private IEclipsePreferences.INodeChangeListener preferencesNodeListener;

  private IEclipsePreferences.IPreferenceChangeListener preferencesChangeListener;

  /**

   * 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;

  }

  /*

   * For testing purpose only

   */

  public static synchronized void addCPResolutionBPListener(ClasspathResolutionBreakpointListener listener) {

    if (CP_RESOLUTION_BP_LISTENERS == null)

      CP_RESOLUTION_BP_LISTENERS = new ArrayList();

    CP_RESOLUTION_BP_LISTENERS.add(listener);

  }

  /*

   * For testing purpose only

   */

  public static synchronized void removeCPResolutionBPListener(ClasspathResolutionBreakpointListener listener) {

    if (CP_RESOLUTION_BP_LISTENERS == null)

      return;

    CP_RESOLUTION_BP_LISTENERS.remove(listener);

    if (CP_RESOLUTION_BP_LISTENERS.size() == 0)

      CP_RESOLUTION_BP_LISTENERS = null;

  }

  private static synchronized ClasspathResolutionBreakpointListener[] getBPListeners() {

    if (CP_RESOLUTION_BP_LISTENERS == null)

      return null;

    return (ClasspathResolutionBreakpointListener[]) CP_RESOLUTION_BP_LISTENERS.toArray(new ClasspathResolutionBreakpointListener[CP_RESOLUTION_BP_LISTENERS.size()]);

  }

  private static void breakpoint(int bp, JavaProject project) {

    ClasspathResolutionBreakpointListener[] listeners = getBPListeners();

    if (listeners == null)

      return;

    for (int j = 0, length = listeners.length; j < length; j++) {

      listeners[j].breakpoint(bp);

    }

  }

  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;

  }

 

  private static boolean areClasspathsEqual(IClasspathEntry[] first, IClasspathEntry[] second) {

    if (first != second){

        if (first == null) return false;

      int length = first.length;

      if (second == null || second.length != length)

        return false;

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

        if (!first[i].equals(second[i]))

          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;

    if (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) {

      return externalPath;

    }

    IPath canonicalPath = null;

    try {

      canonicalPath =

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

    } catch (IOException e) {

      // default to original path

      return externalPath;

    }

    IPath result;

    int canonicalLength = canonicalPath.segmentCount();

    if (canonicalLength == 0) {

      // the java.io.File canonicalization failed

      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 {

        return externalPath;

      }

    }

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

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

      result = result.setDevice(null);

    }

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

    if (externalPath.hasTrailingSeparator()) {

      result = result.addTrailingSeparator();

    }

    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];

    LinkedHashSet cycleParticipants = new LinkedHashSet();

    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 {

            IJavaProject[] projectsInCycle;

            String cycleString = "";   //$NON-NLS-1$

            if (cycleParticipants.isEmpty()) {

              projectsInCycle = null;

            } else {

              projectsInCycle = new IJavaProject[cycleParticipants.size()];

              Iterator it = cycleParticipants.iterator();

              int k = 0;

              while (it.hasNext()) {

                //projectsInCycle[i++] = (IPath) it.next();

                IResource member = workspaceRoot.findMember((IPath) it.next());

                if (member != null && member.getType() == IResource.PROJECT){

                  projectsInCycle[k] = JavaCore.create((IProject)member);

                  if (projectsInCycle[k] != null) {

                    if (k != 0) cycleString += ", "; //$NON-NLS-1$

                    cycleString += projectsInCycle[k++].getElementName();

                  }

                }

              }

            }

            // create new marker

            project.createClasspathProblemMarker(

              new JavaModelStatus(IJavaModelStatusConstants.CLASSPATH_CYCLE, project, cycleString));

          }