Java IProject.isOpen方法代碼示例

import org.eclipse.core.resources.IProject; //導入方法依賴的package包/類
/**
 * Returns with the corresponding {@link IN4JSProject N4JS project} for the given {@link IProject Eclipse project}
 * argument. Returns with {@code null} if
 * <ul>
 * <li>the {@code project} argument is {@code null} or</li>
 * <li>no {@link IN4JSProject#exists() existing} {@link IN4JSProject N4JS project} project can be found with the
 * desired project ID.</li>
 * </ul>
 *
 * @param project
 *            the searched project.
 * @return the N4JS project or {@code null} if such project does not exist.
 */
public IN4JSProject getProject(IProject project) {

	checkArgument(!(project instanceof ExternalProject), "Expected Eclipse workspace project. Got: " + project);

	if (null == project || !project.exists() || !project.isOpen()) {
		return null;
	}

	final String projectName = Strings.nullToEmpty(project.getName());
	final IN4JSProject n4Project = core.create(createPlatformResourceURI(projectName, true));
	if (null == n4Project || !n4Project.exists() || n4Project.isExternal()) {
		return null;
	}
	return n4Project;
}
 

import org.eclipse.core.resources.IProject; //導入方法依賴的package包/類
private String getWorkingSetId(final IProject project) {
	final Path projectPath = project.getLocation().toFile().toPath();
	final Path parentPath = projectPath.getParent();

	if (WS_ROOT_PATH.equals(parentPath)) {
		return OTHERS_WORKING_SET_ID;
	}

	if (parentPath.startsWith(WS_ROOT_PATH)) {
		return parentPath.toFile().getName();
	}

	if (!project.isOpen()) { // closed project appear under Other Projects WS
		return OTHERS_WORKING_SET_ID;
	}

	for (final Path repositoryPath : repositoryPaths) {
		if (repositoryPath.equals(projectPath)) {
			return projectPath.toFile().getName();
		} else if (projectPath.startsWith(repositoryPath)) {
			return parentPath.toFile().getName();
		}
	}

	return OTHERS_WORKING_SET_ID;
}
 

import org.eclipse.core.resources.IProject; //導入方法依賴的package包/類
private int evaluateSelection(final Object[] array, final List<IProject> allOpenProjects) {
	int status = 0;
	for (int i = 0; i < array.length; i++) {
		final Object curr = array[i];
		if (curr instanceof IProject) {
			final IProject project = (IProject) curr;
			if (project.isOpen()) {
				allOpenProjects.add(project);
			} else {
				status |= CLOSED_PROJECTS_SELECTED;
			}
		} else {
			status |= NON_PROJECT_SELECTED;
			if (curr instanceof WorkingSet) {
				final int res = evaluateSelection(((WorkingSet) curr).getElements(), allOpenProjects);
				status |= res;
			}
		}
	}
	return status;
}
 

import org.eclipse.core.resources.IProject; //導入方法依賴的package包/類
/**
 * Test whether the project has the passed nature
 * 
 * @param receiver
 * @param nature
 * @return
 */
public static boolean hasNature(Object receiver, String nature) {
	IProject project = JDTManager.toJavaProject(receiver);
	if (project == null || !project.isOpen())
		return false;
	IProjectDescription description;
	try {
		description = project.getDescription();
	} catch (CoreException e) {
		ResourceManager.logException(e);
		return false;
	}
	String[] natures = description.getNatureIds();
	for (int i = 0; i < natures.length; i++) {
		if (nature.equalsIgnoreCase(natures[i]))
			return true;
	}
	return false;
}
 

import org.eclipse.core.resources.IProject; //導入方法依賴的package包/類
public boolean isProjectOpened(String projectName) {
	boolean isOpen = false;
	try {
		IProject resourceProject = ConvertigoPlugin.getDefault().createProjectPluginResource(projectName);
		isOpen = resourceProject != null && resourceProject.isOpen();
	} catch (CoreException e) {
		logWarning(e, "Error when checking if '" + projectName + "' is open", false);
	}
	return isOpen;
}
 

import org.eclipse.core.resources.IProject; //導入方法依賴的package包/類
public IProject getProjectPluginResource(String projectName, IProgressMonitor monitor) throws CoreException {
	if (cacheIProject.containsKey(projectName)) return (IProject)cacheIProject.get(projectName);
	
	IProject resourceProject = createProjectPluginResource(projectName);
	if (resourceProject.exists()) {
		resourceProject.refreshLocal(IResource.DEPTH_INFINITE, monitor);			
		if (!resourceProject.isOpen())
			resourceProject.open(monitor);
	}
	cacheIProject.put(projectName, resourceProject);
	
	return resourceProject;
}
 

import org.eclipse.core.resources.IProject; //導入方法依賴的package包/類
public static boolean isPluginProject(IProject project)
{
	try
	{
		if( project.isOpen() && project.hasNature(JPFProjectNature.NATURE_ID) )
			return JPFProject.getManifest(project).exists();
	}
	catch( CoreException e )
	{
		return false;
	}
	return false;
}
 

