Replies the current class path.

@return the current class path.
@since 0.7
978788
public static String getCurrentClasspath() {
		final StringBuilder path = new StringBuilder();
		for (final URL url : getCurrentClassLoader().getURLs()) {
			if (path.length() > 0) {
				path.append(File.pathSeparator);
			}
			final File file = FileSystem.convertURLToFile(url);
			if (file != null) {
				path.append(file.getAbsolutePath());
			}
		}
		return path.toString();
	}
390477
public String path() {
        if (path == null) {
            path = decodeComponent(uri, 0, pathEndIdx(), charset, true);
        }
        return path;
    }
1227913
public Set<String> getClasspaths() {
    	Set<String> classpaths = selectedRunner.getClasspaths();
       	return classpaths == null ? new HashSet<String>() : classpaths;
    }
842873
protected List<File> getClassPath() throws IOException {
		final Set<String> classPath = new LinkedHashSet<>();
		classPath.add(this.session.getCurrentProject().getBuild().getSourceDirectory());
		try {
			classPath.addAll(this.session.getCurrentProject().getCompileClasspathElements());
		} catch (DependencyResolutionRequiredException e) {
			throw new IOException(e.getLocalizedMessage(), e);
		}
		for (final Artifact dep : this.session.getCurrentProject().getArtifacts()) {
			classPath.add(dep.getFile().getAbsolutePath());
		}
		classPath.remove(this.session.getCurrentProject().getBuild().getOutputDirectory());
		final List<File> files = new ArrayList<>();
		for (final String filename : classPath) {
			final File file = new File(filename);
			if (file.exists()) {
				files.add(file);
			}
		}
		return files;
	}
463337
public static List getClasspathComponents()
    {
        List components = new LinkedList();

        // walk the classloader hierarchy, trying to get all the components we can
        ClassLoader cl = Thread.currentThread().getContextClassLoader();

        while ((null != cl) && (cl instanceof URLClassLoader))
        {
            URLClassLoader ucl = (URLClassLoader) cl;
            components.addAll(getUrlClassLoaderClasspathComponents(ucl));

            try
            {
                cl = ucl.getParent();
            }
            catch (SecurityException se)
            {
                cl = null;
            }
        }

        // walking the hierarchy doesn't guarantee we get everything, so
        // lets grab the system classpath for good measure.
        String classpath = System.getProperty("java.class.path");
        String separator = System.getProperty("path.separator");
        StringTokenizer st = new StringTokenizer(classpath, separator);
        while (st.hasMoreTokens())
        {
            String component = st.nextToken();
            // Calling File.getPath() cleans up the path so that it's using
            // the proper path separators for the host OS
            component = getCanonicalPath(component);
            components.add(component);
        }

        // Set removes any duplicates, return a list for the api.
        return new LinkedList(new HashSet(components));
    }
1304764
protected function getCurrentClass()
	{
		$classUri = tao_helpers_Uri::decode($this->getRequestParameter('classUri'));
		if ($this->isStandAlone() && (is_null($classUri) || empty($classUri))) {
			return $this->getRootClass();
		} else {
			return parent::getCurrentClass();
		}
	}
1221420
@Pure
	public static Iterator<URL> getClasspath() {
		Iterator<URL> iterator = getStartClasspath();

		final ClassLoader loader = ClassLoaderFinder.findClassLoader();
		try {
			final DynamicURLClassLoader dLoader = (DynamicURLClassLoader) loader;
			iterator = new FilteringIterator(Arrays.asList(dLoader.getURLs()).iterator());
		} catch (ClassCastException exception1) {
			if (ClasspathUtil.class.getClassLoader() != loader) {
				try {
					try (URLClassLoader dLoader = (URLClassLoader) loader) {
						iterator = new IteratorIterator(
								new FilteringIterator(Arrays.asList(dLoader.getURLs()).iterator()),
								iterator);
					}
				} catch (ClassCastException | IOException exception2) {
					//
				}
			}
		}

		return iterator;
	}
374358
public static String getAbsolutePath(String classPath) {
        URL configUrl = Thread.currentThread().getContextClassLoader().getResource(classPath.substring(1));
        if (configUrl == null) {
            configUrl = ResourceUtil.class.getResource(classPath);
        }
        if (configUrl == null) {
            return null;
        }
        try {
            return configUrl.toURI().getPath();
        } catch (URISyntaxException e) {
            throw new RuntimeException(e);
        }
    }
400561
private function getCurrentPath()
    {
        if (is_null($this->currentPath)) {
            $this->currentPath = $this->str($this->httpRequest()->getCurrentUrl(true)->getPath());
        }

        return $this->currentPath;
    }
172574
public static String getCurrentAbsolutPathWithoutDotAndSlash()
	{
		final File currentAbsolutPath = new File(".");
		return currentAbsolutPath.getAbsolutePath().substring(0,
			currentAbsolutPath.getAbsolutePath().length() - 2);
	}
250399
public static String getClassPath(Class<?> c) {
		String strClassFullName = c.getName();
		String strClassName = strClassFullName.substring(strClassFullName
				.lastIndexOf(".") + 1);
		String strClassPathName = getClassPathName(c);

		ClassLoader cl = c.getClassLoader();
		if (cl == null) {
			cl = ClassLoader.getSystemClassLoader();
			return null;
		}

		URL urlClass = cl.getResource(strClassPathName);
		if (urlClass == null)
			return null;

		String strUrl = urlClass.toString();
		return strUrl.substring(0, strUrl.lastIndexOf(strClassName));
	}
947977
protected List<String> getClasspathDirectories()
    {
        return Arrays.asList( project.getBuild().getOutputDirectory(),
            project.getBuild().getTestOutputDirectory() );
    }
133163
public static String getWebProjectPath(Object currentObject) {

        Class<? extends Object> class1 = currentObject.getClass();
        ClassLoader classLoader = class1.getClassLoader();
        URL resource = classLoader.getResource("/");
        String path = resource.getPath();
        int webRootIndex = StringUtils.indexOfIgnoreCase(path, "WEB-INF");
        if (path.indexOf(":/") > 0) {
            return path.substring(1, webRootIndex);
        } else {
            return path.substring(0, webRootIndex);
        }
    }
1293939
@Override
    public String getPath() {
        ServletRESTRequestImpl ret = castRequest();
        if (ret != null)
            return ret.getPath();
        return null;
    }
973124
public String path() {
    if (path == null) {
      if (!hasPath) {
        return path = "";
      }

      int pathEndPos = uri.indexOf('?');
      if (pathEndPos < 0) {
        path = uri;
      } else {
        return path = uri.substring(0, pathEndPos);
      }
    }
    return path;
  }
975109
public function createClasspath()
    {
        if ($this->isReference()) {
            throw $this->tooManyAttributes();
        }
        if ($this->classpath === null) {
            $this->classpath = new Path($this->project);
        }

        return $this->classpath->createPath();
    }
501130
@Pure
	public List<S> getPath() {
		if (this.path == null) {
			return Collections.emptyList();
		}
		return Collections.unmodifiableList(this.path);
	}