Java IPackageFragmentRoot类代码示例

import org.eclipse.jdt.core.IPackageFragmentRoot; //导入依赖的package包/类
/**
 * @param containerFullPath
 * @param packageFragmentRoot
 * @param targetPkg
 * @param selectedFilename
 * @param selectedFile
 * @param openEditor
 * @param ce
 * @throws CoreException
 */
public ResourceContext(
		IPath containerFullPath, 
		IPackageFragmentRoot packageFragmentRoot,
		IPackageFragment targetPkg,
		String selectedFilename, 
		String extendedClassname,
		IFile selectedFile,
		GENERATION_MODE mode,
		ClassExtension ce) throws CoreException {
	this.selectedFile=selectedFile;
	this.packageFragmentRoot = packageFragmentRoot;
	this.targetPkg  = targetPkg;
	this.interfaceName = selectedFile.getName().split("\\.")[0] + ".java";
	this.selectedFilename = selectedFilename;
	this.containerFullPath = containerFullPath;
	this.mode=mode;
	this.classExtension=ce;
	this.generateOnlyInterface = false;
	this.openEditor = false;
	this.erase = true;
	this.extendedClassname=extendedClassname; 
}
 

import org.eclipse.jdt.core.IPackageFragmentRoot; //导入依赖的package包/类
/**
 * @param project
 * @param qualifiedName
 * @return
 * @throws CoreException
 */
public static IFile getIFileFromQualifiedName(String projectname, String qualifiedName) throws CoreException {
	IProject project = getProject(projectname);
	IJavaProject jproject = JavaCore.create(project);
	IPackageFragment[] pkgs = jproject.getPackageFragments();
	String spath = qualifiedName.replace(".", "/");
	for (int i = 0; i < pkgs.length; i++) {
		if (pkgs[i].getKind() != IPackageFragmentRoot.K_SOURCE)
			continue;
		IPath path = pkgs[i].getPath().append(spath);
		IFile iFile = (IFile) ResourceManager.getResource(path.toString() + ".java");
		if (iFile != null && iFile.exists())
			return iFile;
	}
	return null;
}
 

import org.eclipse.jdt.core.IPackageFragmentRoot; //导入依赖的package包/类
/**
 * Lets get the path of hat have been selected in the UI - the complete path
 * a path is something like "src/main/resources"
 * 
 * @param receiver
 * @return
 */
public static String getSelectedPathInProject(Object receiver) {
	if (!ResourceManager.isPackageFragmentRoot(receiver)) {
		return null;
	}
	IPackageFragmentRoot pkg = (IPackageFragmentRoot) receiver;

	IJavaProject javaProject = pkg.getJavaProject();
	if (javaProject == null)
		return null;

	IProject project = javaProject.getProject();

	if (!GW4ENature.hasGW4ENature(project))
		return null;

	String projectName = pkg.getJavaProject().getElementName();
	int pos = projectName.length();
	String input = pkg.getPath().toString().substring(pos + 2);
	return input;
}
 

import org.eclipse.jdt.core.IPackageFragmentRoot; //导入依赖的package包/类
@Override
public boolean test(Object receiver, String property, Object[] args, Object expectedValue) {
	if ("isAuthorizedFolderForGraphDefinition".equals(property)) {
		// Only PackageFragmentRoot is allowed to enable the menu
		// Represents a set of package fragments, and maps the fragments to
		// an underlying resource which is either
		// a folder, JAR, or ZIP file. (Child of IJavaProject)
		// See JDT Plug-in Developer Guide > Programmer's Guide > JDT Core
		// for more information on Java Model
		if (!ResourceManager.isPackageFragmentRoot(receiver)) {
			return false;
		}
		// Lets get the path of hat have been selected in the UI - the
		// complete path
		// a path is something like "src/main/resources"
		String input = ResourceManager.getSelectedPathInProject(receiver);
		// Now we have it, check whether it is listed in the Preference
		boolean authorized = PreferenceManager.isAuthorizedFolderForGraphDefinition(((IPackageFragmentRoot)receiver).getJavaProject().getProject().getName(),input);
		// Sounds like we have an answer now !
		return authorized;
	}
	// Boo !
	return false;
}
 

import org.eclipse.jdt.core.IPackageFragmentRoot; //导入依赖的package包/类
public void assertHasSourceFolders(String[] folders) throws JavaModelException {
	IProject project = getRoot().getProject(this.projectName);
	IJavaProject jproject = JavaCore.create(project);
	IPackageFragmentRoot[] pkgs = jproject.getPackageFragmentRoots();

	for (int i = 0; i < folders.length; i++) {
		String folder = folders[i];
		boolean found = false;
		for (int j = 0; j < pkgs.length; j++) {
			IPackageFragmentRoot pkg = pkgs[j];
			IPath path = new Path("/").append(this.projectName).append(folder);
			if (pkg.getPath().toString().equalsIgnoreCase(path.toString())) {
				found = true;
			}
			;
		}
		assertTrue("Expected folder: " + folder, found);
	}
}
 

