How to use

segments

method

in

org.eclipse.core.runtime.IPath

private boolean isJREContainer(IPath path) {
  if (path == null)
    return false;
  String[] segments= path.segments();
  for (String seg : segments) {
    if (seg.equals(JavaRuntime.JRE_CONTAINER)) {
      return true;
    }
  }
  return false;
}

private boolean isHiddenResource(IPath p) {
  String[] segments = p.segments();
  for (int i = 0; i < segments.length; i++) {
    if (segments[i].startsWith(".")) //$NON-NLS-1$
      return true;
  }
  return false;
}

private static boolean greaterThan(IFile f1, IFile f2) {
  String[] ss1= f1.getFullPath().segments();
  String[] ss2= f2.getFullPath().segments();
  int l1= ss1.length;
  int l2= ss2.length;
  int n= Math.max(l1, l2);
  
  for (int i= 0; i < n; i++) {
    String s1= i < l1 ? ss1[i] : ""; //$NON-NLS-1$
    String s2= i < l2 ? ss2[i] : ""; //$NON-NLS-1$
    int rc= s1.compareToIgnoreCase(s2);
    if (rc != 0)
      return rc < 0;
  }
  return false;
}

private static boolean greaterThan(IFile f1, IFile f2) {
  String[] ss1= f1.getFullPath().segments();
  String[] ss2= f2.getFullPath().segments();
  int l1= ss1.length;
  int l2= ss2.length;
  int n= Math.max(l1, l2);
  for (int i= 0; i < n; i++) {
    String s1= i < l1 ? ss1[i] : ""; //$NON-NLS-1$
    String s2= i < l2 ? ss2[i] : ""; //$NON-NLS-1$
    int rc= s1.compareToIgnoreCase(s2);
    if (rc != 0)
      return rc < 0;
  }
  return false;
}

private IContainer getContainer(ILaunchConfiguration configuration) throws CoreException {
  String projectPath = configuration.getAttribute(DotnetRunDelegate.PROJECT_FOLDER, ""); //$NON-NLS-1$
  if (projectPath == null) {
    return null;
  }
  IPath location = new Path(projectPath);
  if (location.toFile().isDirectory()) {
    return ResourcesPlugin.getWorkspace().getRoot().getContainerForLocation(location);
  } else if (location.segmentCount() == 1) {
    return ResourcesPlugin.getWorkspace().getRoot().getProject(location.segments()[0]);
  } else {
    return ResourcesPlugin.getWorkspace().getRoot().getFolder(location);
  }
}

  public static String getQualifiedName(IPath path) {
    StringBuffer buffer = new StringBuffer();
    String[] segments = path.segments();
    if (segments.length > 0) {
      buffer.append(path.lastSegment());
      if (segments.length > 1) {
        buffer.append(" - "); //$NON-NLS-1$
        if (path.getDevice() != null) {
          buffer.append(path.getDevice());
        }
        for (int i = 0; i < segments.length - 1; i++) {
          buffer.append(File.separatorChar);
          buffer.append(segments[i]);
        }
      }
      return buffer.toString();
    }
    return IInternalDebugCoreConstants.EMPTY_STRING;
  }
}

public Object findElement(IPath path) {
  String[] segments= path.segments();
  
  Object elem= fProvider.getRoot();
  for (int i= 0; i < segments.length && elem != null; i++) {
    List list= fProvider.getChildren(elem);
    String name= segments[i];
    elem= null;
    for (int k= 0; k < list.size(); k++) {
      Object curr= list.get(k);
      if (fProvider.isFolder(curr) && name.equals(fProvider.getLabel(curr))) {
        elem= curr;
        break;
      }
    }
  }
  return elem;
}

public Object findElement(IPath path) {
  String[] segments= path.segments();
  Object elem= fProvider.getRoot();
  for (int i= 0; i < segments.length && elem != null; i++) {
    List<?> list= fProvider.getChildren(elem);
    String name= segments[i];
    elem= null;
    for (int k= 0; k < list.size(); k++) {
      Object curr= list.get(k);
      if (fProvider.isFolder(curr) && name.equals(fProvider.getLabel(curr))) {
        elem= curr;
        break;
      }
    }
  }
  return elem;
}

