This implementation returns a description that includes the class path location.
498496
public String getDescription() {
        StringBuilder builder = new StringBuilder("class path resource [");

        if (clazz != null) {
            builder.append(GrailsResourceUtils.classPackageAsResourcePath(clazz));
            builder.append('/');
        }

        builder.append(path);
        builder.append(']');
        return builder.toString();
    }
269878
private static String getPath(final Object classpath) {
        final Object container = ReflectionUtils.getFieldVal(classpath, "container", false);
        if (container == null) {
            return "";
        }

        final Object delegate = ReflectionUtils.getFieldVal(container, "delegate", false);
        if (delegate == null) {
            return "";
        }

        final String path = (String) ReflectionUtils.getFieldVal(delegate, "path", false);
        if (path != null && path.length() > 0) {
            return path;
        }

        final Object base = ReflectionUtils.getFieldVal(delegate, "base", false);
        if (base == null) {
            // giving up.
            return "";
        }

        final Object archiveFile = ReflectionUtils.getFieldVal(base, "archiveFile", false);
        if (archiveFile != null) {
            final File file = (File) archiveFile;
            return file.getAbsolutePath();
        }
        return "";
    }
1209730
private static String getClassNameandPath (String className, Path path) {
        if (path == null) {
            return getClassNameandPath(className, "/");
        } else {
            return getClassNameandPath(className, path.value());
        }
    }
756422
def path(self, *paths, **kwargs):
        
        return self.__class__(self.__root__, *paths, **kwargs)
955158
private String getClassNameFromPath(String path) {
        String className = path.replace(".class", "");

        // for *nix
        if (className.startsWith("/")) {
            className = className.substring(1, className.length());
        }
        className = className.replace("/", ".");

        // for windows
        if (className.startsWith("\\")) {
            className = className.substring(1, className.length());
        }
        className = className.replace("\\", ".");

        return className;
    }
677958
def getClassPath():
    
    global _CLASSPATHS
    global _SEP
    out=[]
    for path in _CLASSPATHS:
        if path=='':
            continue
        if path.endswith('*'):
            paths=_glob.glob(path+".jar")
            if len(path)==0:
                continue 
            out.extend(paths)
        else:
            out.append(path)
    return _SEP.join(out)
1021381
public static String getClassPath()
  {
    if (_classPath != null)
      return _classPath;

    String cp = System.getProperty("java.class.path");

    String boot = System.getProperty("sun.boot.class.path");
    if (boot != null && ! boot.equals(""))
      cp = cp + File.pathSeparatorChar + boot;

    Pattern pattern = Pattern.compile("" + File.pathSeparatorChar);

    String []path = pattern.split(cp);

    CharBuffer cb = new CharBuffer();

    for (int i = 0; i < path.length; i++) {
      PathImpl subpath = VfsOld.lookup(path[i]);

      if (subpath.canRead() || subpath.isDirectory()) {
        if (cb.length() > 0)
          cb.append(File.pathSeparatorChar);

        cb.append(path[i]);
      }
    }

    _classPath = cb.toString();

    return _classPath;
  }
1263462
@PublicAPI(usage = ACCESS)
    public JavaClasses importClasspath() {
        return importClasspath(new ImportOptions().with(ImportOption.Predefined.DO_NOT_INCLUDE_ARCHIVES));
    }
320783
@Override
    public String getDescription() {
        StringBuilder builder = new StringBuilder("class path resource [");

        if (clazz != null) {
            builder.append(ResourceUtils.classPackageAsResourcePath(clazz));
            builder.append('/');
        }

        builder.append(path);
        builder.append(']');
        return builder.toString();
    }
384100
public static String pathToClassName(String path) {
        path = path.replace('/', '.');
        if (path.endsWith(CLASS_EXTENSION)) {
            path = path.substring(0, path.length() - CLASS_EXTENSION.length());
        }
        return path;
    }
1101369
public String getRelativePath() {
    StringBuilder sb = new StringBuilder();
    String pkg = typeRef.getPackageName().replace('.', '/');
    if (pkg.length() > 0) {
      sb.append(pkg);
      sb.append('/');
    }
    appendDeclaringTypes(typeRef, '$', sb);
    sb.append(typeRef.getSimpleName());
    sb.append(".class");
    return sb.toString();
  }
579947
private static void getClassPathesFromLoader(ClassLoader cl, Map pathes) {
	if (cl instanceof URLClassLoader) _getClassPathesFromLoader((URLClassLoader) cl, pathes);
    }
312149
private static Map<String, Integer> findClasses(Path path)
    {
        List<String> paths = findPaths(path, true);
        Map<String, Integer> results = new HashMap<>();
        for (String subPath : paths)
        {
            if (subPath.endsWith(".java") || subPath.endsWith(".class"))
            {
                String qualifiedName = PathUtil.classFilePathToClassname(subPath);
                addClassToMap(results, qualifiedName);
            }
        }
        return results;
    }
1371259
public ClassFinder addClasspath() {
    try {
      String path = System.getProperty("java.class.path");
      StringTokenizer tok = new StringTokenizer(path, File.pathSeparator);
      while (tok.hasMoreTokens())
        add(new File(tok.nextToken()));
    } catch (Exception ex) {
      log.error("Unable to get class path", ex);
    }
    return this;
  }
520221
def _get_class_path(self, klass_or_instance):
        
        if inspect.isclass(klass_or_instance):
            klass = '{}.{}'.format(klass_or_instance.__module__, klass_or_instance.__name__)
        elif not isinstance(klass_or_instance, str):
            klass = klass_or_instance.__class__
            klass = '{}.{}'.format(klass.__module__, klass.__name__)
        else:
            klass = klass_or_instance

        return klass
63089
function locateDescriptor(descriptor) {
  let basePath

  // Infer from path/url
  if (isString(descriptor)) {
    basePath = descriptor.split('/').slice(0, -1).join('/') || '.'

  // Current dir by default
  } else {
    basePath = '.'
  }

  return basePath
}
656550
private String buildClassPath()
  {
    String classPath = null;//_classPath;

    if (classPath != null) {
      return classPath;
    }

    if (classPath == null && _loader instanceof DynamicClassLoader) {
      classPath = ((DynamicClassLoader) _loader).getClassPath();
    }
    else { // if (true || _loader instanceof URLClassLoader) {
      StringBuilder sb = new StringBuilder();
      sb.append(CauchoUtil.getClassPath());

      if (_loader != null)
        buildClassPath(sb, _loader);

      classPath = sb.toString();
    }
    //else if (classPath == null)
      //classPath = CauchoSystem.getClassPath();

    String srcDirName = getSourceDirName();
    String classDirName = getClassDirName();

    char sep = CauchoUtil.getPathSeparatorChar();

    if (_extraClassPath != null)
      classPath = classPath + sep + _extraClassPath;

    // Adding the srcDir lets javac and jikes find source files
    if (! srcDirName.equals(classDirName))
      classPath = srcDirName + sep + classPath;
    classPath = classDirName + sep + classPath;

    return classPath;
  }