Examples of IClasspathEntry

org.aspectj.org.eclipse.jdt.core.IClasspathEntry
An entry on a Java project classpath identifying one or more package fragment roots. A classpath entry has a content kind (either source, {@link IPackageFragmentRoot#K_SOURCE}, or binary, {@link IPackageFragmentRoot#K_BINARY}), which is inherited by each package fragment root and package fragment associated with the entry.
A classpath entry can refer to any of the following:
- Source code in the current project. In this case, the entry identifies a root folder in the current project containing package fragments and source files with one of the {@link JavaCore#getJavaLikeExtensions() Java-like extensions}. The root folder itself represents a default package, subfolders represent package fragments, and files with a Java-like extension (e.g. .java files) represent compilation units. All compilation units will be compiled when the project is built. The classpath entry must specify the absolute path to the root folder. Entries of this kind are associated with the {@link #CPE_SOURCE} constant.Source classpath entries can carry inclusion and exclusion patterns for selecting which source files appear as compilation units and get compiled when the project is built.
- A binary library in the current project, in another project, or in the external file system. In this case the entry identifies a JAR (or root folder) containing package fragments and .class files. The classpath entry must specify the absolute path to the JAR (or root folder), and in case it refers to an external JAR, then there is no associated resource in the workbench. Entries of this kind are associated with the {@link #CPE_LIBRARY} constant.
- A required project. In this case the entry identifies another project in the workspace. The required project is used as a binary library when compiling (that is, the builder looks in the output location of the required project for required .class files when building). When performing other "development" operations - such as code assist, code resolve, type hierarchy creation, etc. - the source code of the project is referred to. Thus, development is performed against a required project's source code, and compilation is performed against a required project's last built state. The classpath entry must specify the absolute path to the project. Entries of this kind are associated with the {@link #CPE_PROJECT}constant. Note: referencing a required project with a classpath entry refers to the source code or associated .class files located in its output location. It will also automatically include any other libraries or projects that the required project's classpath refers to, iff the corresponding classpath entries are tagged as being exported ( {@link IClasspathEntry#isExported}). Unless exporting some classpath entries, classpaths are not chained by default - each project must specify its own classpath in its entirety.
- A path beginning in a classpath variable defined globally to the workspace. Entries of this kind are associated with the {@link #CPE_VARIABLE} constant. Classpath variables are created using {@link JavaCore#setClasspathVariable(String,IPath,org.eclipse.core.runtime.IProgressMonitor)}, and gets resolved, to either a project or library entry, using {@link JavaCore#getResolvedClasspathEntry(IClasspathEntry)}. It is also possible to register an automatic initializer ( {@link ClasspathVariableInitializer}), which will be invoked through the extension point "org.aspectj.org.eclipse.jdt.core.classpathVariableInitializer". After resolution, a classpath variable entry may either correspond to a project or a library entry.
- A named classpath container identified by its container path. A classpath container provides a way to indirectly reference a set of classpath entries through a classpath entry of kind {@link #CPE_CONTAINER}. Typically, a classpath container can be used to describe a complex library composed of multiple JARs, projects or classpath variables, considering also that containers can be mapped differently on each project. Several projects can reference the same generic container path, but have each of them actually bound to a different container object. The container path is a formed by a first ID segment followed with extra segments, which can be used as additional hints for resolving this container reference. If no container was ever recorded for this container path onto this project (using {@link JavaCore#setClasspathContainer}, then a {@link ClasspathContainerInitializer} will be activated if any was registered for this container ID onto the extension point "org.aspectj.org.eclipse.jdt.core.classpathContainerInitializer". A classpath container entry can be resolved explicitly using {@link JavaCore#getClasspathContainer}and the resulting container entries can contain any non-container entry. In particular, it may contain variable entries, which in turn needs to be resolved before being directly used.
  Also note that the container resolution APIs include an IJavaProject argument, so as to allow the same container path to be interpreted in different ways for different projects.
The result of {@link IJavaProject#getResolvedClasspath} will have all entries of type{@link #CPE_VARIABLE} and {@link #CPE_CONTAINER} resolved to a set of {@link #CPE_SOURCE}, {@link #CPE_LIBRARY} or {@link #CPE_PROJECT}classpath entries.
Any classpath entry other than a source folder (kind {@link #CPE_SOURCE}) can be marked as being exported. Exported entries are automatically contributed to dependent projects, along with the project's default output folder, which is implicitly exported, and any auxiliary output folders specified on source classpath entries. The project's output folder(s) are always listed first, followed by the any exported entries.
This interface is not intended to be implemented by clients. Classpath entries can be created via methods on {@link JavaCore}.
@see JavaCore#newLibraryEntry(org.eclipse.core.runtime.IPath,org.eclipse.core.runtime.IPath,org.eclipse.core.runtime.IPath) @see JavaCore#newProjectEntry(org.eclipse.core.runtime.IPath) @see JavaCore#newSourceEntry(org.eclipse.core.runtime.IPath) @see JavaCore#newVariableEntry(org.eclipse.core.runtime.IPath,org.eclipse.core.runtime.IPath,org.eclipse.core.runtime.IPath) @see JavaCore#newContainerEntry(org.eclipse.core.runtime.IPath) @see ClasspathVariableInitializer @see ClasspathContainerInitializer
org.eclipse.jdt.core.IClasspathEntry
An entry on a Java project classpath identifying one or more package fragment roots. A classpath entry has a content kind (either source, {@link IPackageFragmentRoot#K_SOURCE}, or binary, {@link IPackageFragmentRoot#K_BINARY}), which is inherited by each package fragment root and package fragment associated with the entry.
A classpath entry can refer to any of the following:
- Source code in the current project. In this case, the entry identifies a root folder in the current project containing package fragments and source files with one of the {@link JavaCore#getJavaLikeExtensions() Java-like extensions}. The root folder itself represents a default package, subfolders represent package fragments, and files with a Java-like extension (e.g. .java files) represent compilation units. All compilation units will be compiled when the project is built. The classpath entry must specify the absolute path to the root folder. Entries of this kind are associated with the {@link #CPE_SOURCE} constant.Source classpath entries can carry inclusion and exclusion patterns for selecting which source files appear as compilation units and get compiled when the project is built.
- A binary library in the current project, in another project, or in the external file system. In this case the entry identifies a JAR (or root folder) containing package fragments and .class files. The classpath entry must specify the absolute path to the JAR (or root folder), and in case it refers to an external JAR, then there is no associated resource in the workbench. Entries of this kind are associated with the {@link #CPE_LIBRARY} constant.
- A required project. In this case the entry identifies another project in the workspace. The required project is used as a binary library when compiling (that is, the builder looks in the output location of the required project for required .class files when building). When performing other "development" operations - such as code assist, code resolve, type hierarchy creation, etc. - the source code of the project is referred to. Thus, development is performed against a required project's source code, and compilation is performed against a required project's last built state. The classpath entry must specify the absolute path to the project. Entries of this kind are associated with the {@link #CPE_PROJECT}constant. Note: referencing a required project with a classpath entry refers to the source code or associated .class files located in its output location. It will also automatically include any other libraries or projects that the required project's classpath refers to, iff the corresponding classpath entries are tagged as being exported ( {@link IClasspathEntry#isExported}). Unless exporting some classpath entries, classpaths are not chained by default - each project must specify its own classpath in its entirety.
- A path beginning in a classpath variable defined globally to the workspace. Entries of this kind are associated with the {@link #CPE_VARIABLE} constant.Classpath variables are created using {@link JavaCore#setClasspathVariable(String,IPath,org.eclipse.core.runtime.IProgressMonitor)}, and gets resolved, to either a project or library entry, using {@link JavaCore#getResolvedClasspathEntry(IClasspathEntry)}. It is also possible to register an automatic initializer ( {@link ClasspathVariableInitializer}), which will be invoked through the extension point "org.eclipse.jdt.core.classpathVariableInitializer". After resolution, a classpath variable entry may either correspond to a project or a library entry.
- A named classpath container identified by its container path. A classpath container provides a way to indirectly reference a set of classpath entries through a classpath entry of kind {@link #CPE_CONTAINER}. Typically, a classpath container can be used to describe a complex library composed of multiple JARs, projects or classpath variables, considering also that containers can be mapped differently on each project. Several projects can reference the same generic container path, but have each of them actually bound to a different container object. The container path is a formed by a first ID segment followed with extra segments, which can be used as additional hints for resolving this container reference. If no container was ever recorded for this container path onto this project (using {@link JavaCore#setClasspathContainer}, then a {@link ClasspathContainerInitializer} will be activated if any was registered for thiscontainer ID onto the extension point "org.eclipse.jdt.core.classpathContainerInitializer". A classpath container entry can be resolved explicitly using {@link JavaCore#getClasspathContainer}and the resulting container entries can contain any non-container entry. In particular, it may contain variable entries, which in turn needs to be resolved before being directly used.
  Also note that the container resolution APIs include an IJavaProject argument, so as to allow the same container path to be interpreted in different ways for different projects.
The result of {@link IJavaProject#getResolvedClasspath} will have all entries of type{@link #CPE_VARIABLE} and {@link #CPE_CONTAINER} resolved to a set of{@link #CPE_SOURCE}, {@link #CPE_LIBRARY} or {@link #CPE_PROJECT}classpath entries.
Any classpath entry other than a source folder (kind {@link #CPE_SOURCE}) can be marked as being exported. Exported entries are automatically contributed to dependent projects, along with the project's default output folder, which is implicitly exported, and any auxiliary output folders specified on source classpath entries. The project's output folder(s) are always listed first, followed by the any exported entries.
Classpath entries can be created via methods on {@link JavaCore}.
@see JavaCore#newLibraryEntry(org.eclipse.core.runtime.IPath,org.eclipse.core.runtime.IPath,org.eclipse.core.runtime.IPath) @see JavaCore#newProjectEntry(org.eclipse.core.runtime.IPath) @see JavaCore#newSourceEntry(org.eclipse.core.runtime.IPath) @see JavaCore#newVariableEntry(org.eclipse.core.runtime.IPath,org.eclipse.core.runtime.IPath,org.eclipse.core.runtime.IPath) @see JavaCore#newContainerEntry(org.eclipse.core.runtime.IPath) @see ClasspathVariableInitializer @see ClasspathContainerInitializer @noimplement This interface is not intended to be implemented by clients.

Examples of org.aspectj.org.eclipse.jdt.core.IClasspathEntry

            
        // check to see if any of the modified variables is present on the classpath
        IClasspathEntry[] classpath = project.getRawClasspath();
        for (int j = 0, cpLength = classpath.length; j < cpLength; j++){
          
          IClasspathEntry entry = classpath[j];
          for (int k = 0; k < varLength; k++){
  
            String variableName = this.variableNames[k];            
            if (entry.getEntryKind() ==  IClasspathEntry.CPE_VARIABLE){
  
              if (variableName.equals(entry.getPath().segment(0))){
                affectedProjectClasspaths.put(project, project.getResolvedClasspath());
                continue nextProject;
              }
              IPath sourcePath, sourceRootPath;
              if (((sourcePath = entry.getSourceAttachmentPath()) != null  && variableName.equals(sourcePath.segment(0)))
                || ((sourceRootPath = entry.getSourceAttachmentRootPath()) != null  && variableName.equals(sourceRootPath.segment(0)))) {
  
                affectedProjectClasspaths.put(project, project.getResolvedClasspath());
                continue nextProject;
              }
            }

View Full Code Here

Examples of org.aspectj.org.eclipse.jdt.core.IClasspathEntry

        if (newContainer == null) newContainer = JavaModelManager.CONTAINER_INITIALIZATION_IN_PROGRESS; // 30920 - prevent infinite loop
        boolean found = false;
        if (JavaProject.hasJavaNature(affectedProject.getProject())){
          IClasspathEntry[] rawClasspath = affectedProject.getRawClasspath();
          for (int j = 0, cpLength = rawClasspath.length; j <cpLength; j++) {
            IClasspathEntry entry = rawClasspath[j];
            if (entry.getEntryKind() == IClasspathEntry.CPE_CONTAINER && entry.getPath().equals(this.containerPath)){
              found = true;
              break;
            }
          }
        }

View Full Code Here

Examples of org.aspectj.org.eclipse.jdt.core.IClasspathEntry

    for (int i = 0; i < length - 1; i++) {
      if (!otherClasspathWithOutput[i].equals(newClasspath[i]))
        return false;
    }
    // compare binary outputs
    IClasspathEntry output = otherClasspathWithOutput[length - 1];
    if (output.getContentKind() != ClasspathEntry.K_OUTPUT
        || !output.getPath().equals(newOutputLocation))
      return false;
    return true;
  }

View Full Code Here

Examples of org.aspectj.org.eclipse.jdt.core.IClasspathEntry

      return false;
    }
    
    IPath fullPath = resource.getFullPath();
    IPath innerMostOutput = output.isPrefixOf(fullPath) ? output : null;
    IClasspathEntry innerMostEntry = null;
    for (int j = 0, cpLength = classpath.length; j < cpLength; j++) {
      IClasspathEntry entry = classpath[j];
    
      IPath entryPath = entry.getPath();
      if ((innerMostEntry == null || innerMostEntry.getPath().isPrefixOf(entryPath))
          && entryPath.isPrefixOf(fullPath)) {
        innerMostEntry = entry;
      }
      IPath entryOutput = classpath[j].getOutputLocation();

View Full Code Here

Examples of org.aspectj.org.eclipse.jdt.core.IClasspathEntry

   * Reads and decode an XML classpath string
   */
  public IClasspathEntry[] decodeClasspath(String xmlClasspath, Map unknownElements) throws IOException, AssertionFailedException {
  
    ArrayList paths = new ArrayList();
    IClasspathEntry defaultOutput = null;
    StringReader reader = new StringReader(xmlClasspath);
    Element cpElement;
    try {
      DocumentBuilder parser = DocumentBuilderFactory.newInstance().newDocumentBuilder();
      cpElement = parser.parse(new InputSource(reader)).getDocumentElement();
    } catch (SAXException e) {
      throw new IOException(Messages.file_badFormat); 
    } catch (ParserConfigurationException e) {
      throw new IOException(Messages.file_badFormat); 
    } finally {
      reader.close();
    }
  
    if (!cpElement.getNodeName().equalsIgnoreCase("classpath")) { //$NON-NLS-1$
      throw new IOException(Messages.file_badFormat); 
    }
    NodeList list = cpElement.getElementsByTagName("classpathentry"); //$NON-NLS-1$
    int length = list.getLength();
  
    for (int i = 0; i < length; ++i) {
      Node node = list.item(i);
      if (node.getNodeType() == Node.ELEMENT_NODE) {
        IClasspathEntry entry = ClasspathEntry.elementDecode((Element)node, this, unknownElements);
        if (entry != null){
          if (entry.getContentKind() == ClasspathEntry.K_OUTPUT) { 
            defaultOutput = entry; // separate output
          } else {
            paths.add(entry);
      }
    }

View Full Code Here

Examples of org.aspectj.org.eclipse.jdt.core.IClasspathEntry

    IPath elementPath = element.getPath();
    
    // first look at unresolved entries
    int length = rawClasspath.length;
    for (int i = 0; i < length; i++) {
      IClasspathEntry entry = rawClasspath[i];
      switch (entry.getEntryKind()) {
        case IClasspathEntry.CPE_LIBRARY:
        case IClasspathEntry.CPE_PROJECT:
        case IClasspathEntry.CPE_SOURCE:
          if (isOnClasspathEntry(elementPath, isFolderPath, isPackageFragmentRoot, entry))
            return true;
          break;
      }
    }
    
    // no need to go further for compilation units and elements inside a compilation unit
    // it can only be in a source folder, thus on the raw classpath
    if (isSource)
      return false;
    
    // then look at resolved entries
    for (int i = 0; i < length; i++) {
      IClasspathEntry rawEntry = rawClasspath[i];
      switch (rawEntry.getEntryKind()) {
        case IClasspathEntry.CPE_CONTAINER:
          IClasspathContainer container;
          try {
            container = JavaCore.getClasspathContainer(rawEntry.getPath(), this);
          } catch (JavaModelException e) {
            break;
          }
          if (container == null)
            break;
          IClasspathEntry[] containerEntries = container.getClasspathEntries();
          if (containerEntries == null) 
            break;
          // container was bound
          for (int j = 0, containerLength = containerEntries.length; j < containerLength; j++){
            IClasspathEntry resolvedEntry = containerEntries[j];
            if (resolvedEntry == null) {
              if (JavaModelManager.CP_RESOLVE_VERBOSE) {
                JavaModelManager.getJavaModelManager().verbose_missbehaving_container(this, rawEntry.getPath(), containerEntries);
              }
              return false;
            }
            if (isOnClasspathEntry(elementPath, isFolderPath, isPackageFragmentRoot, resolvedEntry))
              return true;
          }          
          break;
        case IClasspathEntry.CPE_VARIABLE:
          IClasspathEntry resolvedEntry = JavaCore.getResolvedClasspathEntry(rawEntry);
          if (resolvedEntry == null) 
            break;
          if (isOnClasspathEntry(elementPath, isFolderPath, isPackageFragmentRoot, resolvedEntry))
            return true;
          break;

View Full Code Here

Examples of org.aspectj.org.eclipse.jdt.core.IClasspathEntry

      classpath = this.getResolvedClasspath();
    } catch(JavaModelException e){
      return false; // not a Java project
    }
    for (int i = 0; i < classpath.length; i++) {
      IClasspathEntry entry = classpath[i];
      IPath entryPath = entry.getPath();
      if (entryPath.equals(exactPath)) { // package fragment roots must match exactly entry pathes (no exclusion there)
        return true;
      }
      if (entryPath.isPrefixOf(path) 
          && !Util.isExcluded(path, ((ClasspathEntry)entry).fullInclusionPatternChars(), ((ClasspathEntry)entry).fullExclusionPatternChars(), isFolderPath)) {

View Full Code Here

Examples of org.aspectj.org.eclipse.jdt.core.IClasspathEntry

      
    ArrayList prerequisites = new ArrayList();
    // need resolution
    entries = resolveClasspath(entries);
    for (int i = 0, length = entries.length; i < length; i++) {
      IClasspathEntry entry = entries[i];
      if (entry.getEntryKind() == IClasspathEntry.CPE_PROJECT) {
        prerequisites.add(entry.getPath().lastSegment());
      }
    }
    int size = prerequisites.size();
    if (size == 0) {
      return NO_PREREQUISITES;

View Full Code Here

Examples of org.aspectj.org.eclipse.jdt.core.IClasspathEntry

      return defaultOutputLocation();
    
    // extract the output location
    IPath outputLocation = null;
    if (classpath.length > 0) {
      IClasspathEntry entry = classpath[classpath.length - 1];
      if (entry.getContentKind() == ClasspathEntry.K_OUTPUT) {
        outputLocation = entry.getPath();
      }
    }
    return outputLocation;
  }

View Full Code Here

Examples of org.aspectj.org.eclipse.jdt.core.IClasspathEntry

    if (classpath == JavaProject.INVALID_CLASSPATH)
      return defaultClasspath();
    
    // discard the output location
    if (classpath.length > 0) {
      IClasspathEntry entry = classpath[classpath.length - 1];
      if (entry.getContentKind() == ClasspathEntry.K_OUTPUT) {
        IClasspathEntry[] copy = new IClasspathEntry[classpath.length - 1];
        System.arraycopy(classpath, 0, copy, 0, copy.length);
        classpath = copy;
      }
    }

View Full Code Here

0 1 2 3 4 5

TOP

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.