import org.eclipse.jdt.core.IPackageFragmentRoot; //导入依赖的package包/类
public static TestResourceGeneration get (IFile file) throws CoreException, FileNotFoundException {
	String targetFolder = GraphWalkerContextManager.getTargetFolderForTestImplementation(file);
	IPath pkgFragmentRootPath = file.getProject().getFullPath().append(new Path(targetFolder));
	IPackageFragmentRoot implementationFragmentRoot = JDTManager.getPackageFragmentRoot(file.getProject(), pkgFragmentRootPath);
	String classname = file.getName().split("\\.")[0];
	classname = classname + PreferenceManager.suffixForTestImplementation(implementationFragmentRoot.getJavaProject().getProject().getName()) + ".java";

	ClassExtension ce = PreferenceManager.getDefaultClassExtension(file);
	IPath p = ResourceManager.getPathWithinPackageFragment(file).removeLastSegments(1);
	p = implementationFragmentRoot.getPath().append(p);
	
	ResourceContext context = new ResourceContext(p, classname, file, true, false, false, ce);
	
	TestResourceGeneration trg = new TestResourceGeneration(context);
	return trg;
}
 

import org.eclipse.jdt.core.IPackageFragmentRoot; //导入依赖的package包/类
public void createClassRepo(String jarFileName, String Package) {
	ClassRepo.INSTANCE.flusRepo();
	try {
		IPackageFragmentRoot iPackageFragmentRoot = getIPackageFragment(jarFileName);
		if (iPackageFragmentRoot != null) {
			IPackageFragment fragment = iPackageFragmentRoot.getPackageFragment(Package);
			if (fragment != null) {
				for (IClassFile element : fragment.getClassFiles()) {
					ClassRepo.INSTANCE.addClass(element,"","",false);
				}
			} else {
				new CustomMessageBox(SWT.ERROR, Package + " Package not found in jar "
						+ iPackageFragmentRoot.getElementName(), "ERROR").open();
			}
		}
	} catch (JavaModelException e) {
		LOGGER.error("Error occurred while loading class from jar {}", jarFileName, e);
	}
	loadClassesFromSettingsFolder();
}
 

import org.eclipse.jdt.core.IPackageFragmentRoot; //导入依赖的package包/类
/**
 * Returns the list of source folders of the given project as a list of
 * absolute workspace paths.
 * 
 * @param project
 *            a project
 * @return a list of absolute workspace paths
 */
public static List<IFolder> getSourceFolders(IProject project) {
	List<IFolder> srcFolders = new ArrayList<IFolder>();

	try {
		IJavaProject javaProject = JavaCore.create(project);
		if (!javaProject.exists()) {
			return srcFolders;
		}

		// iterate over package roots
		for (IPackageFragmentRoot root : javaProject.getPackageFragmentRoots()) {
			IResource resource = root.getCorrespondingResource();
			if (resource != null && resource.getType() == IResource.FOLDER) {
				srcFolders.add((IFolder) resource);
			}
		}
	} catch (CoreException e) {
		Logger.debug("Get source folder exception: %s", e);
	}

	return srcFolders;
}
 

import org.eclipse.jdt.core.IPackageFragmentRoot; //导入依赖的package包/类
public static void attachSource(final IPackageFragmentRoot fragment, final IPath newSourcePath,
    IProgressMonitor monitor) {
  try {
    if (fragment == null || fragment.getKind() != IPackageFragmentRoot.K_BINARY) {
      return;
    }
    if (!Objects.equals(fragment.getSourceAttachmentPath(), newSourcePath)) {
      // would be so cool if it refreshed the UI automatically
      fragment.attachSource(newSourcePath, null, monitor);
      // close the root so that source attachment cache is flushed. Else UI
      // won't update
      fragment.close();
      // we have to manually fire a delta to notify the UI about the source
      // attachment.
      JavaModelManager manager = JavaModelManager.getJavaModelManager();
      JavaElementDelta attachedSourceDelta = new JavaElementDelta(fragment.getJavaModel());
      attachedSourceDelta.sourceAttached(fragment);
      manager.getDeltaProcessor().fire(attachedSourceDelta, ElementChangedEvent.POST_CHANGE);
    }
  } catch (CoreException e) {
    // ignore
  }
}
 

import org.eclipse.jdt.core.IPackageFragmentRoot; //导入依赖的package包/类
public static IPackageFragmentRoot[] getPluginContainerEntries(IProject project) {
  if (!ProjectUtils.isPluginProject(project)) {
    return new IPackageFragmentRoot[0];
  }
  IJavaProject javaProject = JavaCore.create(project);

  IClasspathEntry pluginContainer = null;
  try {
    pluginContainer = Stream.of(javaProject.getRawClasspath()).filter(cpe -> isPluginContainer(cpe)).findFirst()
        .orElse(null);
  } catch (JavaModelException e) {
    e.printStackTrace();
  }
  if (pluginContainer == null) {
    return new IPackageFragmentRoot[0];
  }
  IPackageFragmentRoot[] pfr = javaProject.findPackageFragmentRoots(pluginContainer);
  return pfr;
}
 