@VisibleForTesting
protected String packageForPath(final IPath path, final IPath classpath) {
 if ((classpath == null)) {
  ClasspathUtil.logger.error("Could not find corresponding classpath entry for path=\'{}\', using default package instead.", path);
  return null;
 }
 final int start = path.matchingFirstSegments(classpath);
 int _segmentCount = classpath.segmentCount();
 boolean _notEquals = (start != _segmentCount);
 if (_notEquals) {
  throw new RuntimeException("illegal path for classpath");
 }
 final String result = IterableExtensions.join(((Iterable<?>)Conversions.doWrapArray(path.removeFirstSegments(start).segments())), ".");
 ClasspathUtil.logger.debug("Inferred package for originPath=\'{}\' is \'{}\'.", path, result);
 return result;
}

/**
 * Calculates the absolute path from a base to a relative target location.
 *
 * @param base the base path
 * @param relativePath the relative path from the base to the target
 * @return the absolute path to the target location
 * @throws NullPointerException if an argument is {@code null}
 * @throws IllegalArgumentException if a) the base path does not denote an absolute path b) the
 *             target path does not denote a relative path, or c) the relative path is invalid
 *             (i.e. points above the root folder)
 */
public static IPath getAbsolutePath(IPath base, IPath relativePath) {
  Preconditions.checkNotNull(base);
  Preconditions.checkNotNull(relativePath);
  Preconditions.checkArgument(base.isAbsolute());
  Preconditions.checkArgument(!relativePath.isAbsolute());
  IPath result = base;
  for (String segment : relativePath.segments()) {
    IPath newResult = result.append(segment);
    // Appending a '..' segment to the root path does not fail but returns a new path object
    // see org.eclipse.core.runtime.Path.removeLastSegment(int)
    if (segment.equals("..") && newResult.segmentCount() >= result.segmentCount()) {
      throw new IllegalArgumentException(String.format("Relative path can't point beyond the root (base=%s, relativePath=%s).", base, relativePath));
    }
    result = newResult;
  }
  return result;
}

public Object findElement(IPath path) {
  String[] segments= path.segments();
  Object elem= fProvider.getRoot();
  for (int i= 0; i < segments.length && elem != null; i++) {
    List<?> list= fProvider.getChildren(elem);
    String name= segments[i];
    elem= null;
    for (int k= 0; k < list.size(); k++) {
      Object curr= list.get(k);
      if (fProvider.isFolder(curr) && name.equals(fProvider.getLabel(curr))) {
        elem= curr;
        break;
      }
    }
  }
  return elem;
}

/**
 * Fuzzy search for Java project in the workspace that matches
 * the given path.
 *
 * @param path the path to match
 * @return the matching Java project or <code>null</code>
 * @since 3.2
 */
private IJavaProject findJavaProject(IPath path) {
  if (path == null)
    return null;
  String[] pathSegments= path.segments();
  IJavaModel model= JavaCore.create(JavaPlugin.getWorkspace().getRoot());
  IJavaProject[] projects;
  try {
    projects= model.getJavaProjects();
  } catch (JavaModelException e) {
    return null; // ignore - use default JRE
  }
  for (int i= 0; i < projects.length; i++) {
    IPath projectPath= projects[i].getProject().getFullPath();
    String projectSegment= projectPath.segments()[0];
    for (int j= 0; j < pathSegments.length; j++)
      if (projectSegment.equals(pathSegments[j]))
        return projects[i];
  }
  return null;
}

/**
 * Fuzzy search for Java project in the workspace that matches
 * the given path.
 *
 * @param path the path to match
 * @return the matching Java project or <code>null</code>
 * @since 3.2
 */
private IJavaProject findJavaProject(IPath path) {
  if (path == null)
    return null;
  String[] pathSegments= path.segments();
  IJavaModel model= JavaCore.create(JavaPlugin.getWorkspace().getRoot());
  IJavaProject[] projects;
  try {
    projects= model.getJavaProjects();
  } catch (JavaModelException e) {
    return null; // ignore - use default JRE
  }
  for (int i= 0; i < projects.length; i++) {
    IPath projectPath= projects[i].getProject().getFullPath();
    String projectSegment= projectPath.segments()[0];
    for (int j= 0; j < pathSegments.length; j++)
      if (projectSegment.equals(pathSegments[j]))
        return projects[i];
  }
  return null;
}

