package org.eclipse.jdt.internal.core;

/*
 * (c) Copyright IBM Corp. 2000, 2001.
 * All Rights Reserved.
 */
import org.eclipse.core.resources.*;
import org.eclipse.core.runtime.IPath;

import org.eclipse.jdt.core.*;

import java.io.File;

/**
 * @see IClasspathEntry
 */
public class ClasspathEntry implements IClasspathEntry {

	/**
	 * Describes the kind of classpath entry - one of 
	 * CPE_PROJECT, CPE_LIBRARY or CPE_SOURCE.
	 */
	protected int entryKind;
	
	/**
	 * Describes the kind of package fragment roots found on
	 * this classpath entry - either K_BINARY or K_SOURCE or
	 * K_OUTPUT.
	 */
	protected int contentKind;

	/**
	 * The meaning of the path of a classpath entry depends on its entry kind:<ul>
	 *	<li>Source code in the current project (<code>CPE_SOURCE</code>) -  
	 *      The path associated with this entry is the absolute path to the root folder. </li>
	 *	<li>A binary library in the current project (<code>CPE_LIBRARY</code>) - the path
	 *		associated with this entry is the absolute path to the JAR (or root folder), and 
	 *		in case it refers to an external JAR, then there is no associated resource in 
	 *		the workbench.
	 *	<li>A required project (<code>CPE_PROJECT</code>) - the path of the entry denotes the
	 *		path to the corresponding project resource.</li>
	 *  <li>A variable entry (<code>CPE_VARIABLE</code>) - the first segment of the path 
	 *      is the name of a classpath variable. If this classpath variable
	 *		is bound to the path <it>P</it>, the path of the corresponding classpath entry
	 *		is computed by appending to <it>P</it> the segments of the returned
	 *		path without the variable.</li>
	 */
	protected IPath path;

	/**
	 * Describes the path to the source archive associated with this
	 * classpath entry, or <code>null</code> if this classpath entry has no
	 * source attachment.
	 * <p>
	 * Only library and variable classpath entries may have source attachments.
	 * For library classpath entries, the result path (if present) locates a source
	 * archive. For variable classpath entries, the result path (if present) has
	 * an analogous form and meaning as the variable path, namely the first segment 
	 * is the name of a classpath variable.
	 */
	protected IPath sourceAttachmentPath;

	/**
	 * Describes the path within the source archive where package fragments
	 * are located. An empty path indicates that packages are located at
	 * the root of the source archive. Returns a non-<code>null</code> value
	 * if and only if <code>getSourceAttachmentPath</code> returns 
	 * a non-<code>null</code> value.
	 */
	protected IPath sourceAttachmentRootPath;

	/**
	 * A constant indicating an output location.
	 */
	protected static final int K_OUTPUT= 10;
/**
 * Creates a class path entry of the specified kind with the given path.
 */
public ClasspathEntry(int contentKind, int entryKind, IPath path, IPath sourceAttachmentPath, IPath sourceAttachmentRootPath) {
	this.contentKind = contentKind;
	this.entryKind = entryKind;
	this.path = path;
	this.sourceAttachmentPath = sourceAttachmentPath;
	this.sourceAttachmentRootPath = sourceAttachmentRootPath;
}
/**
 * Returns true if the given object is a classpath entry
 * with equivalent attributes.
 */
public boolean equals(Object object) {
	if (this == object) return true;
	if (object instanceof IClasspathEntry) {
		IClasspathEntry otherEntry = (IClasspathEntry) object;

		if (this.contentKind != otherEntry.getContentKind()) return false;

		if (this.entryKind != otherEntry.getEntryKind()) return false;
		
		if (!this.path.equals(otherEntry.getPath())) return false;

		IPath otherPath = otherEntry.getSourceAttachmentPath();
		if (this.sourceAttachmentPath == null) { 
			if (otherPath != null) return false;
		} else {
			if (!this.sourceAttachmentPath.equals(otherPath)) return false;
		}
		
		otherPath = otherEntry.getSourceAttachmentRootPath();
		if (this.sourceAttachmentRootPath == null) { 
			if (otherPath != null) return false;
		} else {
			if (!this.sourceAttachmentRootPath.equals(otherPath)) return false;
		}

	    return true;
	} else {
		return false;
	}
}
/**
 * @see IClasspathEntry
 */
public int getContentKind() {
	return this.contentKind;
}
/**
 * @see IClasspathEntry
 */
public int getEntryKind() {
	return this.entryKind;
}
/**
 * @see IClasspathEntry
 */
public IPath getPath() {
	return this.path;
}
/**
 * @see IClasspathEntry
 * @deprecated
 */
public IClasspathEntry getResolvedEntry() {

	return JavaCore.getResolvedClasspathEntry(this);
}
/**
 * @see IClasspathEntry
 */
public IPath getSourceAttachmentPath() {
	return this.sourceAttachmentPath;
}
/**
 * @see IClasspathEntry
 */
public IPath getSourceAttachmentRootPath() {
	return this.sourceAttachmentRootPath;
}
/**
 * Returns the hash code for this classpath entry
 */
public int hashCode() {
	return this.path.hashCode();
}
/**
 * Returns a printable representation of this classpath entry.
 */
public String toString() {
	StringBuffer buffer= new StringBuffer();
	buffer.append(getPath().toString());
	buffer.append('[');
	switch (getEntryKind()) {
		case IClasspathEntry.CPE_LIBRARY:
			buffer.append("CPE_LIBRARY"/*nonNLS*/);
			break;
		case IClasspathEntry.CPE_PROJECT:
			buffer.append("CPE_PROJECT"/*nonNLS*/);
			break;
		case IClasspathEntry.CPE_SOURCE:
			buffer.append("CPE_SOURCE"/*nonNLS*/);
			break;
		case IClasspathEntry.CPE_VARIABLE:
			buffer.append("CPE_VARIABLE"/*nonNLS*/);
			break;
	}
	buffer.append("]["/*nonNLS*/);
	switch (getContentKind()) {
		case IPackageFragmentRoot.K_BINARY:
			buffer.append("K_BINARY"/*nonNLS*/);
			break;
		case IPackageFragmentRoot.K_SOURCE:
			buffer.append("K_SOURCE"/*nonNLS*/);
			break;
		case ClasspathEntry.K_OUTPUT:
			buffer.append("K_OUTPUT"/*nonNLS*/);
			break;
	}
	buffer.append(']');
	if (getSourceAttachmentPath() != null){
		buffer.append("[sourcePath:"/*nonNLS*/);
		buffer.append(getSourceAttachmentPath());
		buffer.append(']');
	}
	if (getSourceAttachmentRootPath() != null){
		buffer.append("[rootPath:"/*nonNLS*/);
		buffer.append(getSourceAttachmentRootPath());
		buffer.append(']');
	}
	return buffer.toString();
}
}