/*******************************************************************************
* Copyright (c) 2004, 2012 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
*******************************************************************************/
package org.eclipse.che.jdt.internal.core;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaModel;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.WorkingCopyOwner;
import org.eclipse.jdt.internal.core.util.MementoTokenizer;
import java.io.File;
import java.util.Map;
/**
* Implementation of {@link org.eclipse.jdt.core.IJavaModel}. The Java Model maintains a cache of active
* {@link org.eclipse.jdt.core.IJavaProject}s in a workspace. A Java Model is specific to a workspace.
* To retrieve a workspace's model, use the
* {@link org.eclipse.jdt.core.IJavaElement#getJavaModel() #getJavaModel()} method.
*
* @see org.eclipse.jdt.core.IJavaModel
*/
@SuppressWarnings({"rawtypes", "unchecked"})
public class JavaModel extends Openable implements IJavaModel {
/**
* Constructs a new Java Model on the given workspace.
* Note that only one instance of JavaModel handle should ever be created.
* One should only indirect through JavaModelManager#getJavaModel() to get
* access to it.
*
* @exception Error if called more than once
*/
protected JavaModel(JavaModelManager manager) throws Error {
super(null, manager);
}
protected boolean buildStructure(OpenableElementInfo info, IProgressMonitor pm, Map newElements, File underlyingResource) /*throws JavaModelException*/ {
// // determine my children
// IProject[] projects = ResourcesPlugin.getWorkspace().getRoot().getProjects();
// int length = projects.length;
// IJavaElement[] children = new IJavaElement[length];
// int index = 0;
// for (int i = 0; i < length; i++) {
// IProject project = projects[i];
// if (JavaProject.hasJavaNature(project)) {
// children[index++] = getJavaProject(project);
// }
// }
// if (index < length)
// System.arraycopy(children, 0, children = new IJavaElement[index], 0, index);
// info.setChildren(children);
//
// newElements.put(this, info);
//
// return true;
throw new UnsupportedOperationException();
}
/*
* @see IJavaModel
*/
public boolean contains(IResource resource) {
// switch (resource.getType()) {
// case IResource.ROOT:
// case IResource.PROJECT:
// return true;
// }
// // file or folder
// IJavaProject[] projects;
// try {
// projects = getJavaProjects();
// } catch (JavaModelException e) {
// return false;
// }
// for (int i = 0, length = projects.length; i < length; i++) {
// JavaProject project = (JavaProject)projects[i];
// if (!project.contains(resource)) {
// return false;
// }
// }
// return true;
throw new UnsupportedOperationException();
}
/**
* @see org.eclipse.jdt.core.IJavaModel
*/
public void copy(IJavaElement[] elements, IJavaElement[] containers, IJavaElement[] siblings, String[] renamings, boolean force, IProgressMonitor monitor) throws
JavaModelException {
// if (elements != null && elements.length > 0 && elements[0] != null && elements[0].getElementType() < IJavaElement.TYPE) {
// runOperation(new CopyResourceElementsOperation(elements, containers, force), elements, siblings, renamings, monitor);
// } else {
// runOperation(new CopyElementsOperation(elements, containers, force), elements, siblings, renamings, monitor);
// }
throw new UnsupportedOperationException();
}
/**
* Returns a new element info for this element.
*/
protected Object createElementInfo() {
return new JavaModelInfo();
}
/**
* @see org.eclipse.jdt.core.IJavaModel
*/
public void delete(IJavaElement[] elements, boolean force, IProgressMonitor monitor) throws JavaModelException {
// if (elements != null && elements.length > 0 && elements[0] != null && elements[0].getElementType() < IJavaElement.TYPE) {
// new DeleteResourceElementsOperation(elements, force).runOperation(monitor);
// } else {
// new DeleteElementsOperation(elements, force).runOperation(monitor);
// }
throw new UnsupportedOperationException();}
public boolean equals(Object o) {
if (!(o instanceof JavaModel)) return false;
return super.equals(o);
}
/**
* @see org.eclipse.jdt.core.IJavaElement
*/
public int getElementType() {
return JAVA_MODEL;
}
/*
* @see JavaElement
*/
public IJavaElement getHandleFromMemento(String token, MementoTokenizer memento, WorkingCopyOwner owner) {
switch (token.charAt(0)) {
case JEM_JAVAPROJECT:
if (!memento.hasMoreTokens()) return this;
String projectName = memento.nextToken();
JavaElement project = (JavaElement)getJavaProject(projectName);
return project.getHandleFromMemento(memento, owner);
}
return null;
}
/**
* @see org.eclipse.jdt.internal.core.JavaElement#getHandleMemento(StringBuffer)
*/
protected void getHandleMemento(StringBuffer buff) {
buff.append(getElementName());
}
/**
* Returns the <code>char</code> that marks the start of this handles
* contribution to a memento.
*/
protected char getHandleMementoDelimiter(){
Assert.isTrue(false, "Should not be called"); //$NON-NLS-1$
return 0;
}
/**
* @see org.eclipse.jdt.core.IJavaModel
*/
public IJavaProject getJavaProject(String projectName) {
// return new JavaProject(ResourcesPlugin.getWorkspace().getRoot().getProject(projectName), this);
throw new UnsupportedOperationException();
}
/**
* Returns the active Java project associated with the specified
* resource, or <code>null</code> if no Java project yet exists
* for the resource.
*
* @exception IllegalArgumentException if the given resource
* is not one of an IProject, IFolder, or IFile.
*/
public IJavaProject getJavaProject(IResource resource) {
// switch(resource.getType()){
// case IResource.FOLDER:
// return new JavaProject(((IFolder)resource).getProject(), this);
// case IResource.FILE:
// return new JavaProject(((IFile)resource).getProject(), this);
// case IResource.PROJECT:
// return new JavaProject((IProject)resource, this);
// default:
// throw new IllegalArgumentException(Messages.element_invalidResourceForProject);
// }
throw new UnsupportedOperationException();
}
/**
* @see org.eclipse.jdt.core.IJavaModel
*/
public IJavaProject[] getJavaProjects() throws JavaModelException {
// ArrayList list = getChildrenOfType(JAVA_PROJECT);
// IJavaProject[] array= new IJavaProject[list.size()];
// list.toArray(array);
// return array;
return new IJavaProject[]{manager.getJavaProject()};
}
/**
* @see org.eclipse.jdt.core.IJavaModel
*/
public Object[] getNonJavaResources() throws JavaModelException {
// return ((JavaModelInfo) getElementInfo()).getNonJavaResources();
throw new UnsupportedOperationException();
}
/*
* @see IJavaElement
*/
public IPath getPath() {
return Path.ROOT;
}
/*
* @see IJavaElement
*/
public File resource(PackageFragmentRoot root) {
// return ResourcesPlugin.getWorkspace().getRoot();
throw new UnsupportedOperationException();
}
@Override
public boolean isOpen() {
return true;
}
@Override
public void open(IProgressMonitor pm) throws JavaModelException {
}
/**
* @see org.eclipse.jdt.core.IOpenable
*/
public IResource getUnderlyingResource() {
return null;
}
/**
* Returns the workbench associated with this object.
*/
public IWorkspace getWorkspace() {
return ResourcesPlugin.getWorkspace();
}
/**
* @see org.eclipse.jdt.core.IJavaModel
*/
public void move(IJavaElement[] elements, IJavaElement[] containers, IJavaElement[] siblings, String[] renamings, boolean force, IProgressMonitor monitor) throws
JavaModelException {
// if (elements != null && elements.length > 0 && elements[0] != null && elements[0].getElementType() < IJavaElement.TYPE) {
// runOperation(new MoveResourceElementsOperation(elements, containers, force), elements, siblings, renamings, monitor);
// } else {
// runOperation(new MoveElementsOperation(elements, containers, force), elements, siblings, renamings, monitor);
// }
throw new UnsupportedOperationException();
}
/**
* @see org.eclipse.jdt.core.IJavaModel#refreshExternalArchives(org.eclipse.jdt.core.IJavaElement[], org.eclipse.core.runtime.IProgressMonitor)
*/
public void refreshExternalArchives(IJavaElement[] elementsScope, IProgressMonitor monitor) throws JavaModelException {
// if (elementsScope == null){
// elementsScope = new IJavaElement[] { this };
// }
// JavaModelManager.getJavaModelManager().getDeltaProcessor().checkExternalArchiveChanges(elementsScope, monitor);
throw new UnsupportedOperationException();
}
/**
* @see org.eclipse.jdt.core.IJavaModel
*/
public void rename(IJavaElement[] elements, IJavaElement[] destinations, String[] renamings, boolean force, IProgressMonitor monitor) throws
JavaModelException {
// MultiOperation op;
// if (elements != null && elements.length > 0 && elements[0] != null && elements[0].getElementType() < IJavaElement.TYPE) {
// op = new RenameResourceElementsOperation(elements, destinations, renamings, force);
// } else {
// op = new RenameElementsOperation(elements, destinations, renamings, force);
// }
//
// op.runOperation(monitor);
throw new UnsupportedOperationException();
}
///**
// * Configures and runs the <code>MultiOperation</code>.
// */
//protected void runOperation(MultiOperation op, IJavaElement[] elements, IJavaElement[] siblings, String[] renamings, IProgressMonitor monitor) throws
// JavaModelException {
// op.setRenamings(renamings);
// if (siblings != null) {
// for (int i = 0; i < elements.length; i++) {
// op.setInsertBefore(elements[i], siblings[i]);
// }
// }
// op.runOperation(monitor);
//}
/**
* @private Debugging purposes
*/
protected void toStringInfo(int tab, StringBuffer buffer, Object info, boolean showResolvedInfo) {
buffer.append(tabString(tab));
buffer.append("Java Model"); //$NON-NLS-1$
if (info == null) {
buffer.append(" (not open)"); //$NON-NLS-1$
}
}
/**
* Helper method - for the provided {@link org.eclipse.core.runtime.IPath}, returns:
* <ul>
* <li>If the path corresponds to an internal file or folder, the {@link org.eclipse.core.resources.IResource} for that resource
* <li>If the path corresponds to an external folder linked through {@link org.eclipse.jdt.internal.core.ExternalFoldersManager},
* the {@link org.eclipse.core.resources.IFolder} for that folder
* <li>If the path corresponds to an external library archive, the {@link java.io.File} for that archive
* <li>Can return <code>null</code> if <code>checkResourceExistence</code> is <code>true</code>
* and the entity referred to by the path does not exist on the file system
* </ul>
* Internal items must be referred to using container-relative paths.
*/
public static Object getTarget(IPath path, boolean checkResourceExistence) {
Object target = getWorkspaceTarget(path); // Implicitly checks resource existence
if (target != null)
return target;
return getExternalTarget(path, checkResourceExistence);
}
/**
* Helper method - returns the {@link org.eclipse.core.resources.IResource} corresponding to the provided {@link org.eclipse.core.runtime.IPath},
* or <code>null</code> if no such resource exists.
*/
public static IResource getWorkspaceTarget(IPath path) {
// if (path == null || path.getDevice() != null)
// return null;
// IWorkspace workspace = ResourcesPlugin.getWorkspace();
// if (workspace == null)
// return null;
// return workspace.getRoot().findMember(path);
throw new UnsupportedOperationException();
}
/**
* Helper method - returns either the linked {@link org.eclipse.core.resources.IFolder} or the {@link java.io.File} corresponding
* to the provided {@link org.eclipse.core.runtime.IPath}. If <code>checkResourceExistence</code> is <code>false</code>,
* then the IFolder or File object is always returned, otherwise <code>null</code> is returned
* if it does not exist on the file system.
*/
public static Object getExternalTarget(IPath path, boolean checkResourceExistence) {
// if (path == null)
// return null;
// ExternalFoldersManager externalFoldersManager = JavaModelManager.getExternalManager();
// Object linkedFolder = externalFoldersManager.getFolder(path);
// if (linkedFolder != null) {
// if (checkResourceExistence) {
// // check if external folder is present
// File externalFile = new File(path.toOSString());
// if (!externalFile.isDirectory()) {
// return null;
// }
// }
// return linkedFolder;
// }
// File externalFile = new File(path.toOSString());
// if (!checkResourceExistence) {
// return externalFile;
// } else if (isExternalFile(path)) {
// return externalFile;
// }
// return null;
throw new UnsupportedOperationException();
}
/**
* Helper method - returns whether an object is a file (i.e., it returns <code>true</code>
* to {@link java.io.File#isFile()}.
*/
public static boolean isFile(Object target) {
if (target instanceof File) {
IPath path = Path.fromOSString(((File)target).getPath());
return isExternalFile(path);
}
return false;
}
/**
* Returns whether the provided path is an external file, checking and updating the
* JavaModelManager's external file cache.
*/
static private boolean isExternalFile(IPath path) {
// if (JavaModelManager.getJavaModelManager().isExternalFile(path)) {
// return true;
// }
// if (JavaModelManager.ZIP_ACCESS_VERBOSE) {
// System.out.println("(" + Thread.currentThread() + ") [JavaModel.isExternalFile(...)] Checking existence of " + path.toString()); //$NON-NLS-1$ //$NON-NLS-2$
// }
// boolean isFile = path.toFile().isFile();
// if (isFile) {
// JavaModelManager.getJavaModelManager().addExternalFile(path);
// }
// return isFile;
throw new UnsupportedOperationException();
}
/**
* Helper method - returns the {@link java.io.File} item if <code>target</code> is a file (i.e., the target
* returns <code>true</code> to {@link java.io.File#isFile()}. Otherwise returns <code>null</code>.
*/
public static File getFile(Object target) {
return isFile(target) ? (File) target : null;
}
protected IStatus validateExistence(File underlyingResource) {
// Java model always exists
return JavaModelStatus.VERIFIED_OK;
}
}