private void createParents(IProject fragmentProject, IPath parent) throws CoreException {
  try {
  String[] segments = parent.segments();
  String path = ""; //$NON-NLS-1$
  File dest = fragmentProject.getFullPath().toFile();
  String destCanonicalPath = dest.getCanonicalPath();
  for (String segment : segments) {
    path += SLASH + segment;
    IFolder folder = fragmentProject.getFolder(path);
    File file = folder.getFullPath().toFile();
    String canonicalFilePath = file.getCanonicalPath();
    if (!canonicalFilePath.startsWith(destCanonicalPath + File.separator)) {
      throw new CoreException(new Status(IStatus.ERROR, PDEPlugin.getPluginId(),
          MessageFormat.format("Entry is outside of the target dir: : {0}", file.getName()), null)); //$NON-NLS-1$
    }
    if (!folder.exists()) {
      folder.create(true, true, getProgressMonitor());
    }
  }
  }
  catch (IOException e) {
    throw new CoreException(new Status(IStatus.ERROR, PDEPlugin.getPluginId(),
        MessageFormat.format("IOException while processing: {0}", fragmentProject.getName()), //$NON-NLS-1$
        null));
  }
}

/**
 * Fuzzy search for Java project in the workspace that matches
 * the given path.
 * 
 * @param path the path to match
 * @return the matching Java project or <code>null</code>
 * @since 3.2
 */
private IJavaProject findJavaProject(IPath path) {
  if (path == null)
    return null;
  String[] pathSegments= path.segments();
  IJavaModel model= JavaCore.create(JavaPlugin.getWorkspace().getRoot());
  IJavaProject[] projects;
  try {
    projects= model.getJavaProjects();
  } catch (JavaModelException e) {
    return null; // ignore - use default JRE
  }
  for (int i= 0; i < projects.length; i++) {
    IPath projectPath= projects[i].getProject().getFullPath();
    String projectSegment= projectPath.segments()[0];
    for (int j= 0; j < pathSegments.length; j++)
      if (projectSegment.equals(pathSegments[j]))
        return projects[i];
  }
  return null;
}

public String getLabel(Object o) {
  if (o instanceof PackageFragmentRootSourceContainer) {
    PackageFragmentRootSourceContainer container = (PackageFragmentRootSourceContainer) o;
    IPackageFragmentRoot fragmentRoot = container.getPackageFragmentRoot();
    IPath path = fragmentRoot.getPath();
    if (path.segmentCount() > 0) {
      StringBuffer buffer = new StringBuffer();
      buffer.append(path.lastSegment());
      if (path.segmentCount() > 1) {
        buffer.append(" - "); //$NON-NLS-1$
        if (path.getDevice() != null) {
          buffer.append(path.getDevice());
        }
        String[] segments = path.segments();
        for (int i = 0; i < segments.length - 1; i++) {
          buffer.append(File.separatorChar);
          buffer.append(segments[i]);
        }
      }
      return buffer.toString();
    }
  }
  return ""; //$NON-NLS-1$
}
/* (non-Javadoc)

/**
 * @param loader
 * @param entry
 */
private void addVariableEntry(TaglibClassLoader loader, IClasspathEntry entry) {
  if (DEBUG)
    System.out.println(" -> adding variable entry: [" + entry + "]"); //$NON-NLS-1$ //$NON-NLS-2$
  // variable should either be a project or a library entry
  // BUG 169431
  String variableName = entry.getPath().toString();
  IPath variablePath = JavaCore.getResolvedVariablePath(entry.getPath());
  variablePath = JavaCore.getClasspathVariable(variableName);
  // RATLC01076854
  // variable paths may not exist
  // in that case null will be returned
  if (variablePath != null) {
    if (variablePath.segments().length == 1) {
      IProject varProj = ResourcesPlugin.getWorkspace().getRoot().getProject(variablePath.toString());
      if (varProj != null && varProj.exists()) {
        addClasspathEntriesForProject(varProj, loader);
        return;
      }
    }
    addLibraryEntry(loader, variablePath);
  }
}

IFolder f = (IFolder) elements.next();
IPath relativePath = f.getFullPath().removeFirstSegments(segments);
String[] pkgName = relativePath.segments();
IPackageFragment pkg = root.getPackageFragment(pkgName);
if (!Util.isExcluded(pkg))

 String _plus = ("found standard path for " + _string);
 ClasspathUtil.logger.debug(_plus);
 return IterableExtensions.join(((Iterable<?>)Conversions.doWrapArray(relativePath.removeFirstSegments(3).segments())), ".");
} else {
 String _string_1 = originPath.toString();

String[] segments = path.segments();
for (String nextSegment : segments) {