Java Code Examples for org.eclipse.jdt.core.JavaCore#newContainerEntry()

private boolean updateClasspath(IPath newPath, IProgressMonitor monitor) throws JavaModelException {
	boolean updated= false;
	
	IClasspathEntry[] classpath= fProject.getRawClasspath();
	IPath jreContainerPath= new Path(JavaRuntime.JRE_CONTAINER);
	for (int i= 0; i < classpath.length; i++) {
		IClasspathEntry curr= classpath[i];
		if (curr.getEntryKind() == IClasspathEntry.CPE_CONTAINER && curr.getPath().matchingFirstSegments(jreContainerPath) > 0) {
			if (! newPath.equals(curr.getPath())) {
				updated= true;
				classpath[i]= JavaCore.newContainerEntry(newPath, curr.getAccessRules(), curr.getExtraAttributes(), curr.isExported());
			}
		}
	}
	if (updated) {
		fProject.setRawClasspath(classpath, monitor);
	}
	return updated;
}
 

/**
 * Sometimes the project configuration is corrupt and a Java runtime is not on the classpath
 * @param monitor
 * @param javaProject
 * @throws JavaModelException
 */
private void fixMissingJavaRuntime(IProgressMonitor monitor, IJavaProject javaProject) throws JavaModelException {
	
	if (!javaProject.getProject().getName().equals("config")) {
		IClasspathEntry[] classPathEntries = javaProject.getRawClasspath();
		boolean found = false;
		for (IClasspathEntry classpathEntry : classPathEntries) {
			// fix missing runtime
			if (classpathEntry.getEntryKind() == IClasspathEntry.CPE_CONTAINER) {
				if (classpathEntry.getPath().toString().startsWith("org.eclipse.jdt.launching.JRE_CONTAINER")) {
					found = true;
					break;
				}
			}
		}
		
		if (!found) {
			IClasspathEntry entry = JavaCore.newContainerEntry(new Path("org.eclipse.jdt.launching.JRE_CONTAINER"),
					false);
			Set<IClasspathEntry> entries = new HashSet<IClasspathEntry>(Arrays.asList(classPathEntries));
			entries.add(entry);
			FixProjectsUtils.setClasspath(entries.toArray(new IClasspathEntry[entries.size()]), javaProject,
					monitor);
		}
	}
}
 

private IClasspathEntry[] getClassPathEntries( IProject project )
{
	IClasspathEntry[] internalClassPathEntries = getInternalClassPathEntries( project );
	IClasspathEntry[] entries = new IClasspathEntry[internalClassPathEntries.length + 1];
	System.arraycopy( internalClassPathEntries,
			0,
			entries,
			0,
			internalClassPathEntries.length );
	entries[entries.length - 1] = JavaCore.newContainerEntry( new Path( "org.eclipse.jdt.launching.JRE_CONTAINER" ) ); //$NON-NLS-1$
	return entries;
}
 

public IClasspathEntry getSelection() {
	if (fEditResult != null) {
		if (fOldClasspathEntry != null && fOldClasspathEntry.getPath().equals(fEditResult.getPath())) {
			return JavaCore.newContainerEntry(fEditResult.getPath(), fOldClasspathEntry.getAccessRules(), fOldClasspathEntry.getExtraAttributes(), fOldClasspathEntry.isExported());
		} else {
			return JavaCore.newContainerEntry(fEditResult.getPath(), false);
		}
	}
	return null;
}
 

private IClasspathEntry[] getClassPathEntries( IProject project )
{
	IClasspathEntry[] internalClassPathEntries = getInternalClassPathEntries( project );
	IClasspathEntry[] entries = new IClasspathEntry[internalClassPathEntries.length + 1];
	System.arraycopy( internalClassPathEntries,
			0,
			entries,
			0,
			internalClassPathEntries.length );
	entries[entries.length - 1] = JavaCore.newContainerEntry( new Path( "org.eclipse.jdt.launching.JRE_CONTAINER" ) ); //$NON-NLS-1$
	return entries;
}
 

@SuppressWarnings("restriction")
public RuntimeLibraryContainerWizardPage() {
	super("RuntimeLibraryContainer"); //$NON-NLS-1$
	setTitle(Messages.RuntimeLibraryContainerWizardPage_classpathLibraryTitle);
	setImageDescriptor(org.eclipse.jdt.internal.ui.JavaPluginImages.DESC_WIZBAN_ADD_LIBRARY);
	setDescription(Messages.RuntimeLibraryContainerWizardPage_classpathLibraryDescription);
	this.containerEntry = JavaCore
			.newContainerEntry(RuntimeLibraryContainerInitializer.LIBRARY_PATH);
}
 

/**
 * Creates a Java project with the given name and a "src" folder and the default JRE library on
 * its classpath.
 */
public static IJavaProject createProject(String projectName) throws CoreException {
  IClasspathEntry[] classpath = new IClasspathEntry[] {
      JavaCore.newSourceEntry(Path.fromOSString("/" + projectName + "/" + SOURCE_FOLDER)),
      JavaCore.newContainerEntry(Path.fromOSString("org.eclipse.jdt.launching.JRE_CONTAINER"))};
  return ProjectTestUtil.createProject(projectName, classpath);
}
 

public final IClasspathEntry getSelection() {
  SdkSelection<T> sdkSelection = sdkSelectionBlock.getSdkSelection();
  IPath containerPath = SdkClasspathContainer.computeContainerPath(
      containerID, sdkSelection.getSelectedSdk(), sdkSelection.isDefault()
          ? Type.DEFAULT : Type.NAMED);
  return JavaCore.newContainerEntry(containerPath);
}
 

/** Construct a wizard page for defining the SARL library container.
 */
