--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package net.sourceforge.phpdt.internal.core;
+
+import net.sourceforge.phpdt.core.IJavaElement;
+import net.sourceforge.phpdt.core.IJavaProject;
+import net.sourceforge.phpdt.core.IPackageFragment;
+import net.sourceforge.phpdt.core.IPackageFragmentRoot;
+import net.sourceforge.phpdt.core.JavaCore;
+import net.sourceforge.phpdt.core.JavaModelException;
+import net.sourceforge.phpdt.core.compiler.CharOperation;
+
+import org.eclipse.core.resources.IFolder;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.QualifiedName;
+
+
+/**
+ * @see IPackageFragmentRoot
+ */
+public class PackageFragmentRoot extends Openable implements IPackageFragmentRoot {
+
+ /**
+ * The delimiter between the source path and root path in the
+ * attachment server property.
+ */
+ protected final static char ATTACHMENT_PROPERTY_DELIMITER= '*';
+ /*
+ * No source attachment property
+ */
+ protected final static String NO_SOURCE_ATTACHMENT = ""; //$NON-NLS-1$
+ /*
+ * No source mapper singleton
+ */
+// protected final static SourceMapper NO_SOURCE_MAPPER = new SourceMapper();
+
+ /**
+ * The resource associated with this root.
+ * (an IResource or a java.io.File (for external jar only))
+ */
+ protected Object resource;
+
+/**
+ * Constructs a package fragment root which is the root of the java package
+ * directory hierarchy.
+ */
+protected PackageFragmentRoot(IResource resource, IJavaProject project, String name) {
+ super(PACKAGE_FRAGMENT_ROOT, project, name);
+ this.resource = resource;
+}
+
+/**
+ * @see IPackageFragmentRoot
+ */
+//public void attachSource(IPath sourcePath, IPath rootPath, IProgressMonitor monitor) throws JavaModelException {
+// try {
+// verifyAttachSource(sourcePath);
+// if (monitor != null) {
+// monitor.beginTask(Util.bind("element.attachingSource"), 2); //$NON-NLS-1$
+// }
+// SourceMapper oldMapper= getSourceMapper();
+// IWorkspace workspace = ResourcesPlugin.getWorkspace();
+// boolean rootNeedsToBeClosed= false;
+//
+// if (sourcePath == null) {
+// //source being detached
+// rootNeedsToBeClosed= true;
+// setSourceMapper(null);
+// /* Disable deltas (see 1GDTUSD)
+// // fire a delta to notify the UI about the source detachement.
+// JavaModelManager manager = (JavaModelManager) JavaModelManager.getJavaModelManager();
+// JavaModel model = (JavaModel) getJavaModel();
+// JavaElementDelta attachedSourceDelta = new JavaElementDelta(model);
+// attachedSourceDelta .sourceDetached(this); // this would be a PackageFragmentRoot
+// manager.registerResourceDelta(attachedSourceDelta );
+// manager.fire(); // maybe you want to fire the change later. Let us know about it.
+// */
+// } else {
+// /*
+// // fire a delta to notify the UI about the source attachement.
+// JavaModelManager manager = (JavaModelManager) JavaModelManager.getJavaModelManager();
+// JavaModel model = (JavaModel) getJavaModel();
+// JavaElementDelta attachedSourceDelta = new JavaElementDelta(model);
+// attachedSourceDelta .sourceAttached(this); // this would be a PackageFragmentRoot
+// manager.registerResourceDelta(attachedSourceDelta );
+// manager.fire(); // maybe you want to fire the change later. Let us know about it.
+// */
+//
+// //check if different from the current attachment
+// IPath storedSourcePath= getSourceAttachmentPath();
+// IPath storedRootPath= getSourceAttachmentRootPath();
+// if (monitor != null) {
+// monitor.worked(1);
+// }
+// if (storedSourcePath != null) {
+// if (!(storedSourcePath.equals(sourcePath) && (rootPath != null && rootPath.equals(storedRootPath)) || storedRootPath == null)) {
+// rootNeedsToBeClosed= true;
+// }
+// }
+// // check if source path is valid
+// Object target = JavaModel.getTarget(workspace.getRoot(), sourcePath, false);
+// if (target == null) {
+// if (monitor != null) {
+// monitor.done();
+// }
+// throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.INVALID_PATH, sourcePath));
+// }
+// SourceMapper mapper = createSourceMapper(sourcePath, rootPath);
+// if (rootPath == null && mapper.rootPath != null) {
+// // as a side effect of calling the SourceMapper constructor, the root path was computed
+// rootPath = new Path(mapper.rootPath);
+// }
+// setSourceMapper(mapper);
+// }
+// if (sourcePath == null) {
+// setSourceAttachmentProperty(null); //remove the property
+// } else {
+// //set the property to the path of the mapped source
+// setSourceAttachmentProperty(
+// sourcePath.toString()
+// + (rootPath == null ? "" : (ATTACHMENT_PROPERTY_DELIMITER + rootPath.toString()))); //$NON-NLS-1$
+// }
+// if (rootNeedsToBeClosed) {
+// if (oldMapper != null) {
+// oldMapper.close();
+// }
+// BufferManager manager= BufferManager.getDefaultBufferManager();
+// Enumeration openBuffers= manager.getOpenBuffers();
+// while (openBuffers.hasMoreElements()) {
+// IBuffer buffer= (IBuffer) openBuffers.nextElement();
+// IOpenable possibleMember= buffer.getOwner();
+// if (isAncestorOf((IJavaElement) possibleMember)) {
+// buffer.close();
+// }
+// }
+// if (monitor != null) {
+// monitor.worked(1);
+// }
+// }
+// } catch (JavaModelException e) {
+// setSourceAttachmentProperty(null); // loose info - will be recomputed
+// throw e;
+// } finally {
+// if (monitor != null) {
+// monitor.done();
+// }
+// }
+//}
+
+//SourceMapper createSourceMapper(IPath sourcePath, IPath rootPath) {
+// SourceMapper mapper = new SourceMapper(
+// sourcePath,
+// rootPath == null ? null : rootPath.toOSString(),
+// this.isExternal() ? JavaCore.getOptions() : this.getJavaProject().getOptions(true)); // only project options if associated with resource
+// return mapper;
+//}
+/*
+ * @see org.eclipse.jdt.core.IPackageFragmentRoot#delete
+ */
+//public void delete(
+// int updateResourceFlags,
+// int updateModelFlags,
+// IProgressMonitor monitor)
+// throws JavaModelException {
+//
+// DeletePackageFragmentRootOperation op = new DeletePackageFragmentRootOperation(this, updateResourceFlags, updateModelFlags);
+// runOperation(op, monitor);
+//}
+
+/**
+ * This root is being closed. If this root has an associated source attachment,
+ * close it too.
+ *
+ * @see JavaElement
+ */
+//protected void closing(Object info) throws JavaModelException { TODO remove after 2.1
+// ((PackageFragmentRootInfo) info).sourceMapper = null;
+// super.closing(info);
+//}
+/**
+ * Compute the package fragment children of this package fragment root.
+ *
+ * @exception JavaModelException The resource associated with this package fragment root does not exist
+ */
+//protected boolean computeChildren(OpenableElementInfo info) throws JavaModelException {
+// try {
+// // the underlying resource may be a folder or a project (in the case that the project folder
+// // is actually the package fragment root)
+// IResource resource = getResource();
+// if (resource.getType() == IResource.FOLDER || resource.getType() == IResource.PROJECT) {
+// ArrayList vChildren = new ArrayList(5);
+// char[][] exclusionPatterns = fullExclusionPatternChars();
+// computeFolderChildren((IContainer) resource, "", vChildren, exclusionPatterns); //$NON-NLS-1$
+// IJavaElement[] children = new IJavaElement[vChildren.size()];
+// vChildren.toArray(children);
+// info.setChildren(children);
+// }
+// } catch (JavaModelException e) {
+// //problem resolving children; structure remains unknown
+// info.setChildren(new IJavaElement[]{});
+// throw e;
+// }
+// return true;
+//}
+
+/**
+ * Starting at this folder, create package fragments and add the fragments that are not exclused
+ * to the collection of children.
+ *
+ * @exception JavaModelException The resource associated with this package fragment does not exist
+ */
+//protected void computeFolderChildren(IContainer folder, String prefix, ArrayList vChildren, char[][] exclusionPatterns) throws JavaModelException {
+// IPackageFragment pkg = getPackageFragment(prefix);
+// vChildren.add(pkg);
+// try {
+// JavaProject javaProject = (JavaProject)getJavaProject();
+// IResource[] members = folder.members();
+// for (int i = 0, max = members.length; i < max; i++) {
+// IResource member = members[i];
+// String memberName = member.getName();
+// if (member.getType() == IResource.FOLDER
+// && Util.isValidFolderNameForPackage(memberName)
+// && !Util.isExcluded(member, exclusionPatterns)) {
+//
+// // eliminate binary output only if nested inside direct subfolders
+// if (javaProject.contains(member)) {
+// String newPrefix;
+// if (prefix.length() == 0) {
+// newPrefix = memberName;
+// } else {
+// newPrefix = prefix + "." + memberName; //$NON-NLS-1$
+// }
+// computeFolderChildren((IFolder) member, newPrefix, vChildren, exclusionPatterns);
+// }
+// }
+// }
+// } catch(IllegalArgumentException e){
+// throw new JavaModelException(e, IJavaModelStatusConstants.ELEMENT_DOES_NOT_EXIST); // could be thrown by ElementTree when path is not found
+// } catch (CoreException e) {
+// throw new JavaModelException(e);
+// }
+//}
+/*
+ * Computes and returns the source attachment root path for the given source attachment path.
+ * Returns <code>null</code> if none could be found.
+ *
+ * @param sourceAttachmentPath the given absolute path to the source archive or folder
+ * @return the computed source attachment root path or <code>null</cde> if none could be found
+ * @throws JavaModelException
+ */
+//public IPath computeSourceAttachmentRootPath(IPath sourceAttachmentPath) throws JavaModelException {
+// IPath sourcePath = this.getSourceAttachmentPath();
+// if (sourcePath == null) return null;
+// SourceMapper mapper =
+// new SourceMapper(
+// sourcePath,
+// null, // detect root path
+// this.isExternal() ? JavaCore.getOptions() : this.getJavaProject().getOptions(true) // only project options if associated with resource
+// );
+// if (mapper.rootPath == null) return null;
+// return new Path(mapper.rootPath);
+//}
+/*
+ * @see org.eclipse.jdt.core.IPackageFragmentRoot#copy
+ */
+//public void copy(
+// IPath destination,
+// int updateResourceFlags,
+// int updateModelFlags,
+// IClasspathEntry sibling,
+// IProgressMonitor monitor)
+// throws JavaModelException {
+//
+// CopyPackageFragmentRootOperation op =
+// new CopyPackageFragmentRootOperation(this, destination, updateResourceFlags, updateModelFlags, sibling);
+// runOperation(op, monitor);
+//}
+
+
+
+/**
+ * Returns a new element info for this element.
+ */
+//protected OpenableElementInfo createElementInfo() {
+// return new PackageFragmentRootInfo();
+//}
+
+/**
+ * @see IPackageFragmentRoot
+ */
+//public IPackageFragment createPackageFragment(String name, boolean force, IProgressMonitor monitor) throws JavaModelException {
+// CreatePackageFragmentOperation op = new CreatePackageFragmentOperation(this, name, force);
+// runOperation(op, monitor);
+// return getPackageFragment(name);
+//}
+
+/**
+ * Returns the root's kind - K_SOURCE or K_BINARY, defaults
+ * to K_SOURCE if it is not on the classpath.
+ *
+ * @exception NotPresentException if the project and root do
+ * not exist.
+ */
+//protected int determineKind(IResource underlyingResource) throws JavaModelException {
+// IClasspathEntry[] entries= ((JavaProject)getJavaProject()).getExpandedClasspath(true);
+// for (int i= 0; i < entries.length; i++) {
+// IClasspathEntry entry= entries[i];
+// if (entry.getPath().equals(underlyingResource.getFullPath())) {
+// return entry.getContentKind();
+// }
+// }
+// return IPackageFragmentRoot.K_SOURCE;
+//}
+
+/**
+ * Compares two objects for equality;
+ * for <code>PackageFragmentRoot</code>s, equality is having the
+ * same <code>JavaModel</code>, same resources, and occurrence count.
+ *
+ */
+public boolean equals(Object o) {
+ if (this == o)
+ return true;
+ if (!(o instanceof PackageFragmentRoot))
+ return false;
+ PackageFragmentRoot other = (PackageFragmentRoot) o;
+ return getJavaModel().equals(other.getJavaModel()) &&
+ this.resource.equals(other.resource) &&
+ fOccurrenceCount == other.fOccurrenceCount;
+}
+
+/**
+ * @see IJavaElement
+ */
+//public boolean exists() {
+// return super.exists()
+// && isOnClasspath();
+//}
+
+//public IClasspathEntry findSourceAttachmentRecommendation() {
+// try {
+// IPath rootPath = this.getPath();
+// IClasspathEntry entry;
+// IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();
+//
+// // try on enclosing project first
+// JavaProject parentProject = (JavaProject) getJavaProject();
+// try {
+// entry = parentProject.getClasspathEntryFor(rootPath);
+// if (entry != null){
+// Object target = JavaModel.getTarget(workspaceRoot, entry.getSourceAttachmentPath(), true);
+// if (target instanceof IFile){
+// IFile file = (IFile) target;
+// if (Util.isArchiveFileName(file.getName())){
+// return entry;
+// }
+// } else if (target instanceof IFolder) {
+// return entry;
+// }
+// if (target instanceof java.io.File){
+// java.io.File file = (java.io.File) target;
+// if (file.isFile()) {
+// if (Util.isArchiveFileName(file.getName())){
+// return entry;
+// }
+// } else {
+// // external directory
+// return entry;
+// }
+// }
+// }
+// } catch(JavaModelException e){
+// }
+//
+// // iterate over all projects
+// IJavaModel model = getJavaModel();
+// IJavaProject[] jProjects = model.getJavaProjects();
+// for (int i = 0, max = jProjects.length; i < max; i++){
+// JavaProject jProject = (JavaProject) jProjects[i];
+// if (jProject == parentProject) continue; // already done
+// try {
+// entry = jProject.getClasspathEntryFor(rootPath);
+// if (entry != null){
+// Object target = JavaModel.getTarget(workspaceRoot, entry.getSourceAttachmentPath(), true);
+// if (target instanceof IFile){
+// IFile file = (IFile) target;
+// if (Util.isArchiveFileName(file.getName())){
+// return entry;
+// }
+// } else if (target instanceof IFolder) {
+// return entry;
+// }
+// if (target instanceof java.io.File){
+// java.io.File file = (java.io.File) target;
+// if (file.isFile()) {
+// if (Util.isArchiveFileName(file.getName())){
+// return entry;
+// }
+// } else {
+// // external directory
+// return entry;
+// }
+// }
+// }
+// } catch(JavaModelException e){
+// }
+// }
+// } catch(JavaModelException e){
+// }
+//
+// return null;
+//}
+
+/*
+ * Returns the exclusion patterns from the classpath entry associated with this root.
+ */
+//char[][] fullExclusionPatternChars() {
+// try {
+// if (this.isOpen() && this.getKind() != IPackageFragmentRoot.K_SOURCE) return null;
+// ClasspathEntry entry = (ClasspathEntry)getRawClasspathEntry();
+// if (entry == null) {
+// return null;
+// } else {
+// return entry.fullExclusionPatternChars();
+// }
+// } catch (JavaModelException e) {
+// return null;
+// }
+//}
+
+/**
+ * @see Openable
+ */
+//protected boolean generateInfos(OpenableElementInfo info, IProgressMonitor pm, Map newElements, IResource underlyingResource) throws JavaModelException {
+//
+// ((PackageFragmentRootInfo) info).setRootKind(determineKind(underlyingResource));
+// return computeChildren(info);
+//}
+
+/**
+ * @see JavaElement#getHandleMemento()
+ */
+protected char getHandleMementoDelimiter() {
+ return JavaElement.JEM_PACKAGEFRAGMENTROOT;
+}
+/**
+ * @see JavaElement#getHandleMemento()
+ */
+public String getHandleMemento(){
+ IPath path;
+ IResource resource = getResource();
+ if (resource != null) {
+ // internal jar or regular root
+ if (getResource().getProject().equals(getJavaProject().getProject())) {
+ path = resource.getProjectRelativePath();
+ } else {
+ path = resource.getFullPath();
+ }
+ } else {
+ // external jar
+ path = getPath();
+ }
+ StringBuffer buff= new StringBuffer(((JavaElement)getParent()).getHandleMemento());
+ buff.append(getHandleMementoDelimiter());
+ buff.append(path.toString());
+ return buff.toString();
+}
+/**
+ * @see IPackageFragmentRoot
+ */
+//public int getKind() throws JavaModelException {
+// return ((PackageFragmentRootInfo)getElementInfo()).getRootKind();
+//}
+
+/**
+ * Returns an array of non-java resources contained in the receiver.
+ */
+//public Object[] getNonJavaResources() throws JavaModelException {
+// return ((PackageFragmentRootInfo) getElementInfo()).getNonJavaResources(getJavaProject(), getResource(), this);
+//}
+
+/**
+ * @see IPackageFragmentRoot
+ */
+public IPackageFragment getPackageFragment(String packageName) {
+ if (packageName.indexOf(' ') != -1) { // tolerate package names with spaces (e.g. 'x . y') (http://bugs.eclipse.org/bugs/show_bug.cgi?id=21957)
+ char[][] compoundName = Util.toCompoundChars(packageName);
+ StringBuffer buffer = new StringBuffer(packageName.length());
+ for (int i = 0, length = compoundName.length; i < length; i++) {
+ buffer.append(CharOperation.trim(compoundName[i]));
+ if (i != length-1) {
+ buffer.append('.');
+ }
+ }
+ packageName = buffer.toString();
+ }
+ return new PackageFragment(this, packageName);
+}
+
+/**
+ * Returns the package name for the given folder
+ * (which is a decendent of this root).
+ */
+protected String getPackageName(IFolder folder) throws JavaModelException {
+ IPath myPath= getPath();
+ IPath pkgPath= folder.getFullPath();
+ int mySegmentCount= myPath.segmentCount();
+ int pkgSegmentCount= pkgPath.segmentCount();
+ StringBuffer name = new StringBuffer(IPackageFragment.DEFAULT_PACKAGE_NAME);
+ for (int i= mySegmentCount; i < pkgSegmentCount; i++) {
+ if (i > mySegmentCount) {
+ name.append('.');
+ }
+ name.append(pkgPath.segment(i));
+ }
+ return name.toString();
+}
+
+/**
+ * @see IJavaElement
+ */
+public IPath getPath() {
+ return getResource().getFullPath();
+}
+
+/*
+ * @see IPackageFragmentRoot
+ */
+//public IClasspathEntry getRawClasspathEntry() throws JavaModelException {
+//
+// IClasspathEntry rawEntry = null;
+// IJavaProject project = this.getJavaProject();
+// project.getResolvedClasspath(true); // force the reverse rawEntry cache to be populated
+// JavaModelManager.PerProjectInfo perProjectInfo =
+// JavaModelManager.getJavaModelManager().getPerProjectInfoCheckExistence(project.getProject());
+// if (perProjectInfo != null && perProjectInfo.resolvedPathToRawEntries != null) {
+// rawEntry = (IClasspathEntry) perProjectInfo.resolvedPathToRawEntries.get(this.getPath());
+// }
+// return rawEntry;
+//}
+
+/*
+ * @see IJavaElement
+ */
+public IResource getResource() {
+ return (IResource)this.resource;
+}
+
+/**
+ * @see IPackageFragmentRoot
+ */
+//public IPath getSourceAttachmentPath() throws JavaModelException {
+// if (getKind() != K_BINARY) return null;
+//
+// String serverPathString= getSourceAttachmentProperty();
+// if (serverPathString == null) {
+// return null;
+// }
+// int index= serverPathString.lastIndexOf(ATTACHMENT_PROPERTY_DELIMITER);
+// if (index < 0) {
+// // no root path specified
+// return new Path(serverPathString);
+// } else {
+// String serverSourcePathString= serverPathString.substring(0, index);
+// return new Path(serverSourcePathString);
+// }
+//}
+
+/**
+ * Returns the server property for this package fragment root's
+ * source attachement.
+ */
+//protected String getSourceAttachmentProperty() throws JavaModelException {
+// String propertyString = null;
+// QualifiedName qName= getSourceAttachmentPropertyName();
+// try {
+// propertyString = ResourcesPlugin.getWorkspace().getRoot().getPersistentProperty(qName);
+//
+// // if no existing source attachment information, then lookup a recommendation from classpath entries
+// if (propertyString == null) {
+// IClasspathEntry recommendation = findSourceAttachmentRecommendation();
+// if (recommendation != null) {
+// IPath rootPath = recommendation.getSourceAttachmentRootPath();
+// propertyString =
+// recommendation.getSourceAttachmentPath().toString()
+// + ((rootPath == null)
+// ? "" : //$NON-NLS-1$
+// (ATTACHMENT_PROPERTY_DELIMITER + rootPath.toString()));
+// setSourceAttachmentProperty(propertyString);
+// } else {
+// // mark as being already looked up
+// setSourceAttachmentProperty(NO_SOURCE_ATTACHMENT);
+// }
+// } else if (NO_SOURCE_ATTACHMENT.equals(propertyString)) {
+// // already looked up and no source attachment found
+// return null;
+// }
+// return propertyString;
+// } catch (CoreException ce) {
+// throw new JavaModelException(ce);
+// }
+//}
+
+/**
+ * Returns the qualified name for the source attachment property
+ * of this root.
+ */
+protected QualifiedName getSourceAttachmentPropertyName() throws JavaModelException {
+ return new QualifiedName(JavaCore.PLUGIN_ID, "sourceattachment: " + this.getPath().toOSString()); //$NON-NLS-1$
+}
+
+public void setSourceAttachmentProperty(String property) {
+ try {
+ ResourcesPlugin.getWorkspace().getRoot().setPersistentProperty(this.getSourceAttachmentPropertyName(), property);
+ } catch (CoreException ce) {
+ }
+}
+
+/**
+ * For use by <code>AttachSourceOperation</code> only.
+ * Sets the source mapper associated with this root.
+ */
+//public void setSourceMapper(SourceMapper mapper) throws JavaModelException {
+// ((PackageFragmentRootInfo) getElementInfo()).setSourceMapper(mapper);
+//}
+
+
+
+/**
+ * @see IPackageFragmentRoot
+ */
+//public IPath getSourceAttachmentRootPath() throws JavaModelException {
+// if (getKind() != K_BINARY) return null;
+//
+// String serverPathString= getSourceAttachmentProperty();
+// if (serverPathString == null) {
+// return null;
+// }
+// int index = serverPathString.lastIndexOf(ATTACHMENT_PROPERTY_DELIMITER);
+// if (index == -1) return null;
+// String serverRootPathString= IPackageFragmentRoot.DEFAULT_PACKAGEROOT_PATH;
+// if (index != serverPathString.length() - 1) {
+// serverRootPathString= serverPathString.substring(index + 1);
+// }
+// return new Path(serverRootPathString);
+//}
+
+/**
+ * @see JavaElement
+ */
+//public SourceMapper getSourceMapper() {
+// SourceMapper mapper;
+// try {
+// PackageFragmentRootInfo rootInfo = (PackageFragmentRootInfo) getElementInfo();
+// mapper = rootInfo.getSourceMapper();
+// if (mapper == null) {
+// // first call to this method
+// IPath sourcePath= getSourceAttachmentPath();
+// if (sourcePath != null) {
+// IPath rootPath= getSourceAttachmentRootPath();
+// mapper = this.createSourceMapper(sourcePath, rootPath);
+// if (rootPath == null && mapper.rootPath != null) {
+// // as a side effect of calling the SourceMapper constructor, the root path was computed
+// rootPath = new Path(mapper.rootPath);
+//
+// //set the property to the path of the mapped source
+// this.setSourceAttachmentProperty(
+// sourcePath.toString()
+// + ATTACHMENT_PROPERTY_DELIMITER
+// + rootPath.toString());
+// }
+// rootInfo.setSourceMapper(mapper);
+// } else {
+// // remember that no source is attached
+// rootInfo.setSourceMapper(NO_SOURCE_MAPPER);
+// mapper = null;
+// }
+// } else if (mapper == NO_SOURCE_MAPPER) {
+// // a previous call to this method found out that no source was attached
+// mapper = null;
+// }
+// } catch (JavaModelException e) {
+// // no source can be attached
+// mapper = null;
+// }
+// return mapper;
+//}
+
+/**
+ * @see IJavaElement
+ */
+public IResource getUnderlyingResource() throws JavaModelException {
+ if (!exists()) throw newNotPresentException();
+ return getResource();
+}
+
+public int hashCode() {
+ return this.resource.hashCode();
+}
+
+/**
+ * @see IPackageFragmentRoot
+ */
+public boolean isArchive() {
+ return false;
+}
+
+/**
+ * @see IPackageFragmentRoot
+ */
+public boolean isExternal() {
+ return false;
+}
+
+/*
+ * Returns whether this package fragment root is on the classpath of its project.
+ */
+//protected boolean isOnClasspath() {
+// if (this.getElementType() == IJavaElement.JAVA_PROJECT){
+// return true;
+// }
+//
+// IPath path = this.getPath();
+// try {
+// // check package fragment root on classpath of its project
+// IJavaProject project = this.getJavaProject();
+// IClasspathEntry[] classpath = project.getResolvedClasspath(true);
+// for (int i = 0, length = classpath.length; i < length; i++) {
+// IClasspathEntry entry = classpath[i];
+// if (entry.getPath().equals(path)) {
+// return true;
+// }
+// }
+// } catch(JavaModelException e){
+// // could not read classpath, then assume it is outside
+// }
+// return false;
+//}
+/*
+ * @see org.eclipse.jdt.core.IPackageFragmentRoot#move
+ */
+//public void move(
+// IPath destination,
+// int updateResourceFlags,
+// int updateModelFlags,
+// IClasspathEntry sibling,
+// IProgressMonitor monitor)
+// throws JavaModelException {
+//
+// MovePackageFragmentRootOperation op =
+// new MovePackageFragmentRootOperation(this, destination, updateResourceFlags, updateModelFlags, sibling);
+// runOperation(op, monitor);
+//}
+//
+//
+//protected void openWhenClosed(IProgressMonitor pm) throws JavaModelException {
+// if (!this.resourceExists()
+// || !this.isOnClasspath()) {
+// throw newNotPresentException();
+// }
+// super.openWhenClosed(pm);
+//}
+
+/**
+ * Recomputes the children of this element, based on the current state
+ * of the workbench.
+ */
+//public void refreshChildren() {
+// try {
+// OpenableElementInfo info= (OpenableElementInfo)getElementInfo();
+// computeChildren(info);
+// } catch (JavaModelException e) {
+// // do nothing.
+// }
+//}
+
+/*
+ * @see JavaElement#rootedAt(IJavaProject)
+ */
+public IJavaElement rootedAt(IJavaProject project) {
+ return
+ new PackageFragmentRoot(
+ getResource(),
+ project,
+ fName);
+}
+
+/**
+ * @private Debugging purposes
+ */
+protected void toStringInfo(int tab, StringBuffer buffer, Object info) {
+ buffer.append(this.tabString(tab));
+ if (getElementName().length() == 0) {
+ buffer.append("[project root]"); //$NON-NLS-1$
+ } else {
+ IPath path = getPath();
+ if (getJavaProject().getElementName().equals(path.segment(0))) {
+ buffer.append(path.removeFirstSegments(1).makeRelative());
+ } else {
+ buffer.append(path);
+ }
+ }
+ if (info == null) {
+ buffer.append(" (not open)"); //$NON-NLS-1$
+ }
+}
+
+/**
+ * Possible failures: <ul>
+ * <li>ELEMENT_NOT_PRESENT - the root supplied to the operation
+ * does not exist
+ * <li>INVALID_ELEMENT_TYPES - the root is not of kind K_BINARY
+ * <li>RELATIVE_PATH - the path supplied to this operation must be
+ * an absolute path
+ * </ul>
+ */
+//protected void verifyAttachSource(IPath sourcePath) throws JavaModelException {
+// if (!exists()) {
+// throw newNotPresentException();
+// } else if (this.getKind() != K_BINARY) {
+// throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.INVALID_ELEMENT_TYPES, this));
+// } else if (sourcePath != null && !sourcePath.isAbsolute()) {
+// throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.RELATIVE_PATH, sourcePath));
+// }
+//}
+
+}
git://git.phpeclipse.com / phpeclipse.git / blobdiff