import org.eclipse.jdt.core.IPackageFragmentRoot; //导入依赖的package包/类
@Override
protected IStatus run(IProgressMonitor monitor) {
  if (monitor == null) {
    monitor = new NullProgressMonitor();
  }
  Collection<IPackageFragmentRoot> currentQueue;
  synchronized (this.queue) {
    currentQueue = new LinkedHashSet<>(this.queue);
    this.queue.clear();
  }

  for (IPackageFragmentRoot fragment : currentQueue) {
    if (monitor.isCanceled()) {
      break;
    }
    findAndAttachSources(fragment, monitor);
  }
  // schedule remaining requests that were added during this run
  synchronized (this.queue) {
    if (!queue.isEmpty() && !monitor.isCanceled()) {
      schedule();
    }
  }
  return Status.OK_STATUS;
}
 

import org.eclipse.jdt.core.IPackageFragmentRoot; //导入依赖的package包/类
private Collection<IPackageFragmentRoot> getSelectedClasspathEntries(ISelection selection) {
  if (!(selection instanceof ITreeSelection)) {
    return Collections.emptyList();
  }
  ITreeSelection structuredSelection = (ITreeSelection) selection;
  Set<IPackageFragmentRoot> fragments = new LinkedHashSet<>(structuredSelection.size());
  for (Object o : structuredSelection.toList()) {
    if (o instanceof IPackageFragmentRoot) {
      IPackageFragmentRoot pfr = (IPackageFragmentRoot) o;
      if (ClasspathUtils.isBinaryFragment(pfr) && belongsToPluginContainer(structuredSelection, pfr)) {
        fragments.add(pfr);
      }
    } else if (isPluginContainer(o)) {
      IAdaptable adaptable = (IAdaptable) o;
      IWorkbenchAdapter wa = adaptable.getAdapter(IWorkbenchAdapter.class);
      if (wa != null) {
        Object[] children = wa.getChildren(o);
        if (children instanceof IAdaptable[]) {
          IAdaptable[] adaptables = (IAdaptable[]) children;
          fragments.addAll(filterPackageFragmentRoots(adaptables));
        }
      }
    }
  }
  return fragments;
}
 

import org.eclipse.jdt.core.IPackageFragmentRoot; //导入依赖的package包/类
@Override
public void run(IAction action) {
  if (selection == null || selection.isEmpty()) {
    return;
  }
  Set<IPackageFragmentRoot> queue = new LinkedHashSet<>();
  for(Iterator<?> it = selection.iterator(); it.hasNext();) {
    Object element = it.next();
    if(element instanceof IPackageFragmentRoot) {
      IPackageFragmentRoot fragment = (IPackageFragmentRoot) element;
      try {
        if (canProcess(fragment)) {
          queue.add(fragment);
        }
      } catch (CoreException e) {
        e.printStackTrace();
      }
    }
  }
  findSources(queue);
}
 

import org.eclipse.jdt.core.IPackageFragmentRoot; //导入依赖的package包/类
@Override
public void setActiveEditor(IAction action, IEditorPart part) {
  if (part != null && part.getEditorInput() instanceof IClassFileEditorInput) {
    Set<IPackageFragmentRoot> queue = new LinkedHashSet<>();
    try {
      IClassFileEditorInput input = (IClassFileEditorInput) part.getEditorInput();
      IJavaElement element = input.getClassFile();
      while (element.getParent() != null) {
        element = element.getParent();
        if (element instanceof IPackageFragmentRoot) {
          IPackageFragmentRoot fragment = (IPackageFragmentRoot) element;
          if (canProcess(fragment)) {
            queue.add(fragment);
          }
        }
      }
    } catch (Exception ex) {
      ex.printStackTrace();
    }
    findSources(queue);
  }
}
 

import org.eclipse.jdt.core.IPackageFragmentRoot; //导入依赖的package包/类
public ICompilationUnit createCompilationUnit(
    IPackageFragmentRoot fragmentRoot, String testsrc, String path)
    throws CoreException, IOException {
  IPath typepath = new Path(path);
  String pkgname = typepath.removeLastSegments(1).toString()
      .replace('/', '.');
  IPackageFragment fragment = createPackage(fragmentRoot, pkgname);
  StringBuilder sb = new StringBuilder();
  InputStream source = openTestResource(new Path(testsrc).append(typepath));
  Reader r = new InputStreamReader(source);
  int c;
  while ((c = r.read()) != -1)
    sb.append((char) c);
  r.close();
  return createCompilationUnit(fragment, typepath.lastSegment(),
      sb.toString());
}