public JanusContainerWizardPage() {
	super("JanusClassPathContainer"); //$NON-NLS-1$
	setTitle(Messages.JanusClasspathContainer_0);
	setImageDescriptor(JavaPluginImages.DESC_WIZBAN_ADD_LIBRARY);
	setDescription(Messages.JanusContainerWizardPage_0);
	this.containerEntry = JavaCore.newContainerEntry(
			JanusClasspathContainerInitializer.CONTAINER_ID);
}
 

@SuppressWarnings("restriction")
public XtendContainerWizardPage() {
	super("XtendClassPathContainer"); //$NON-NLS-1$
	setTitle(Messages.XtendClasspathContainer_Description);
	setImageDescriptor(org.eclipse.jdt.internal.ui.JavaPluginImages.DESC_WIZBAN_ADD_LIBRARY);
	setDescription(Messages.XtendContainerWizardPage_Desc);
	this.containerEntry = JavaCore.newContainerEntry(XtendContainerInitializer.XTEND_LIBRARY_PATH);
}
 

public IClasspathEntry[] getNewContainers() {
	List<CPUserLibraryElement> selected= fLibrarySelector.getCheckedElements();
	IClasspathEntry[] res= new IClasspathEntry[selected.size()];
	for (int i= 0; i < res.length; i++) {
		CPUserLibraryElement curr= selected.get(i);
		res[i]= JavaCore.newContainerEntry(curr.getPath(), false);
	}
	return res;
}
 

/**
 * @since 2.9
 */
public static IClasspathEntry getJREContainerEntry(String bree) {
	IClasspathEntry jreContainerEntry = getDefaultJREContainerEntry();
	IExecutionEnvironment ee = JavaRuntime.getExecutionEnvironmentsManager().getEnvironment(bree);
	if (ee != null) {
		return JavaCore.newContainerEntry(newJREContainerPath(ee));
	}
	return jreContainerEntry;
}
 

private static IClasspathEntry makeClasspathEntry(Library library) throws CoreException {
  IClasspathAttribute[] classpathAttributes = new IClasspathAttribute[1];
  if (library.isExport()) {
    boolean isWebApp = true;
    classpathAttributes[0] = UpdateClasspathAttributeUtil.createDependencyAttribute(isWebApp);
  } else {
    classpathAttributes[0] = UpdateClasspathAttributeUtil.createNonDependencyAttribute();
  }
  // in practice, this method will only be called for the master library
  IPath containerPath = new Path(LibraryClasspathContainer.CONTAINER_PATH_PREFIX)
      .append(library.getId());
  return JavaCore.newContainerEntry(containerPath, new IAccessRule[0], classpathAttributes,
      false);
}
 

@Test
public void testAddClasspathEntries() throws JavaModelException {
  IClasspathEntry entry1 = JavaCore.newSourceEntry(new Path("/my/src"));
  IClasspathEntry entry2 = JavaCore.newContainerEntry(new Path("/my/container"));
  List<IClasspathEntry> toAdd = Lists.newArrayList(entry1, entry2);

  assertFalse(classpathExists(entry1));
  assertFalse(classpathExists(entry2));
  ClasspathUtil.addClasspathEntries(project, toAdd, monitor);
  assertTrue(classpathExists(entry1));
  assertTrue(classpathExists(entry2));
}
 

private static void addJunit4ToClasspath(IProject newProject, IProgressMonitor monitor)
    throws CoreException {
  IClasspathAttribute nonDependencyAttribute =
      UpdateClasspathAttributeUtil.createNonDependencyAttribute();
  IClasspathEntry junit4Container = JavaCore.newContainerEntry(
      JUnitCore.JUNIT4_CONTAINER_PATH,
      new IAccessRule[0],
      new IClasspathAttribute[] {nonDependencyAttribute},
      false);
  ClasspathUtil.addClasspathEntry(newProject, junit4Container, monitor);
}
 

@Override
protected IClasspathEntry createContainerClasspathEntry() {
	return JavaCore.newContainerEntry(JUNIT5_LIBRARY_PATH);
}
 

@Override
protected IClasspathEntry createContainerClasspathEntry() {
	return JavaCore.newContainerEntry(XtendContainerInitializer.XTEND_LIBRARY_PATH);
}
 

/**
 * @since 2.6
 */
public static IClasspathEntry getDefaultJREContainerEntry() {
	IPath jreContainerPath = getDefaultJREContainerPath();
	return JavaCore.newContainerEntry(jreContainerPath);
}
 

private IClasspathEntry newClasspathEntry( )
{

	IClasspathAttribute[] extraAttributes = new IClasspathAttribute[0];
	switch ( fEntryKind )
	{
		case IClasspathEntry.CPE_SOURCE :
			return JavaCore.newSourceEntry( fPath,
					null,
					null,
					null,
					extraAttributes );
		case IClasspathEntry.CPE_LIBRARY :
		{
			return JavaCore.newLibraryEntry( fPath,
					null,
					null,
					null,
					extraAttributes,
					isExported( ) );
		}
		case IClasspathEntry.CPE_PROJECT :
		{
			return JavaCore.newProjectEntry( fPath,
					null,
					false,
					extraAttributes,
					isExported( ) );
		}
		case IClasspathEntry.CPE_CONTAINER :
		{
			return JavaCore.newContainerEntry( fPath,
					null,
					extraAttributes,
					isExported( ) );
		}
		case IClasspathEntry.CPE_VARIABLE :
		{
			return JavaCore.newVariableEntry( fPath,
					null,
					null,
					null,
					extraAttributes,
					isExported( ) );
		}
		default :
			return null;
	}
}
 

public IClasspathEntry getSelection() {
	return JavaCore.newContainerEntry(new Path(fEntryField.getText()));
}