import org.eclipse.core.resources.IProject; //導入方法依賴的package包/類
@Override
protected boolean isInterestingProject(IProject project)
{
	try
	{
		return project.isOpen() && project.hasNature(JPFJarNature.NATURE_ID);
	}
	catch( CoreException e )
	{
		JPFClasspathLog.logError(e);
		return false;
	}
}
 

import org.eclipse.core.resources.IProject; //導入方法依賴的package包/類
@Override
public Object[] getChildren(Object o)
{
	if( !(o instanceof IWorkspace) )
	{
		return new Object[0];
	}

	// Collect all the projects in the workspace except the given
	// project
	IProject[] projects = ((IWorkspace) o).getRoot().getProjects();
	List<IProject> referenced = new ArrayList<>(projects.length);
	boolean found = false;
	for( int i = 0; i < projects.length; i++ )
	{
		IProject otherProject = projects[i];
		if( !found && otherProject.equals(project) )
		{
			found = true;
			continue;
		}
		try
		{
			if( otherProject.isOpen() && otherProject.hasNature(JPFJarNature.NATURE_ID) )
			{
				referenced.add(otherProject);
			}
		}
		catch( CoreException e )
		{
			// ignore
		}
	}

	return referenced.toArray();
}
 

import org.eclipse.core.resources.IProject; //導入方法依賴的package包/類
public static boolean hasNature(IProject project)
{
	try
	{
		return project.isOpen() && project.hasNature(NATURE_ID);
	}
	catch( CoreException e )
	{
		JPFClasspathLog.logError(e);
		return false;
	}
}
 

import org.eclipse.core.resources.IProject; //導入方法依賴的package包/類
public static IJavaProject createProject(String name) throws CoreException {

		IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
		IProject project = root.getProject(name);
		if (!project.exists()) {
			project.create(new NullProgressMonitor());
		} else {
			project.refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor());
		}

		if (!project.isOpen()) {
			project.open(new NullProgressMonitor());
		}

		IFolder binFolder = project.getFolder("bin");
		if (!binFolder.exists()) {
			createFolder(binFolder, false, true, new NullProgressMonitor());
		}
		IPath outputLocation = binFolder.getFullPath();

		addNatureToProject(project, JavaCore.NATURE_ID, new NullProgressMonitor());

		IJavaProject jproject = JavaCore.create(project);
		jproject.setOutputLocation(outputLocation, new NullProgressMonitor());

		IClasspathEntry[] entries = PreferenceConstants.getDefaultJRELibrary();

		jproject.setRawClasspath(entries, new NullProgressMonitor());

		return jproject;
	}
 

import org.eclipse.core.resources.IProject; //導入方法依賴的package包/類
@Override
public IAdaptable createElement(IMemento memento) {
    String projName = memento.getString(TAG_PROJECT);
    ProjectEditorInput input = new ProjectEditorInput(projName);

    IProject project =
            (projName == null) ? null : ResourcesPlugin.getWorkspace().getRoot().getProject(projName);
    if (project == null || !project.exists() || !project.isOpen()) {
        input.setError(new PgCodekeeperUIException(Messages.project_either_closed_or_deleted + projName));
    }

    return input;
}
 

import org.eclipse.core.resources.IProject; //導入方法依賴的package包/類
private IProject createTheProjectAtSpecifiedLocation(String projectName,
		URI location) throws CoreException {
	IProject newProject;
	newProject = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName);

	if(!newProject.exists()){
		IProjectDescription desc = newProject.getWorkspace().newProjectDescription(newProject.getName());
		if (location != null && ResourcesPlugin.getWorkspace().getRoot().getLocationURI().equals(location)) {
			desc.setLocationURI(null);
		}
		else{
			desc.setLocationURI(location);
		}

		try {
			newProject.create(desc, null);
			if (!newProject.isOpen()) {
				newProject.open(null);
			}
			logger.debug("Project base structure created"); 
		} catch (CoreException exception) {
			logger.debug("Project base structure creation failed");
			throw exception;
		}
	}
	return newProject;
}
 

import org.eclipse.core.resources.IProject; //導入方法依賴的package包/類
private Boolean isOpenProjectExists(Boolean openProjectFound, IProject[] projects) {
	for (IProject project : projects) {
		if (project.isOpen()) {
			openProjectFound = true;
			break;
		}
	}
	return openProjectFound;
}
 

import org.eclipse.core.resources.IProject; //導入方法依賴的package包/類
private static List<String> loadAllComponentTypes() throws CoreException {
	List<String> files = new ArrayList<String>();
	for (IProject project : ResourcesPlugin.getWorkspace().getRoot().getProjects()) {
		if (project.isAccessible() && project.isOpen()) {
			files.addAll(loadModels(project));
		}
	}
	return files;
}