Results for path file:java

Found 198438 results in 16050 files, showing top 50 files (show more).

github.com/bazelbuild/rules_closure:java/io/bazel/rules/closure/Webpath.java: [ master, ]
72: private final String path;
55: private static final Webpath EMPTY_PATH = new Webpath("");
56: private static final Webpath ROOT_PATH = new Webpath(ROOT);
49: public final class Webpath implements CharSequence, Comparable<Webpath> {
76: private Webpath(String path) {
170: public Webpath subpath(int beginIndex, int endIndex) {
393: public Webpath toAbsolutePath(Webpath currentWorkingDirectory) {
399: public Webpath toAbsolutePath() {
34: * Web server path.
36: * <p>This class is a de facto implementation of the {@link java.nio.file.Path} API. That interface
62: / Returns new path** of {@code first}. */
63: public static Webpath get(String path) {
64: if (path.isEmpty()) {
65: return EMPTY_PATH;
66: } else if (isRootInternal(path)) {
67: return ROOT_PATH;
69: return new Webpath(path);
77: this.path = checkNotNull(path);
82: return isRootInternal(path);
85: private static boolean isRootInternal(String path) {
86: return path.length() == 1 && path.charAt(0) == SEPARATOR;
89: / Returns {@code true} if path** starts with {@code separator}. */
91: return isAbsoluteInternal(path);
94: private static boolean isAbsoluteInternal(String path) {
95: return !path.isEmpty() && path.charAt(0) == SEPARATOR;
98: / Returns {@code true} if path** ends with {@code separator}. */
100: return hasTrailingSeparatorInternal(path);
103: private static boolean hasTrailingSeparatorInternal(CharSequence path) {
104: return path.length() != 0 && path.charAt(path.length() - 1) == SEPARATOR;
107: / Returns {@code true} if path** ends with a trailing slash, or would after normalization. */
109: int length = path.length();
110: return path.isEmpty()
111: \|\| path.charAt(length - 1) == SEPARATOR
112: \|\| (path.endsWith(".") && (length == 1 \|\| path.charAt(length - 2) == SEPARATOR))
113: \|\| (path.endsWith("..") && (length == 2 \|\| path.charAt(length - 3) == SEPARATOR));
117: * Returns last component in {@code path}.
119: * @see java.nio.file.Path#getFileName()
123: if (path.isEmpty()) {
124: return EMPTY_PATH;
130: return parts.size() == 1 && path.equals(last) ? this : new Webpath(last);
137: * @see java.nio.file.Path#getParent()
141: if (path.isEmpty() \|\| isRoot()) {
146: ? path.lastIndexOf(SEPARATOR, path.length() - 2)
147: : path.lastIndexOf(SEPARATOR);
149: return isAbsolute() ? ROOT_PATH : null;
151: return new Webpath(path.substring(0, index + 1));
156: * Returns root component if an absolute path, otherwise {@code null}.
158: * @see java.nio.file.Path#getRoot()
162: return isAbsolute() ? ROOT_PATH : null;
166: * Returns specified range of sub-components in path joined together.
168: * @see java.nio.file.Path#subpath(int, int)
171: if (path.isEmpty() && beginIndex == 0 && endIndex == 1) {
185: * Returns number of components in {@code path}.
187: * @see java.nio.file.Path#getNameCount()
190: if (path.isEmpty()) {
200: * Returns component in {@code path} at {@code index}.
202: * @see java.nio.file.Path#getName(int)
205: if (path.isEmpty()) {
217: * Returns path without extra separators or {@code .} and {@code ..}, preserving trailing slash.
219: * @see java.nio.file.Path#normalize()
228: index = path.indexOf(SEPARATOR, mark);
229: String part = path.substring(mark, index == -1 ? path.length() : index + 1);
280: * Returns {@code other} appended to {@code path}.
282: * @see java.nio.file.Path#resolve(java.nio.file.Path)
285: if (other.path.isEmpty()) {
290: return new Webpath(path + other.path);
292: return new Webpath(path + SEPARATOR + other.path);
297: * Returns {@code other} resolved against parent of {@code path}.
299: * @see java.nio.file.Path#resolveSibling(java.nio.file.Path)
307: / Returns absolute path** of {@code reference} relative to {@code file}. */
313: * Returns {@code other} made relative to {@code path}.
315: * @see java.nio.file.Path#relativize(java.nio.file.Path)
318: checkArgument(isAbsolute() == other.isAbsolute(), "'other' is different type of Path");
319: if (path.isEmpty()) {
331: StringBuilder result = new StringBuilder(path.length() + other.path.length());
348: * Returns {@code true} if {@code path} starts with {@code other}.
350: * @see java.nio.file.Path#startsWith(java.nio.file.Path)
355: if (other.path.length() > me.path.length()) {
359: } else if (!me.path.isEmpty() && other.path.isEmpty()) {
375: * Returns {@code true} if {@code path} ends with {@code other}.
377: * @see java.nio.file.Path#endsWith(java.nio.file.Path)
382: if (other.path.length() > me.path.length()) {
384: } else if (!me.path.isEmpty() && other.path.isEmpty()) {
387: return me.isAbsolute() && me.path.equals(other.path);
392: / Converts relative path to an absolute path*. /
398: /** Returns {@code toAbsolutePath(ROOT_PATH)}. */
400: return toAbsolutePath(ROOT_PATH);
403: / Removes beginning separator from path, if an absolute path*. /
405: return isAbsolute() ? new Webpath(path.substring(1)) : this;
408: / Adds trailing separator to path*, if it isn't present. /
410: return hasTrailingSeparator() ? this : new Webpath(path + SEPARATOR);
413: / Removes trailing separator from path*, unless it's root. /
416: return new Webpath(path.substring(0, path.length() - 1));
422: / Splits path** into components, excluding separators and empty strings. */
427: / Splits path** into components in reverse, excluding separators and empty strings. */
435: * @see java.nio.file.Path#compareTo(java.nio.file.Path)
481: String path2 = ((Webpath) other).path;
485: if (i == path.length()) {
486: return i2 == path2.length();
488: if (i2 == path2.length()) {
491: char c = path.charAt(i++);
493: while (i < path.length() && path.charAt(i) == SEPARATOR) {
497: char c2 = path2.charAt(i2++);
502: while (i2 < path2.length() && path2.charAt(i2) == SEPARATOR) {
515: for (int i = 0; i < path.length(); i++) {
516: char c = path.charAt(i);
527: / Returns path** as a string. */
530: return path;
535: return path.length();
540: return path.charAt(index);
545: return path.subSequence(start, end);
548: / Returns {@code true} if this path** is an empty string. */
550: return path.isEmpty();
553: / Returns list of path** components, excluding slashes. */
559: path.isEmpty() \|\| isRoot()
561: : SPLITTER.splitToList(path));
37: * is not formally implemented because it would not be desirable to have web paths accidentally
38: * intermingle with file system paths.
40: * <p>This implementation is almost identical to {@code sun.nio.fs.UnixPath}. The main difference is
122: public Webpath getFileName() {
140: public Webpath getParent() {
161: public Webpath getRoot() {
181: return new Webpath(JOINER.join(subList));
204: public Webpath getName(int index) {
210: return new Webpath(getParts().get(index));
221: public Webpath normalize() {
276: return new Webpath(result.toString());
284: public Webpath resolve(Webpath other) {
301: public Webpath resolveSibling(Webpath other) {
303: Webpath parent = getParent();
308: public Webpath lookup(Webpath reference) {
317: public Webpath relativize(Webpath other) {
344: return new Webpath(result.toString());
352: public boolean startsWith(Webpath other) {
353: Webpath me = removeTrailingSeparator();
379: public boolean endsWith(Webpath other) {
380: Webpath me = removeTrailingSeparator();
404: public Webpath removeBeginningSeparator() {
409: public Webpath addTrailingSeparator() {
414: public Webpath removeTrailingSeparator() {
433: * Compares two paths lexicographically for ordering.
438: public int compareTo(Webpath other) {
478: if (!(other instanceof Webpath) \|\| hashCode() != other.hashCode()) {

android.googlesource.com/platform/packages/modules/common:java/com/android/modules/targetprep/proto/classpath_classes.proto: [ master, ]
36: string path = 1;
40: string path = 1;
21: enum Classpath {
23: BOOTCLASSPATH = 1;
24: SYSTEMSERVERCLASSPATH = 2;
32: repeated string paths = 4;
41: Classpath classpath = 2;
44: message ClasspathEntry {
54: message ClasspathClassesDump {
55: repeated ClasspathEntry entries = 1;

github.com/bazelbuild/eclipse:java/com/google/devtools/bazel/e4b/classpath/BazelClasspathContainer.java: [ master, ]
48: private final IPath path;
15: package com.google.devtools.bazel.e4b.classpath;
60: private boolean isSourcePath(String path) throws JavaModelException, BackingStoreException {
137: private static IPath getJarIPath(File execRoot, String file) {
156: public IPath getPath() {
45: public class BazelClasspathContainer implements IClasspathContainer {
52: public BazelClasspathContainer(IPath path, IJavaProject project)
93: private boolean isSourceInPaths(List<String> sources)
104: public IClasspathEntry[] getClasspathEntries() {
125: private IClasspathEntry[] jarsToClasspathEntries(Set<Jars> jars) {
20: import java.nio.file.Path;
55: this.path = path;
61: Path pp = new File(instance.getWorkspaceRoot().toString() + File.separator + path).toPath();
81: private boolean matchPatterns(Path path, IPath[] patterns) {
85: if (matcher.matches(path)) {
141: File path = new File(execRoot, file);
142: return org.eclipse.core.runtime.Path.fromOSString(path.toString());
157: return path;
21: import java.nio.file.PathMatcher;
30: import org.eclipse.core.runtime.IPath;
63: for (IClasspathEntry entry : project.getRawClasspath()) {
65: IResource res = root.findMember(entry.getPath());
69: IPath[] inclusionPatterns = entry.getInclusionPatterns();
83: for (IPath p : patterns) {
84: PathMatcher matcher = FileSystems.getDefault().getPathMatcher("glob:" + p.toOSString());
96: if (isSourcePath(s)) {
117: Activator.error("Unable to compute classpath containers entries.", e);
130: entries[i] = JavaCore.newLibraryEntry(getJarIPath(execRoot, j.getJar()),
131: getJarIPath(execRoot, j.getSrcJar()), null);
147: return "Bazel Classpath Container";
31: import org.eclipse.jdt.core.IClasspathContainer;
32: import org.eclipse.jdt.core.IClasspathEntry;
64: if (entry.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
111: if (!isSourceInPaths(s.getSources())) {
115: return jarsToClasspathEntries(jars);
118: return new IClasspathEntry[] {};
121: return new IClasspathEntry[] {};
126: IClasspathEntry[] entries = new IClasspathEntry[jars.size()];

github.com/google/climb-tracker:climblib/src/main/java/fr/steren/climblib/Path.java: [ master, ]
15: public class Path {

github.com/googleapis/java-storage-nio:google-cloud-nio/src/main/java/com/google/cloud/storage/contrib/nio/UnixPath.java: [ master, ]
65: private final String path;
57: public static final UnixPath EMPTY_PATH = new UnixPath(false, "");
58: public static final UnixPath ROOT_PATH = new UnixPath(false, ROOT);
50: final class UnixPath implements CharSequence {
69: private UnixPath(boolean permitEmptyComponents, String path) {
75: public static UnixPath getPath(boolean permitEmptyComponents, String path) {
91: public static UnixPath getPath(boolean permitEmptyComponents, String first, String... more) {
208: public UnixPath subpath(int beginIndex, int endIndex) {
417: public UnixPath toAbsolutePath(UnixPath currentWorkingDirectory) {
423: public UnixPath toAbsolutePath() {
36: * Unix file system path.
38: * <p>This class is helpful for writing {@link java.nio.file.Path Path} implementations.
42: * preserve trailing backslashes, in order to ensure the path will continue to be recognized as a
70: this.path = checkNotNull(path);
74: / Returns new path** of {@code first}. */
76: if (path.isEmpty()) {
77: return EMPTY_PATH;
78: } else if (isRootInternal(path)) {
79: return ROOT_PATH;
81: return new UnixPath(permitEmptyComponents, path);
86: * Returns new path of {@code first} with {@code more} components resolved against it.
118: return isRootInternal(path);
121: private static boolean isRootInternal(String path) {
122: return path.length() == 1 && path.charAt(0) == SEPARATOR;
125: / Returns {@code true} if path** starts with {@code separator}. */
127: return isAbsoluteInternal(path);
130: private static boolean isAbsoluteInternal(String path) {
131: return !path.isEmpty() && path.charAt(0) == SEPARATOR;
134: / Returns {@code true} if path** ends with {@code separator}. */
136: return hasTrailingSeparatorInternal(path);
139: private static boolean hasTrailingSeparatorInternal(CharSequence path) {
140: return path.length() != 0 && path.charAt(path.length() - 1) == SEPARATOR;
143: / Returns {@code true} if path** ends with a trailing slash, or would after normalization. */
145: int length = path.length();
146: return path.isEmpty()
147: \|\| path.charAt(length - 1) == SEPARATOR
148: \|\| path.endsWith(".") && (length == 1 \|\| path.charAt(length - 2) == SEPARATOR)
149: \|\| path.endsWith("..") && (length == 2 \|\| path.charAt(length - 3) == SEPARATOR);
153: * Returns last component in {@code path}.
155: * @see java.nio.file.Path#getFileName()
159: if (path.isEmpty()) {
160: return EMPTY_PATH;
166: return parts.size() == 1 && path.equals(last)
175: * @see java.nio.file.Path#getParent()
179: if (path.isEmpty() \|\| isRoot()) {
184: ? path.lastIndexOf(SEPARATOR, path.length() - 2)
185: : path.lastIndexOf(SEPARATOR);
187: return isAbsolute() ? ROOT_PATH : null;
189: return new UnixPath(permitEmptyComponents, path.substring(0, index + 1));
194: * Returns root component if an absolute path, otherwise {@code null}.
196: * @see java.nio.file.Path#getRoot()
200: return isAbsolute() ? ROOT_PATH : null;
204: * Returns specified range of sub-components in path joined together.
206: * @see java.nio.file.Path#subpath(int, int)
209: if (path.isEmpty() && beginIndex == 0 && endIndex == 1) {
223: * Returns number of components in {@code path}.
225: * @see java.nio.file.Path#getNameCount()
228: if (path.isEmpty()) {
238: * Returns component in {@code path} at {@code index}.
240: * @see java.nio.file.Path#getName(int)
243: if (path.isEmpty()) {
254: * Returns path without extra separators or {@code .} and {@code ..}, preserving trailing slash.
256: * @see java.nio.file.Path#normalize()
265: index = path.indexOf(SEPARATOR, mark);
266: String part = path.substring(mark, index == -1 ? path.length() : index + 1);
300: * Returns {@code other} appended to {@code path}.
302: * @see java.nio.file.Path#resolve(java.nio.file.Path)
305: if (other.path.isEmpty()) {
310: return new UnixPath(permitEmptyComponents, path + other.path);
312: return new UnixPath(permitEmptyComponents, path + SEPARATOR + other.path);
317: * Returns {@code other} resolved against parent of {@code path}.
319: * @see java.nio.file.Path#resolveSibling(java.nio.file.Path)
328: * Returns {@code other} made relative to {@code path}.
330: * @see java.nio.file.Path#relativize(java.nio.file.Path)
333: checkArgument(isAbsolute() == other.isAbsolute(), "'other' is different type of Path");
334: if (path.isEmpty()) {
346: StringBuilder result = new StringBuilder(path.length() + other.path.length());
363: * Returns {@code true} if {@code path} starts with {@code other}.
365: * @see java.nio.file.Path#startsWith(java.nio.file.Path)
370: if (other.path.length() > me.path.length()) {
374: } else if (!me.path.isEmpty() && other.path.isEmpty()) {
390: * Returns {@code true} if {@code path} ends with {@code other}.
392: * @see java.nio.file.Path#endsWith(java.nio.file.Path)
397: if (other.path.length() > me.path.length()) {
399: } else if (!me.path.isEmpty() && other.path.isEmpty()) {
402: return me.isAbsolute() && me.path.equals(other.path);
410: * @see java.nio.file.Path#compareTo(java.nio.file.Path)
416: / Converts relative path to an absolute path*. /
422: /** Returns {@code toAbsolutePath(ROOT_PATH)}. */
424: return toAbsolutePath(ROOT_PATH);
427: / Removes beginning separator from path, if an absolute path*. /
429: return isAbsolute() ? new UnixPath(permitEmptyComponents, path.substring(1)) : this;
432: / Adds trailing separator to path*, if it isn't present. /
434: return hasTrailingSeparator() ? this : new UnixPath(permitEmptyComponents, path + SEPARATOR);
437: / Removes trailing separator from path*, unless it's root. /
440: return new UnixPath(permitEmptyComponents, path.substring(0, path.length() - 1));
446: / Splits path** into components, excluding separators and empty strings. */
451: / Splits path** into components in reverse, excluding separators and empty strings. */
458: return this == other \|\| other instanceof UnixPath && path.equals(((UnixPath) other).path);
463: return path.hashCode();
466: / Returns path** as a string. */
469: return path;
474: return path.length();
479: return path.charAt(index);
484: return path.subSequence(start, end);
487: / Returns {@code true} if this path** is an empty string. */
489: return path.isEmpty();
492: / Returns list of path** components, excluding slashes. */
498: path.isEmpty() \|\| isRoot() ? Collections.<String>emptyList() : createParts());
504: path.charAt(0) == SEPARATOR ? path.substring(1) : path);
506: return SPLITTER.splitToList(path);
40: * <p>This implementation behaves almost identically to {@code sun.nio.fs.UnixPath}. The only
41: * difference is that some methods (like {@link #relativize(UnixPath)} go to greater lengths to
88: * @see #resolve(UnixPath)
89: * @see java.nio.file.FileSystem#getPath(String, String...)
93: return getPath(permitEmptyComponents, first);
102: return new UnixPath(permitEmptyComponents, part);
113: return new UnixPath(permitEmptyComponents, builder.toString());
158: public UnixPath getFileName() {
168: : new UnixPath(permitEmptyComponents, last);
178: public UnixPath getParent() {
199: public UnixPath getRoot() {
219: return new UnixPath(permitEmptyComponents, JOINER.join(subList));
242: public UnixPath getName(int index) {
247: return new UnixPath(permitEmptyComponents, getParts().get(index));
258: public UnixPath normalize() {
296: return new UnixPath(permitEmptyComponents, result.toString());
304: public UnixPath resolve(UnixPath other) {
321: public UnixPath resolveSibling(UnixPath other) {
323: UnixPath parent = getParent();
332: public UnixPath relativize(UnixPath other) {
359: return new UnixPath(permitEmptyComponents, result.toString());
367: public boolean startsWith(UnixPath other) {
368: UnixPath me = removeTrailingSeparator();
394: public boolean endsWith(UnixPath other) {
395: UnixPath me = removeTrailingSeparator();
408: * Compares two paths lexicographically for ordering.
412: public int compareTo(UnixPath other) {
428: public UnixPath removeBeginningSeparator() {
433: public UnixPath addTrailingSeparator() {
438: public UnixPath removeTrailingSeparator() {

github.com/apache/sling-org-apache-sling-jcr-contentloader:src/main/java/org/apache/sling/jcr/contentloader/PathEntry.java: [ master, ]
148: private final String path;
84: public static final String PATH_DIRECTIVE = "path";
46: public class PathEntry extends ImportOptions {
242: public PathEntry(ManifestHeader.Entry entry, long bundleLastModified) {
246: public PathEntry(ManifestHeader.Entry entry, long bundleLastModified, @Nullable String bundleSymbolicName) {
365: public String getPath() {
189: public static @Nullable Iterator<PathEntry> getContentPaths(@NotNull final Manifest manifest, long bundleLastModified) {
201: public static @Nullable Iterator<PathEntry> getContentPaths(final Bundle bundle) {
212: public static @Nullable Iterator<PathEntry> getContentPaths(final Map<String, String> headers, long bundleLastModified) {
216: private static @Nullable Iterator<PathEntry> getContentPaths(final Map<String, String> headers, long bundleLastModified, @Nullable String bundleSymblicName) {
44: * A path entry from the manifest for initial content.
81: * The path directive specifying the target node where initial content will
134: PATH_DIRECTIVE,
147: / The path** for the initial content. */
172: * Target path where initial content will be loaded. If it´s null then
247: this.path = entry.getValue();
308: // path directive
309: final String pathValue = entry.getDirectiveValue(PATH_DIRECTIVE);
366: return this.path;
48: private static final Logger log = LoggerFactory.getLogger(PathEntry.class);
183: * Parses the "Sling-Initial-Content" header from the given manifest and returns the resolved PathEntries
187: * @return an iterator over the parsed {@code PathEntry} items or {@code null} in case no "Sling-Initial-Content" header was found in the manifest
196: * Parses the "Sling-Initial-Content" header from the given bundle and returns the resolved PathEntries
199: * @return an iterator over the parsed {@code PathEntry} items or {@code null} in case no "Sling-Initial-Content" header was found in the bundle's man...(5 bytes skipped)...
206: * Parses the "Sling-Initial-Content" header from the given headers and returns the resolved PathEntries
210: * @return an iterator over the parsed {@code PathEntry} items or {@code null} in case no "Sling-Initial-Content" header was found
217: final List<PathEntry> entries = new ArrayList<>();
226: entries.add(new PathEntry(entry, bundleLastModified, bundleSymblicName));
310: if (pathValue != null) {
311: this.target = pathValue;
354: if (pathValue != null) {
192: return getContentPaths(headers, bundleLastModified);
202: return getContentPaths(toMap(bundle.getHeaders()), bundle.getLastModified(), bundle.getSymbolicName());
213: return getContentPaths(headers, bundleLastModified, null);

github.com/apache/sling-org-apache-sling-models-api:src/main/java/org/apache/sling/models/annotations/injectorspecific/ResourcePath.java: [ master, ]
44: public String path() default "";
38: public @interface ResourcePath {
50: public String[] paths() default {};
32: * resource by path(s). The path may be either in the path/paths attribute or in a value map property with the given name.
37: @Source("resource-path")
41: * Specifies the path of the resource. If not provided, the path is derived from the property name.
42: * @return Path
47: * Specifies more than one path for the resource. If not provided, a single path is derived from the property name.
53: * Specifies the name of the property containing the resource path. If empty or not set, then the name
48: * @return Paths

github.com/apache/sling-org-apache-sling-commons-jcr-file:src/main/java/org/apache/sling/commons/jcr/file/internal/JcrPath.java: [ master, ]
41: private final String path;
37: public class JcrPath implements Path {
47: JcrPath(final JcrFileSystem fileSystem, final String path) {
54: JcrPath(final JcrFileSystem fileSystem, final String first, final String... more) {
137: public Path subpath(int beginIndex, int endIndex) {
229: public Path toAbsolutePath() {
240: public Path toRealPath(LinkOption... options) throws IOException {
26: import java.nio.file.Path;
49: this.path = PathUtil.normalize(path);
50: this.names = names(this.path);
51: logger.info("new path: {}", path);
56: this.path = PathUtil.normalize(first + JcrFileSystem.SEPARATOR + String.join(JcrFileSystem.SEPARATOR, more));
57: this.names = names(this.path);
58: logger.info("new path: {}", path);
61: private List<String> names(final String path) {
63: if (path != null) {
64: final String[] strings = path.split("/");
76: logger.info("getting file system for {}", path);
82: logger.info("isAbsolute: {}", path);
83: return path.startsWith("/");
87: public Path getRoot() {
88: logger.info("getting root for {}", path);
93: public Path getFileName() {
94: logger.info("getting file name for {}", path);
105: public Path getParent() {
106: logger.info("getting parent for {}", path);
107: final String parent = PathUtil.getParent(path);
116: logger.info("getting name count: {}", path);
121: public Path getName(int index) {
122: logger.info("getting name: {}", path);
138: logger.info("subpath: {}", path);
144: public boolean startsWith(Path other) {
145: logger.info("startsWith: {}", path);
152: logger.info("startsWith: {}", path);
158: public boolean endsWith(Path other) {
159: logger.info("endsWith: {}", path);
166: logger.info("endsWith: {}", path);
171: public Path normalize() {
172: logger.info("normalizing path {}", path);
173: return new JcrPath(fileSystem, PathUtil.normalize(path));
178: public Path resolve(Path other) {
179: logger.info("resolving given path {} against this path {}", other, this);
183: if (this.path.endsWith("/")) {
184: final String path = this.path.concat(other.toString());
185: return new JcrPath(fileSystem, path);
187: final String path = String.format("%s/%s", this.path, other.toString());
188: return new JcrPath(fileSystem, path);
194: public Path resolve(String other) {
195: logger.info("resolving given path {} against this path {}", other, this);
196: final Path path = new JcrPath(fileSystem, other); // TODO InvalidPathException
197: return resolve(path);
202: public Path resolveSibling(Path other) {
209: public Path resolveSibling(String other) {
216: public Path relativize(Path other) {
224: logger.info("toUri: {}", path);
230: logger.info("toAbsolutePath: {}", path);
234: return new JcrPath(fileSystem, "/".concat(path));
241: logger.info("toRealPath: {}", path);
247: logger.info("to file: {}", path);
248: return new JcrFile(fileSystem, path);
267: public Iterator<Path> iterator() {
274: public int compareTo(Path other) {
281: return path;
45: private final Logger logger = LoggerFactory.getLogger(JcrPath.class);
89: return new JcrPath(fileSystem, "/");
100: return new JcrPath(fileSystem, name);
111: return new JcrPath(fileSystem, parent);
132: return new JcrPath(fileSystem, names.get(index));

github.com/kohsuke/groobuild:src/groobuild/v2/Path.java: [ master, ]
16: public abstract class Path implements Attainable {
34: public final File path;
74: public File path;
8: * Represents a file path whose actual location is determined lazily.
11: * {@link Path} is {@link Attainable}, which has the semantics
24: * Returns {@link Path} that represents a subpath from this path.
26: public abstract Path _(String relativePath);
29: * {@link Path} whose actual location is known.
33: public static final class Constant extends Path {
37: * Pre-requisites for attaining this path.
41: public Constant(File path) {
42: this.path = path;
54: public Path _(String relativePath) {
55: return new Constant(new File(path,relativePath));
60: * {@link Path} whose actual location may change
61: * after the path is used elsewhere.
73: public static final class Variable extends Path {
77: * Pre-requisites for attaining this path.
85: return new Constant(path);
88: public Path _(String relativePath) {

github.com/apache/sling-org-apache-sling-jcr-maintenance:src/main/java/org/apache/sling/jcr/maintenance/internal/VersionCleanupPath.java: [ master, ]
38: private final String path;
32: public class VersionCleanupPath implements Comparable<VersionCleanupPath> {
41: public VersionCleanupPath(VersionCleanupPathConfig config) {
69: public String getPath() {
44: this.path = config.path();
49: return path.compareTo(o.path) * -1;
67: * @return the path
70: return path;
74: final List<VersionCleanupPath> versionCleanupConfigs, final String path) throws RepositoryException {
75: log.trace("Evaluating configurations {} for path {}", versionCleanupConfigs, path);
76: return versionCleanupConfigs.stream().filter(c -> path.startsWith(c.getPath())).findFirst()
77: ...(13 bytes skipped)... .orElseThrow(() -> new RepositoryException("Failed to find version cleanup configuration for " + path));
88: return "VersionCleanupPath [keepVersions=" + keepVersions + ", limit=" + limit + ", path=" + path + "]";
30: @Component(service = VersionCleanupPath.class, immediate = true)
34: private static final Logger log = LoggerFactory.getLogger(VersionCleanupPath.class);
48: public int compareTo(VersionCleanupPath o) {
73: public static final VersionCleanupPath getMatchingConfiguration(
23: import org.apache.sling.jcr.maintenance.VersionCleanupPathConfig;
31: @Designate(ocd = VersionCleanupPathConfig.class, factory = true)

github.com/apache/flex-whiteboard:fthomas/developerToolSuite/trunk/org.apache.flex.utilities.developerToolSuite.executor-lib/src/main/flex/org/apache/flex/utilities/developerToolSuite/executor/infrastructure/message/ValidateJavaPathMessage.as: [ trunk, ]
26: public function get path():String {
18: public class ValidateJavaPathMessage {
22: public function ValidateJavaPathMessage(path:String) {
20: private var _path:String;
23: _path = path;
27: return _path;

github.com/GoogleCloudPlatform/datanucleus-appengine:testing/selenium-core/xpath/javascript-xpath-0.1.8.js: [ master, ]
645: UnionExpr.prototype.path = function(path) {
74: var PathExpr;
673: PathExpr = function(filter) {
2755: win.XPathExpression = function(expr) {
2773: win.XPathResult = function (value, type) {
614: union.path(expr);
619: throw Error('missing next union location path');
621: union.path(PathExpr.parse(lexer));
646: this.paths.push(path);
648: if (path.needContextPosition) {
651: if (path.needContextNode) {
686: var op, expr, path, token;
698: path = new PathExpr(FilterExpr.root()); // RootExpr
704: path.step(op, expr);
710: path = new PathExpr(FilterExpr.context());
711: path.step('/', expr);
716: path = new PathExpr(expr);
725: path.step(op, Step.parse(lexer));
728: return path;
806: t += indent + 'path:' + '\n';
1: /* JavaScript-XPath 0.1.8
4: * JavaScript-XPath is freely distributable under the terms of an MIT-style license.
5: * For details, see the JavaScript-XPath web site: http://coderepos.org/share/wiki/JavaScript-XPath
24: if (window.jsxpath) {
25: config = window.jsxpath;
57: && document.implementation.hasFeature("XPath", null));
600: this.paths = [];
609: expr = PathExpr.parse(lexer);
635: var paths = this.paths;
637: for (var i = 0, l = paths.length; i < l; i ++) {
638: var exrs = paths[i].evaluate(ctx);
639: if (!exrs.isNodeSet) throw Error('PathExpr must be nodeset');
660: for (var i = 0; i < this.paths.length; i ++) {
661: t += this.paths[i].show(indent);
668: * class: PathExpr
670: if (!window.PathExpr && window.defaultConfig)
671: window.PathExpr = null;
683: PathExpr.ops = { '//': 1, '/': 1 };
685: PathExpr.parse = function(lexer) {
731: PathExpr.prototype = new BaseExpr();
733: PathExpr.prototype.evaluate = function(ctx) {
786: PathExpr.prototype.step = function(op, step) {
803: PathExpr.prototype.show = function(indent) {
1013: // fix for "xpath href with spaces" (http://jira.openqa.org/browse/SEL-347)
2273: return node.__jsxpath_id__ \|\| (node.__jsxpath_id__ = this.uuid++);
2769: win.XPathExpression.prototype.evaluate = function(node, type) {
2770: return new win.XPathResult(this.expr.evaluate(new Ctx(node)), type);
2807: win.XPathResult.prototype.iterateNext = function() { return this.nodes[this.index++] };
2808: win.XPathResult.prototype.snapshotItem = function(i) { return this.nodes[i] };
2810: win.XPathResult.ANY_TYPE = 0;
2811: win.XPathResult.NUMBER_TYPE = 1;
2812: win.XPathResult.STRING_TYPE = 2;
2813: win.XPathResult.BOOLEAN_TYPE = 3;
2814: win.XPathResult.UNORDERED_NODE_ITERATOR_TYPE = 4;
2815: win.XPathResult.ORDERED_NODE_ITERATOR_TYPE = 5;
2816: win.XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE = 6;
2817: win.XPathResult.ORDERED_NODE_SNAPSHOT_TYPE = 7;
2818: win.XPathResult.ANY_UNORDERED_NODE_TYPE = 8;
2819: win.XPathResult.FIRST_ORDERED_NODE_TYPE = 9;
2823: return new win.XPathExpression(expr, null);

github.com/apache/sling-org-apache-sling-models-api:src/main/java/org/apache/sling/models/annotations/Path.java: [ master, ]
33: public @interface Path {
36: public String[] paths() default {};
27: * Provide path(s) on an @Inject. Not necessarily tied to the Resource Path injector (thus no

android.googlesource.com/platform/external/mp4parser:isoparser/src/main/java/com/googlecode/mp4parser/util/Path.java: [ master, ]
29: public class Path {
31: private Path() {
36: public static String createPath(Box box) {
40: private static String createPath(Box box, String path) {
52: public static Box getPath(Box box, String path) {
58: public static List<Box> getPaths(Box box, String path) {
42: return path;
46: path = String.format("/%s[%d]", box.getType(), index) + path;
48: return createPath(box.getParent(), path);
53: List<Box> all = getPaths(box, path);
59: if (path.startsWith("/")) {
65: return getPaths(isoFile, path.substring(1));
66: } else if (path.isEmpty()) {
71: if (path.contains("/")) {
72: later = path.substring(path.indexOf('/') + 1);
73: now = path.substring(0, path.indexOf('/'));
75: now = path;
104: throw new RuntimeException(now + " is invalid path.");
111: public static boolean isContained(Box box, String path) {
112: assert path.startsWith("/") : "Absolute path required";
113: return getPaths(box, path).contains(box);
37: return createPath(box, "");
83: return getPaths(box.getParent(), later);
96: children.addAll(getPaths(box1, later));

github.com/apache/dubbo:dubbo-common/src/main/java/org/apache/dubbo/common/URL.java: [ master, ]
113: protected String path;
559: public String getPath() {
563: public URL setPath(String path) {
567: public String getAbsolutePath() {
1515: public String getPathKey() {
55: import static org.apache.dubbo.common.constants.CommonConstants.PATH_KEY;
78: * for this case, url protocol = null, url host = 192.168.1.3, port = 20880, url path = null
80: * for this case, url protocol = file, url host = null, url path = home/user1/router.js
82: * for this case, url protocol = file, url host = home, url path = user1/router.js
84: * for this case, url protocol = file, url host = null, url path = D:/1/router.js
88: * for this case, url protocol = null, url host = null, url path = home/user1/router.js
90: * for this case, url protocol = null, url host = home, url path = user1/router.js
149: this.path = null;
158: ...(16 bytes skipped)...tring protocol, String host, int port, String[] pairs) { // varargs ... conflict with the following path argument, use array instead.
166: public URL(String protocol, String host, int port, String path) {
167: this(protocol, null, null, host, port, path, (Map<String, String>) null);
170: public URL(String protocol, String host, int port, String path, String... pairs) {
171: this(protocol, null, null, host, port, path, CollectionUtils.toStringMap(pairs));
174: public URL(String protocol, String host, int port, String path, Map<String, String> parameters) {
175: this(protocol, null, null, host, port, path, parameters);
178: public URL(String protocol, String username, String password, String host, int port, String path) {
179: this(protocol, username, password, host, port, path, (Map<String, String>) null);
182: public URL(String protocol, String username, String password, String host, int port, String path, String... pairs) {
183: this(protocol, username, password, host, port, path, CollectionUtils.toStringMap(pairs));
191: String path,
193: this(protocol, username, password, host, port, path, parameters, toMethodParameters(parameters));
201: String path,
212: while (path != null && path.startsWith("/")) {
213: path = path.substring(1);
215: this.path = path;
247: String path = null;
287: // case: file:/path/to/file.txt
300: path = url.substring(i + 1);
329: return new URL(protocol, username, password, host, port, path, parameters);
448: return new URL(protocol, username, password, host, port, path, getParameters());
456: return new URL(getProtocol(), username, password, host, port, path, getParameters());
464: return new URL(getProtocol(), username, password, host, port, path, getParameters());
481: return new URL(getProtocol(), username, password, host, port, path, getParameters());
504: return new URL(getProtocol(), username, password, host, port, path, getParameters());
528: return new URL(getProtocol(), username, password, host, port, path, getParameters());
560: return path;
564: return new URL(getProtocol(), username, password, host, port, path, getParameters());
568: if (path != null && !path.startsWith("/")) {
569: return "/" + path;
571: return path;
1151: return new URL(getProtocol(), username, password, host, port, path, map);
1165: return new URL(getProtocol(), username, password, host, port, path, map);
1180: return new URL(getProtocol(), username, password, host, port, path, map, methodMap);
1198: return new URL(getProtocol(), username, password, host, port, path, map, methodMap);
1234: return new URL(getProtocol(), username, password, host, port, path, map);
1243: return new URL(getProtocol(), username, password, host, port, path, map);
1285: return new URL(getProtocol(), username, password, host, port, path, map);
1289: return new URL(getProtocol(), username, password, host, port, path, new HashMap<>());
1308: if (PATH_KEY.equals(key)) {
1309: return path;
1332: if (path != null) {
1333: map.put(PATH_KEY, path);
1439: String path;
1441: path = getServiceKey();
1443: path = getPath();
1445: if (StringUtils.isNotEmpty(path)) {
1447: buf.append(path);
1511: * The format of return value is '{group}/{path/interfaceName}:{version}'
1516: String inf = StringUtils.isNotEmpty(path) ? path : getServiceInterface();
1523: public static String buildKey(String path, String group, String version) {
1524: return BaseServiceMetadata.buildServiceKey(path, group, version);
1549: return getParameter(INTERFACE_KEY, path);
1660: result = prime * result + ((path == null) ? 0 : path.hashCode());
1702: if (!StringUtils.isEquals(path, other.path)) {
405: ...(36 bytes skipped)...w URL(url.getProtocol(), url.getUsername(), url.getPassword(), url.getHost(), url.getPort(), url.getPath())
406: ...(20 bytes skipped)...w URL(url.getProtocol(), url.getUsername(), url.getPassword(), url.getHost(), url.getPort(), url.getPath(), newMap);

github.com/bazelbuild/bazel:src/main/java/com/google/devtools/build/lib/buildeventstream/proto/build_event_stream.proto: [ master, ]
1182: string path = 1;
482: repeated string path_prefix = 4;
494: string symlink_target_path = 7;
477: // A sequence of prefixes to apply to the file name to construct a full path.
493: // The symlink target path, if the file is an unresolved symlink.
530: // (e.g., a file path).
534: // (e.g., a file path).
745: // Path to logs of passed runs.
748: // Path to logs of failed runs;
1164: // The message that contains what type of action to perform on a given path and
1178: // The path of the symlink to be created or deleted, absolute or relative to
1187: // If action is CREATE, this is the target path that the symlink should point
1188: // to. If the path points underneath the output base, it is relative to the
549: // List of paths to log files

github.com/apache/hadoop:hadoop-hdfs-project/hadoop-hdfs/src/main/java/org/apache/hadoop/hdfs/server/namenode/FSEditLogOp.java: [ trunk, ]
432: String path;
872: String path;
963: private String path;
1076: String path;
1170: String path;
1519: String path;
1617: String path;
2415: String path;
2522: String path;
2983: String path;
4870: String path;
292: String getPath();
479: <T extends AddCloseOp> T setPath(String path) {
485: public String getPath() {
885: AppendOp setPath(String path) {
982: AddBlockOp setPath(String path) {
987: public String getPath() {
1093: UpdateBlocksOp setPath(String path) {
1099: public String getPath() {
1187: SetReplicationOp setPath(String path) {
1537: DeleteOp setPath(String path) {
1647: MkdirOp setPath(String path) {
2435: TimesOp setPath(String path) {
2552: SymlinkOp setPath(String path) {
2869: TruncateOp setPath(String src) {
3006: ReassignLeaseOp setPath(String path) {
4887: SetStoragePolicyOp setPath(String path) {
458: path = null;
480: this.path = path;
486: return path;
572: FSImageSerialization.writeString(path, out);
620: this.path = FSImageSerialization.readString(in);
714: .append(", path=")
715: .append(path)
757: XMLUtils.addSaxString(contentHandler, "PATH", path);
788: this.path = st.getValue("PATH");
886: this.path = path;
909: .append("[path=").append(path)
918: this.path = null;
926: this.path = FSImageSerialization.readString(in);
935: FSImageSerialization.writeString(path, out);
944: XMLUtils.addSaxString(contentHandler, "PATH", path);
954: this.path = st.getValue("PATH");
977: path = null;
983: this.path = path;
988: return path;
1011: FSImageSerialization.writeString(path, out);
1025: path = FSImageSerialization.readString(in);
1037: sb.append("AddBlockOp [path=")
1038: .append(path)
1050: XMLUtils.addSaxString(contentHandler, "PATH", path);
1060: this.path = st.getValue("PATH");
1089: path = null;
1094: this.path = path;
1100: return path;
1116: FSImageSerialization.writeString(path, out);
1124: path = FSImageSerialization.readString(in);
1138: sb.append("UpdateBlocksOp [path=")
1139: .append(path)
1149: XMLUtils.addSaxString(contentHandler, "PATH", path);
1157: this.path = st.getValue("PATH");
1183: path = null;
1188: this.path = path;
1200: FSImageSerialization.writeString(path, out);
1207: this.path = FSImageSerialization.readString(in);
1219: builder.append("SetReplicationOp [path=")
1220: .append(path)
1233: XMLUtils.addSaxString(contentHandler, "PATH", path);
1239: this.path = st.getValue("PATH");
1533: path = null;
1538: this.path = path;
1550: FSImageSerialization.writeString(path, out);
1565: this.path = FSImageSerialization.readString(in);
1581: .append(", path=")
1582: .append(path)
1598: XMLUtils.addSaxString(contentHandler, "PATH", path);
1606: this.path = st.getValue("PATH");
1635: path = null;
1648: this.path = path;
1676: FSImageSerialization.writeString(path, out);
1705: this.path = FSImageSerialization.readString(in);
1739: .append(", path=")
1740: .append(path)
1763: XMLUtils.addSaxString(contentHandler, "PATH", path);
1778: this.path = st.getValue("PATH");
2430: path = null;
2436: this.path = path;
2453: FSImageSerialization.writeString(path, out);
2468: this.path = FSImageSerialization.readString(in);
2485: .append(", path=")
2486: .append(path)
2503: XMLUtils.addSaxString(contentHandler, "PATH", path);
2512: this.path = st.getValue("PATH");
2540: path = null;
2553: this.path = path;
2580: FSImageSerialization.writeString(path, out);
2606: this.path = FSImageSerialization.readString(in);
2630: .append(", path=")
2631: .append(path)
2655: XMLUtils.addSaxString(contentHandler, "PATH", path);
2669: this.path = st.getValue("PATH");
2997: path = null;
3007: this.path = path;
3020: FSImageSerialization.writeString(path, out);
3028: this.path = FSImageSerialization.readString(in);
3037: .append(", path=")
3038: .append(path)
3052: XMLUtils.addSaxString(contentHandler, "PATH", path);
3058: this.path = st.getValue("PATH");
3476: /* set the directory path where the snapshot is taken. */
3581: /* set the directory path where the snapshot is taken. */
3952: .append("path=" + directive.getPath().toUri().getPath() + ",")
4019: builder.append(",").append("path=").append(directive.getPath());
4883: path = null;
4888: this.path = path;
4899: FSImageSerialization.writeString(path, out);
4906: this.path = FSImageSerialization.readString(in);
4913: builder.append("SetStoragePolicyOp [path=")
4914: .append(path)
4927: XMLUtils.addSaxString(contentHandler, "PATH", path);
4934: this.path = st.getValue("PATH");
3916: assert(directive.getPath() != null);
4018: if (directive.getPath() != null) {

github.com/apache/incubator-shenyu:shenyu-common/src/main/java/org/apache/shenyu/common/config/ShenyuConfig.java: [ master, ]
449: private String path;
464: public String getPath() {
473: public void setPath(final String path) {
717: public static class ExcludePath {
721: private List<String> paths = new ArrayList<>();
763: public static class FallbackPath {
767: private List<String> paths = new ArrayList<>();
813: private List<String> paths = new ArrayList<>();
746: public void setPaths(final List<String> paths) {
755: public List<String> getPaths() {
792: public void setPaths(final List<String> paths) {
801: public List<String> getPaths() {
838: public void setPaths(final List<String> paths) {
847: public List<String> getPaths() {
460: * Gets path.
462: * @return the path
465: return path;
469: * Sets path.
471: * @param path the path
474: this.path = path;
715: * The type Exclude path.
761: * The type fallback path.
1878: private String matchMode = TrieMatchModeEnum.ANT_PATH_MATCH.getMatchMode();
41: private ExcludePath exclude = new ExcludePath();
45: private FallbackPath fallback = new FallbackPath();
238: public ExcludePath getExclude() {
247: public void setExclude(final ExcludePath exclude) {
256: public FallbackPath getFallback() {
265: public void setFallback(final FallbackPath fallback) {
742: * Sets paths.
744: * @param paths the paths
747: this.paths = paths;
751: * get paths.
753: * @return paths paths
756: return paths;
788: * Sets paths.
790: * @param paths the paths
793: this.paths = paths;
797: * get paths.
799: * @return paths paths
802: return paths;
834: * Sets paths.
836: * @param paths the paths
839: this.paths = paths;
843: * get paths.
845: * @return paths paths
848: return paths;

github.com/apache/zookeeper:zookeeper-server/src/main/java/org/apache/zookeeper/server/ZooKeeperServer.java: [ master, ]
1067: String path;
244: final Map<String, ChangeRecord> outstandingChangesForPath = new HashMap<>();
2261: private String parentPath(String path) throws KeeperException.BadArgumentsException {
2269: private String effectiveACLPath(Request request) throws KeeperException.BadArgumentsException, KeeperException.InvalidACLException ...(1 bytes skipped)...
221: private final RequestPathMetricsCollector requestPathMetricsCollector;
432: public RequestPathMetricsCollector getRequestPathMetricsCollector() {
314: * When a request is completed or dropped, the relevant code path calls the
658: File path = zkDb.snapLog.getDataDir();
659: return getDirSize(path);
667: File path = zkDb.snapLog.getSnapDir();
668: return getDirSize(path);
1057: ChangeRecord(long zxid, String path, StatPersisted stat, int childCount, List<ACL> acl) {
1059: this.path = path;
1080: ChangeRecord changeRecord = new ChangeRecord(zxid, path, stat, childCount,
1893: if (outstandingChangesForPath.get(cr.path) == cr) {
1894: outstandingChangesForPath.remove(cr.path);
2076: * @param path : the ZNode path
2079: public void checkACL(ServerCnxn cnxn, List<ACL> acl, int perm, List<Id> ids, String path, List<ACL> setAcls) throws KeeperException.NoAuthException {
2108: new ServerAuthenticationProvider.MatchValues(path, authId.getId(), id.getId(), perm, setAcls))) {
2119: * check a path whether exceeded the quota.
2121: * @param path
2122: * the path of the node, used for the quota prefix check
2130: public void checkQuota(String path, byte[] lastData, byte[] data, int type) throws KeeperException.QuotaExceededException {
2136: String lastPrefix = zkDatabase.getDataTree().getMaxPrefixWithQuota(path);
2141: final String namespace = PathUtils.getTopNamespace(path);
2155: * check a path whether exceeded the quota.
2158: the path of the node which has a quota.
2255: * Trim a path to get the immediate predecessor.
2257: * @param path
2262: int lastSlash = path.lastIndexOf('/');
2263: if (lastSlash == -1 \|\| path.indexOf('\0') != -1 \|\| getZKDatabase().isSpecialPath(path)) {
2264: throw new KeeperException.BadArgumentsException(path);
2266: return lastSlash == 0 ? "/" : path.substring(0, lastSlash);
2271: String path = null;
2281: path = parentPath(req.getPath());
2288: path = parentPath(req.getPath());
2295: path = req.getPath();
2304: path = req.getPath();
2315: PrepRequestProcessor.fixupACL(path, request.authInfo, acl);
2318: return path;
2375: LOG.debug("ACL check against illegal node path: {}", e.getMessage());
60: import org.apache.zookeeper.common.PathUtils;
446: pwriter.println(zkDb.snapLog.getSnapDir().getAbsolutePath());
450: pwriter.println(zkDb.snapLog.getDataDir().getAbsolutePath());
471: zkDb.snapLog.getSnapDir().getAbsolutePath(),
472: zkDb.snapLog.getDataDir().getAbsolutePath(),
2171: String limitNode = Quotas.limitPath(lastPrefix);
2190: //check the statPath quota
2191: String statNode = Quotas.statPath(lastPrefix);
2353: String pathToCheck;
2362: pathToCheck = effectiveACLPath(request);
2363: if (pathToCheck != null) {
2364: checkACL(request.cnxn, zkDb.getACL(pathToCheck, null), effectiveACLPerms(request), request.authInfo, pathToCheck, null);
92: import org.apache.zookeeper.server.util.RequestPathMetricsCollector;
343: this.requestPathMetricsCollector = new RequestPathMetricsCollector();
381: this.requestPathMetricsCollector = new RequestPathMetricsCollector();
433: return requestPathMetricsCollector;
825: requestPathMetricsCollector.start();
988: requestPathMetricsCollector.shutdown();

github.com/google/error-prone:check_api/src/main/java/com/google/errorprone/util/ASTHelpers.java: [ master, ]
1690: public abstract TreePath path();
418: public static <T> TreePath findPathFromEnclosingNodeToTopLevel(TreePath path, Class<T> klass) {
415: * Given a TreePath, finds the first enclosing node of the given type and returns the path from
419: if (path != null) {
421: path = path.getParentPath();
422: } while (path != null && !klass.isInstance(path.getLeaf()));
424: return path;
441: public static <T> T findEnclosingNode(TreePath path, Class<T> klass) {
442: path = findPathFromEnclosingNodeToTopLevel(path, klass);
443: return (path == null) ? null : klass.cast(path.getLeaf());
1524: * The return value is normalized to always use '/' to separate elements of the path and to always
1536: * normalized to always use '/' to separate elements of the path and to always have a leading '/'.
1692: static TargetType create(Type type, TreePath path) {
1693: return new AutoValue_ASTHelpers_TargetType(type, path);
1750: * Returns the target type of the tree at the given {@link VisitorState}'s path, or else {@code
1997: for (TreePath path = parent; path != null; path = path.getParentPath()) {
1998: Tree enclosing = path.getLeaf();
99: import com.sun.source.util.TreePath;
377: Tree parent = state.getPath().getParentPath().getLeaf();
391: Tree parent = state.getPath().getParentPath().getLeaf();
437: * Given a TreePath, walks up the tree until it finds a node of the given type. Returns null if no
449: for (Tree parent : state.getPath()) {
920: /* @Inherited won't work if the annotation isn't on the classpath, but we can still
1229: JCCompilationUnit compilationUnit = (JCCompilationUnit) state.getPath().getCompilationUnit();
1243: TreePath pathToExpr = new TreePath(state.getPath(), expr);
1244: return nullnessAnalysis.getNullness(pathToExpr, state.context);
1394: * Returns true if the leaf node in the {@link TreePath} from {@code state} sits somewhere
1398: for (Tree ancestor : state.getPath()) {
1413: * Returns true if the leaf node in the {@link TreePath} from {@code state} sits somewhere
1417: for (Tree ancestor : state.getPath()) {
1541: return uri.getPath();
1546: // It's possible (though it violates the zip file spec) for paths to zip file entries to use
1620: return stream(state.getPath())
1665: return stream(state.getPath())
1758: if (!canHaveTargetType(state.getPath().getLeaf())) {
1762: TreePath parent = state.getPath();
1765: parent = parent.getParentPath();
1776: actualTree = parent.getParentPath().getParentPath().getParentPath().getLeaf();
1779: actualTree = parent.getParentPath().getParentPath().getLeaf();
1848: private final TreePath parent;
1851: private TargetTypeVisitor(ExpressionTree current, VisitorState state, TreePath parent) {
1888: Tree switchTree = parent.getParentPath().getLeaf();
2474: for (Tree ancestor : state.getPath()) {
862: * the definition of the annotation on the runtime and compile-time classpaths
891: * the definition of the annotation on the runtime and compile-time classpaths

github.com/apache/incubator-shenyu:shenyu-common/src/main/java/org/apache/shenyu/common/constant/Constants.java: [ master, ]
188: String PATH = "path";
43: String CONTEXT_PATH = "contextPath";
248: String PATH_SEPARATOR = "/";
378: String FILTER_PATH = "filterPath";
533: String SCRIPT_PATH = "/META-INF/scripts/";
568: String META_PATH = "/shenyu-client/register-metadata";
578: String URI_PATH = "/shenyu-client/register-uri";
583: String OFFLINE_PATH = "/shenyu-client/offline";
593: String API_DOC_PATH = "/shenyu-client/register-apiDoc";
598: String LOGIN_PATH = "/platform/login";
213: String SIGN_PATH_NOT_EXIST = "you have not configured the sign path.";
508: String CONTEXT_PATH_NAME_PREFIX = "/context-path";
653: String SHENYU_ADMIN_PATH_CONFIGS_FETCH = "/configs/fetch";
658: String SHENYU_ADMIN_PATH_CONFIGS_LISTENER = "/configs/listener";
734: Integer TRIE_PATH_VARIABLES_SIZE = 128;
739: Integer TRIE_PATH_CACHE_SIZE = 256;
41: * The constant context path.
186: * The constant PATH.
211: * The constant SIGN_PATH_NOT_EXIST.
506: * context path name prefix.
531: * redis script path.
566: * When register by http, the meta register path.
576: * When register by http, the uri path.
581: * When register by http, the offline path.
591: * The constant API_DOC_PATH.
596: * When register by http, the login path.
651: * shenyu admin path configs fetch.
656: * shenyu admin path configs listener.
732: * trie default path variables size.
737: * trie default path cache size.
376: * jwt handle key for filterPath.

github.com/apache/tomcat:java/org/apache/catalina/core/StandardContext.java: [ trunk, ]
326: private String path = null;
320: private String encodedPath = null;
679: private String sessionCookiePath;
821: private boolean allowMultipleLeadingForwardSlashInPath = false;
841: public void setAllowMultipleLeadingForwardSlashInPath(
848: public boolean getAllowMultipleLeadingForwardSlashInPath() {
1178: public String getEncodedPath() {
1581: public String getSessionCookiePath() {
1593: public void setSessionCookiePath(String sessionCookiePath) {
2058: public String getPath() {
2069: public void setPath(String path) {
2555: public String getWorkPath() {
4351: public String getRealPath(String path) {
6370: public String getContextPath() {
6466: public String getRealPath(String path) {
687: private boolean sessionCookiePathUsesTrailingSlash = false;
815: private boolean dispatchersUseEncodedPaths = true;
888: public void setDispatchersUseEncodedPaths(boolean dispatchersUseEncodedPaths) {
899: public boolean getDispatchersUseEncodedPaths() {
1602: public boolean getSessionCookiePathUsesTrailingSlash() {
1608: public void setSessionCookiePathUsesTrailingSlash(
6407: public Set<String> getResourcePaths(String path) {
318: * Encoded path.
324: * Unencoded path for this web application.
676: * The path to use for session cookies. <code>null</code> indicates that
677: * the path is controlled by the application.
683: * Is a / added to the end of the session cookie path to ensure browsers,
1073: return new ContextName(path, webappVersion).getBaseName();
1574: * Gets the path to use for session cookies. Overrides any setting that
1577: * @return The value of the default session cookie path or null if not
1587: * Sets the path to use for session cookies. Overrides any setting that
1590: * @param sessionCookiePath The path to use
2055: * @return the context path for this Context.
2059: return path;
2064: * Set the context path for this Context.
2066: * @param path The new context path
2071: if (path == null \|\| path.equals("/")) {
2073: this.path = "";
2074: } else if ("".equals(path) \|\| path.startsWith("/")) {
2075: this.path = path;
2078: this.path = "/" + path;
2080: if (this.path.endsWith("/")) {
2082: this.path = this.path.substring(0, this.path.length() - 1);
2086: "standardContext.pathInvalid", path, this.path));
2088: encodedPath = URLEncoder.DEFAULT.encode(this.path, StandardCharsets.UTF_8);
2090: setName(this.path);
2550: / Get the absolute path** to the work dir.
2553: * @return The work path
4345: * Return the real path for a given virtual path, if possible; otherwise
4348: * @param path The path to the desired resource
4354: if ("".equals(path)) {
4355: path = "/";
4359: WebResource resource = resources.getResource(path);
4364: !resource.exists()) && path.endsWith("/")) {
6001: // Acquire (or calculate) the work directory path
6408: return sc.getResourcePaths(path);
6412: public URL getResource(String path) throws MalformedURLException {
6413: return sc.getResource(path);
6417: public InputStream getResourceAsStream(String path) {
6418: return sc.getResourceAsStream(path);
6422: public RequestDispatcher getRequestDispatcher(String path) {
6423: return sc.getRequestDispatcher(path);
6467: return sc.getRealPath(path);
591: * The pathname to the work directory for this context (relative to
842: boolean allowMultipleLeadingForwardSlashInPath) {
843: this.allowMultipleLeadingForwardSlashInPath = allowMultipleLeadingForwardSlashInPath;
849: return allowMultipleLeadingForwardSlashInPath;
1179: return encodedPath;
1582: return sessionCookiePath;
1594: String oldSessionCookiePath = this.sessionCookiePath;
1595: this.sessionCookiePath = sessionCookiePath;
1596: support.firePropertyChange("sessionCookiePath",
1597: oldSessionCookiePath, sessionCookiePath);
2145: * pathname, a relative pathname, or a URL.
2154: * pathname, a relative pathname, or a URL.
2565: log.warn(sm.getString("standardContext.workPath", getName()),
2569: return workDir.getAbsolutePath();
4352: // The WebResources API expects all paths to start with /. This is a
4360: String canonicalPath = resource.getCanonicalPath();
4361: if (canonicalPath == null) {
4363: } else if ((resource.isDirectory() && !canonicalPath.endsWith(File.separator) \|\|
4365: return canonicalPath + File.separatorChar;
4367: return canonicalPath;
4370: // ServletContext.getRealPath() does not allow this to be thrown
6044: String catalinaHomePath = null;
6046: catalinaHomePath = getCatalinaBase().getCanonicalPath();
6047: dir = new File(catalinaHomePath, workDir);
6050: workDir, catalinaHomePath, getName()), e);
6371: return sc.getContextPath();
6375: public ServletContext getContext(String uripath) {
6376: return sc.getContext(uripath);
889: this.dispatchersUseEncodedPaths = dispatchersUseEncodedPaths;
900: return dispatchersUseEncodedPaths;
1603: return sessionCookiePathUsesTrailingSlash;
1609: boolean sessionCookiePathUsesTrailingSlash) {
1610: this.sessionCookiePathUsesTrailingSlash =
1611: sessionCookiePathUsesTrailingSlash;

github.com/google/google-authenticator:mobile/blackberry/src/com/google/authenticator/blackberry/Uri.java: [ master, ]
496: private PathPart path;
1025: private final PathPart path;
1183: private PathPart path;
1247: Builder path(PathPart path) {
1263: public Builder path(String path) {
248: public abstract String getPath();
256: public abstract String getEncodedPath();
504: public String getPath() {
508: public String getEncodedPath() {
516: private String parsePath() {
647: static String parsePath(String uriString, int ssi) {
778: public String getPath() {
782: public String getEncodedPath() {
857: static class PathSegments {
864: PathSegments(String[] segments, int size) {
885: static class PathSegmentsBuilder {
1099: public String getEncodedPath() {
1103: public String getPath() {
1274: public Builder encodedPath(String path) {
1281: public Builder appendPath(String newSegment) {
1288: public Builder appendEncodedPath(String newSegment) {
1897: static class PathPart extends AbstractPart {
1905: private PathPart(String encoded, String decoded) {
1920: private PathSegments pathSegments;
2074: public static Uri withAppendedPath(Uri baseUri, String pathSegment) {
297: public abstract String[] getPathSegments();
304: public abstract String getLastPathSegment();
498: private PathPart getPathPart() {
512: public String[] getPathSegments() {
802: public String[] getPathSegments() {
806: public String getLastPathSegment() {
921: public String getLastPathSegment() {
1123: public String[] getPathSegments() {
1928: PathSegments getPathSegments() {
90: and a path component that begins with two slash characters. The
96: <scheme>://<authority><path>?<query>
243: * Gets the decoded path.
245: * @return the decoded path, or null if this is not a hierarchical URI
251: * Gets the encoded path.
253: * @return the encoded path, or null if this is not a hierarchical URI
293: * Gets the decoded path segments.
295: * @return decoded path segments, each without a leading or trailing '/'
300: * Gets the decoded last segment in the path.
302: * @return the decoded last segment or null if the path is empty
499: return path == null
500: ? path = PathPart.fromEncoded(parsePath())
501: : path;
619: // Look for the start of the path, query, or fragment, or the
624: case '/': // Start of path
640: * Parses a path out of this given URI string.
645: * @return the path
650: // Find start of path.
655: // Skip over authority to path.
661: return ""; // Empty path.
662: case '/': // Start of path!
668: // Path starts immediately after scheme separator.
672: // Find end of path.
691: .path(getPathPart())
855: * Wrapper for path segment array.
1029: private HierarchicalUri(String scheme, Part authority, PathPart path,
1033: this.path = path == null ? PathPart.NULL : path;
1081: String encodedPath = path.getEncoded();
1100: return this.path.getEncoded();
1104: return this.path.getDecoded();
1124: return this.path.getPathSegments().segments;
1158: .path(path)
1169: * {@code <scheme>://<authority><absolute path>?<query>#<fragment>}
1172: * of two patterns: {@code <relative or absolute path>?<query>#<fragment>}
1173: * or {@code //<authority><absolute path>?<query>#<fragment>}
1251: this.path = path;
1256: * Sets the path. Leaves '/' characters intact but encodes others as
1259: * <p>If the path is not null and doesn't start with a '/', and if
1261: * given path with a '/'.
1264: return path(PathPart.fromDecoded(path));
1268: * Sets the previously encoded path.
1270: * <p>If the path is not null and doesn't start with a '/', and if
1272: * given path with a '/'.
1275: return path(PathPart.fromEncoded(path));
1279: * Encodes the given segment and appends it to the path.
1282: return path(PathPart.appendDecodedSegment(path, newSegment));
1286: * Appends the given segment to the path.
1289: return path(PathPart.appendEncodedSegment(path, newSegment));
1378: PathPart path = this.path;
1379: if (path == null \|\| path == PathPart.NULL) {
1380: path = PathPart.EMPTY;
1382: // If we have a scheme and/or authority, the path must
1385: path = PathPart.makeAbsolute(path);
1390: scheme, authority, path, query, fragment);
1894: * Immutable wrapper of encoded and decoded versions of a path part. Lazily
1917: * Cached path segments. This doesn't need to be volatile--we don't
1923: * Gets the individual path segments. Parses them if necessary.
1925: * @return parsed path segments or null if this isn't a hierarchical
1933: String path = getEncoded();
1934: if (path == null) {
1942: while ((current = path.indexOf('/', previous)) > -1) {
1943: // This check keeps us from adding a segment if the path starts
1947: = decode(path.substring(previous, current));
1953: // Add in the final path segment.
1954: if (previous < path.length()) {
1955: segmentBuilder.add(decode(path.substring(previous)));
1963: // If there is no old path, should we make the new path relative
1967: // No old path.
1980: // No old path.
1999: * Creates a path from the encoded string.
2008: * Creates a path from the decoded string.
2017: * Creates a path from the encoded and decoded strings.
2035: * Prepends path values with "/" if they're present, not empty, and
2065: * Creates a new Uri by appending an already-encoded path segment to a
2068: * @param baseUri Uri to append path segment to
2069: * @param pathSegment encoded path segment to append
2071: * the path
115: PathPart.EMPTY, Part.NULL, Part.NULL);
309: * equal. Case counts. Paths are not normalized. If one Uri specifies a
538: return parsePath(uriString, ssi);
651: int pathStart;
656: pathStart = ssi + 3;
657: LOOP: while (pathStart < length) {
658: switch (uriString.charAt(pathStart)) {
665: pathStart++;
669: pathStart = ssi + 1;
673: int pathEnd = pathStart;
674: LOOP: while (pathEnd < length) {
675: switch (uriString.charAt(pathEnd)) {
680: pathEnd++;
683: return uriString.substring(pathStart, pathEnd);
859: static final PathSegments EMPTY = new PathSegments(null, 0);
883: * Builds PathSegments.
902: PathSegments build() {
904: return PathSegments.EMPTY;
908: return new PathSegments(segments, size);
1082: if (encodedPath != null) {
1083: builder.append(encodedPath);
1377: // Hierarchical URIs should not return null for getPath().
1900: static final PathPart NULL = new PathPart(null, null);
1903: static final PathPart EMPTY = new PathPart("", "");
1929: if (pathSegments != null) {
1930: return pathSegments;
1935: return pathSegments = PathSegments.EMPTY;
1938: PathSegmentsBuilder segmentBuilder = new PathSegmentsBuilder();
1958: return pathSegments = segmentBuilder.build();
1961: static PathPart appendEncodedSegment(PathPart oldPart,
1971: String oldPath = oldPart.getEncoded();
1973: if (oldPath == null) {
1974: oldPath = "";
1977: int oldPathLength = oldPath.length();
1978: String newPath;
1981: newPath = "/" + newSegment;
1982: } else if (oldPath.charAt(oldPathLength - 1) == '/') {
1983: newPath = oldPath + newSegment;
1985: newPath = oldPath + "/" + newSegment;
1988: return fromEncoded(newPath);
1991: static PathPart appendDecodedSegment(PathPart oldPart, String decoded) {
1994: // TODO: Should we reuse old PathSegments? Probably not.
2003: static PathPart fromEncoded(String encoded) {
2012: static PathPart fromDecoded(String decoded) {
2022: static PathPart from(String encoded, String decoded) {
2031: return new PathPart(encoded, decoded);
2038: static PathPart makeAbsolute(PathPart oldPart) {
2043: String oldPath = encodedCached ? oldPart.encoded : oldPart.decoded;
2045: if (oldPath == null \|\| oldPath.length() == 0
2046: \|\| oldPath.startsWith("/")) {
2060: return new PathPart(newEncoded, newDecoded);
2076: builder = builder.appendEncodedPath(pathSegment);
505: return getPathPart().getDecoded();
509: return getPathPart().getEncoded();
513: return getPathPart().getPathSegments().segments;
925: String[] segments = getPathSegments();
1979: if (oldPathLength == 0) {

github.com/apache/zookeeper:zookeeper-server/src/main/java/org/apache/zookeeper/KeeperException.java: [ master, ]
524: private String path;
557: public String getPath() {
48: * @param path The ZooKeeper path being operated on.
52: public static KeeperException create(Code code, String path) {
54: r.path = path;
63: public static KeeperException create(int code, String path) {
65: r.path = path;
413: / Exceeded the quota that was set on the path*./
530: KeeperException(Code code, String path) {
532: this.path = path;
554: * Read the path for this exception
555: * @return the path associated with this error, null if none
558: return path;
563: if (path == null \|\| path.isEmpty()) {
566: return "KeeperErrorCode = " + getCodeMessage(code) + " for " + path;
618: public BadArgumentsException(String path) {
619: super(Code.BADARGUMENTS, path);
633: public BadVersionException(String path) {
634: super(Code.BADVERSION, path);
672: public InvalidACLException(String path) {
673: super(Code.INVALIDACL, path);
747: public NoChildrenForEphemeralsException(String path) {
748: super(Code.NOCHILDRENFOREPHEMERALS, path);
762: public NodeExistsException(String path) {
763: super(Code.NODEEXISTS, path);
777: public NoNodeException(String path) {
778: super(Code.NONODE, path);
792: public NotEmptyException(String path) {
793: super(Code.NOTEMPTY, path);
916: public NoWatcherException(String path) {
917: super(Code.NOWATCHER, path);
931: public ReconfigDisabledException(String path) {
932: super(Code.RECONFIGDISABLED, path);
945: public SessionClosedRequireAuthException(String path) {
946: super(Code.SESSIONCLOSEDREQUIRESASLAUTH, path);
970: public QuotaExceededException(String path) {
971: super(Code.QUOTAEXCEEDED, path);

github.com/google/binnavi:src/main/java/com/google/security/zynamics/binnavi/data/postgresql_tables.sql: [ master, ]
1394: path integer[],
1241: CREATE TABLE bn_edge_paths (
1250: COMMENT ON COLUMN bn_edge_paths.edge_id IS 'The id of the edge which the path information belongs to.';
1251: COMMENT ON COLUMN bn_edge_paths."position" IS 'The position of the edge path.';
1252: COMMENT ON COLUMN bn_edge_paths.x IS 'The x coordinate of the edge path';
1253: COMMENT ON COLUMN bn_edge_paths.y IS 'The y coordinate of the edge path';
1409: COMMENT ON COLUMN bn_expression_types.path IS 'The path of the type substitution. Each integer here is an element from bn_types.';
2294: SELECT '\|\| moduleid \|\|', et.address, et.position, et.expression_id, et.type, et.path, et.offset
2399: expression_types_path integer[],
2437: bety.path AS expression_types_path,
4647: ...(40 bytes skipped)...integer, IN address bigint, IN position integer, IN expressionid integer, IN basetypeid integer, IN path integer[], IN offset integer)
4656: IN path integer[],
4661: INSERT INTO bn_expression_types (module_id, address, position, expression_id, base_type_id, path, offset)
4670: IN path integer[],
4819: path integer[],
4825: SELECT address, "position", expression_id, base_type_id, path, "offset"
4848: path integer[],
4854: SELECT address, "position", expression_id, base_type_id, path, "offset"
1238: -- bn_edge_paths
1246: CONSTRAINT bn_edge_paths_pkey PRIMARY KEY (edge_id, "position")
1249: COMMENT ON TABLE bn_edge_paths IS 'This table stores the layout information of edges.';
4639: LEFT JOIN bn_edge_paths AS ep ON ep.edge_id = edges.id

github.com/apache/ignite:modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/sql/generated/IgniteSqlParserImplConstants.java: [ master, ]
411: int PATH = 405;
127: int CURRENT_PATH = 121;
920: "\"CURRENT_PATH\"",
1204: "\"PATH\"",

github.com/apache/shiro:web/src/main/java/org/apache/shiro/web/servlet/SimpleCookie.java: [ master, ]
79: private String path;
63: protected static final String PATH_ATTRIBUTE_NAME = "Path";
155: public String getPath() {
160: public void setPath(String path) {
226: private String calculatePath(HttpServletRequest request) {
324: private void appendPath(StringBuilder sb, String path) {
393: private boolean pathMatches(String cookiePath, String requestPath) {
103: this.path = cookie.getPath();
156: return path;
161: this.path = path;
219: * Returns the Cookie's calculated path setting. If the {@link javax.servlet.http.Cookie#getPath() path} is {@code null}, then the
220: * {@code request}'s {@link javax.servlet.http.HttpServletRequest#getContextPath() context path}
221: * will be returned. If getContextPath() is the empty string or null then the ROOT_PATH constant is returned.
224: * @return the path to be used as the path when the cookie is created or removed
227: String path = StringUtils.clean(getPath());
228: if (!StringUtils.hasText(path)) {
229: path = StringUtils.clean(request.getContextPath());
233: if (path == null) {
234: path = ROOT_PATH;
236: log.trace("calculated path: {}", path);
237: return path;
247: String path = calculatePath(request);
254: addCookieHeader(response, name, value, comment, domain, path, maxAge, version, secure, httpOnly, sameSite);
258: String domain, String path, int maxAge, int version,
261: String headerValue = buildHeaderValue(name, value, comment, domain, path, maxAge, version, secure, httpOnly, sameSite);
277: String domain, String path, int maxAge, int version,
280: return buildHeaderValue(name, value, comment, domain, path, maxAge, version, secure, httpOnly, getSameSite());
284: String domain, String path, int maxAge, int version,
299: appendPath(sb, path);
325: if (StringUtils.hasText(path)) {
327: sb.append(PATH_ATTRIBUTE_NAME).append(NAME_VALUE_DELIMITER).append(path);
391: * @see <a href="https://tools.ietf.org/html/rfc6265#section-5.1.4">RFC 6265, Section 5.1.4 "Paths and Path-Match"</a>
422: String path = calculatePath(request);
429: addCookieHeader(response, name, value, comment, domain, path, maxAge, version, secure, httpOnly, sameSite);
441: String path = StringUtils.clean(getPath());
442: if (path != null && !pathMatches(path, request.getRequestURI())) {
443: log.warn("Found '{}' cookie at path '{}', but should be only used for '{}'",
444: new Object[] { name, Encode.forHtml(request.getRequestURI()), path});
386: * Check whether the given {@code cookiePath} matches the {@code requestPath}
388: * @param cookiePath
389: * @param requestPath
394: if (!requestPath.startsWith(cookiePath)) {
398: return requestPath.length() == cookiePath.length()
399: \|\| cookiePath.charAt(cookiePath.length() - 1) == '/'
400: \|\| requestPath.charAt(cookiePath.length()) == '/';

github.com/apache/nifi:nifi-nar-bundles/nifi-hive-bundle/nifi-hive-processors/src/main/java/org/apache/hadoop/hive/ql/io/orc/OrcFlowFileWriter.java: [ master, ]
113: private final Path path;
38: import org.apache.hadoop.fs.Path;
157: Path path,
175: this.path = path;
213: memoryManager.addWriter(path, stripeSize, this);
333: LOG.debug("ORC writer " + path + " size = " + size + " limit = " +
2519: memoryManager.removeWriter(path);

github.com/grpc/grpc-java:okhttp/src/main/java/io/grpc/okhttp/OkHttpServerTransport.java: [ master, ]
85: private static final ByteString PATH = ByteString.encodeUtf8(":path");
652: ByteString path = null;
660: } else if (PATH.equals(header.name) && path == null) {
661: path = header.value;
679: && (httpMethod == null \|\| scheme == null \|\| path == null)) {
727: // Remove the leading slash of the path and get the fully qualified method name
728: if (path.size() == 0 \|\| path.getByte(0) != '/') {
730: "Expected path to start with /: " + asciiString(path));
733: String method = asciiString(path).substring(1);

github.com/apache/drill:exec/java-exec/src/main/resources/rest/static/js/d3.v3.js: [ master, ]
4108: d3.geo.path = function() {
4110: function path(object) {
5938: function d3_layout_bundlePath(link) {
3845: var d3_geo_pathAreaSum, d3_geo_pathAreaPolygon, d3_geo_pathArea = {
3872: var d3_geo_pathBoundsX0, d3_geo_pathBoundsY0, d3_geo_pathBoundsX1, d3_geo_pathBoundsY1;
3880: function d3_geo_pathBoundsPoint(x, y) {
3931: function d3_geo_pathBufferCircle(radius) {
3947: function d3_geo_pathCentroidPoint(x, y) {
3966: function d3_geo_pathCentroidLineEnd() {
4155: function d3_geo_pathProjectStream(project) {
4118: path.area = function(object) {
4123: path.centroid = function(object) {
4128: path.bounds = function(object) {
4133: path.projection = function(_) {
4138: path.context = function(_) {
4144: path.pointRadius = function(_) {
4147: return path;
4151: return path;
4153: return path.projection(d3.geo.albersUsa()).context(null);
7922: var i = 0, n = points.length, p = points[0], path = [ p[0], ",", p[1] ];
7923: while (++i < n) path.push("H", (p[0] + (p = points[i])[0]) / 2, "V", p[1]);
7924: if (n > 1) path.push("H", p[0]);
7925: return path.join("");
7928: var i = 0, n = points.length, p = points[0], path = [ p[0], ",", p[1] ];
7929: while (++i < n) path.push("V", (p = points[i])[1], "H", p[0]);
7930: return path.join("");
7933: var i = 0, n = points.length, p = points[0], path = [ p[0], ",", p[1] ];
7934: while (++i < n) path.push("H", (p = points[i])[0], "V", p[1]);
7935: return path.join("");
7951: var quad = points.length != tangents.length, path = "", p0 = points[0], p = points[1], t0 = tangents[0], t = t0, pi = 1;
7953: path += "Q" + (p[0] - t0[0] * 2 / 3) + "," + (p[1] - t0[1] * 2 / 3) + "," + p[0] + "," + p[1];
7961: path += "C" + (p0[0] + t0[0]) + "," + (p0[1] + t0[1]) + "," + (p[0] - t[0]) + "," + (p[1] - t[1]) + "," ...(20 bytes skipped)...
7965: path += "S" + (p[0] - t[0]) + "," + (p[1] - t[1]) + "," + p[0] + "," + p[1];
7970: path += "Q" + (p[0] + t[0] * 2 / 3) + "," + (p[1] + t[1] * 2 / 3) + "," + lp[0] + "," + lp[1];
7972: return path;
7986: ...(44 bytes skipped)...s[0], x0 = pi[0], y0 = pi[1], px = [ x0, x0, x0, (pi = points[1])[0] ], py = [ y0, y0, y0, pi[1] ], path = [ x0, ",", y0, "L", d3_svg_lineDot4(d3_svg_lineBasisBezier3, px), ",", d3_svg_lineDot4(d3_svg_lin...(21 bytes skipped)...
7994: d3_svg_lineBasisBezier(path, px, py);
7997: path.push("L", pi);
7998: return path.join("");
8002: var path = [], i = -1, n = points.length, pi, px = [ 0 ], py = [ 0 ];
8008: path.push(d3_svg_lineDot4(d3_svg_lineBasisBezier3, px) + "," + d3_svg_lineDot4(d3_svg_lineBasisBezier3, ...(5 bytes skipped)...
8016: d3_svg_lineBasisBezier(path, px, py);
8018: return path.join("");
8021: var path, i = -1, n = points.length, m = n + 4, pi, px = [], py = [];
8027: path = [ d3_svg_lineDot4(d3_svg_lineBasisBezier3, px), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, py)...(3 bytes skipped)...
8035: d3_svg_lineBasisBezier(path, px, py);
8037: return path.join("");
8056: function d3_svg_lineBasisBezier(path, x, y) {
8057: path.push("C", d3_svg_lineDot4(d3_svg_lineBasisBezier1, x), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier1...(206 bytes skipped)...
8647: var range = d3_scaleRange(scale1), path = g.selectAll(".domain").data([ 0 ]), pathUpdate = (path.enter().append("path").attr("class", "domain"),
8648: d3.transition(path));
3850: d3_geo_pathAreaPolygon = 0;
3851: d3_geo_pathArea.lineStart = d3_geo_pathAreaRingStart;
3854: d3_geo_pathArea.lineStart = d3_geo_pathArea.lineEnd = d3_geo_pathArea.point = d3_noop;
3855: d3_geo_pathAreaSum += abs(d3_geo_pathAreaPolygon / 2);
3858: function d3_geo_pathAreaRingStart() {
3860: d3_geo_pathArea.point = function(x, y) {
3861: d3_geo_pathArea.point = nextPoint;
3865: d3_geo_pathAreaPolygon += y0 * x - x0 * y;
3868: d3_geo_pathArea.lineEnd = function() {
3873: var d3_geo_pathBounds = {
3874: point: d3_geo_pathBoundsPoint,
3881: if (x < d3_geo_pathBoundsX0) d3_geo_pathBoundsX0 = x;
3882: if (x > d3_geo_pathBoundsX1) d3_geo_pathBoundsX1 = x;
3883: if (y < d3_geo_pathBoundsY0) d3_geo_pathBoundsY0 = y;
3884: if (y > d3_geo_pathBoundsY1) d3_geo_pathBoundsY1 = y;
3886: function d3_geo_pathBuffer() {
3887: var pointCircle = d3_geo_pathBufferCircle(4.5), buffer = [];
3902: pointCircle = d3_geo_pathBufferCircle(_);
3934: var d3_geo_pathCentroid = {
3935: point: d3_geo_pathCentroidPoint,
3936: lineStart: d3_geo_pathCentroidLineStart,
3937: lineEnd: d3_geo_pathCentroidLineEnd,
3939: d3_geo_pathCentroid.lineStart = d3_geo_pathCentroidRingStart;
3942: d3_geo_pathCentroid.point = d3_geo_pathCentroidPoint;
3943: d3_geo_pathCentroid.lineStart = d3_geo_pathCentroidLineStart;
3944: d3_geo_pathCentroid.lineEnd = d3_geo_pathCentroidLineEnd;
3952: function d3_geo_pathCentroidLineStart() {
3954: d3_geo_pathCentroid.point = function(x, y) {
3955: d3_geo_pathCentroid.point = nextPoint;
3956: d3_geo_pathCentroidPoint(x0 = x, y0 = y);
3963: d3_geo_pathCentroidPoint(x0 = x, y0 = y);
3967: d3_geo_pathCentroid.point = d3_geo_pathCentroidPoint;
3969: function d3_geo_pathCentroidRingStart() {
3971: d3_geo_pathCentroid.point = function(x, y) {
3972: d3_geo_pathCentroid.point = nextPoint;
3973: d3_geo_pathCentroidPoint(x00 = x0 = x, y00 = y0 = y);
3984: d3_geo_pathCentroidPoint(x0 = x, y0 = y);
3986: d3_geo_pathCentroid.lineEnd = function() {
3990: function d3_geo_pathContext(context) {
4026: context.closePath();
4119: d3_geo_pathAreaSum = 0;
4120: d3.geo.stream(object, projectStream(d3_geo_pathArea));
4121: return d3_geo_pathAreaSum;
4125: d3.geo.stream(object, projectStream(d3_geo_pathCentroid));
4129: d3_geo_pathBoundsX1 = d3_geo_pathBoundsY1 = -(d3_geo_pathBoundsX0 = d3_geo_pathBoundsY0 = Infinity);
4130: d3.geo.stream(object, projectStream(d3_geo_pathBounds));
4131: return [ [ d3_geo_pathBoundsX0, d3_geo_pathBoundsY0 ], [ d3_geo_pathBoundsX1, d3_geo_pathBoundsY1 ] ];
4135: projectStream = (projection = _) ? _.stream \|\| d3_geo_pathProjectStream(_) : d3_identity;
4140: contextStream = (context = _) == null ? new d3_geo_pathBuffer() : new d3_geo_pathContext(_);
5933: var paths = [], i = -1, n = links.length;
5934: while (++i < n) paths.push(d3_layout_bundlePath(links[i]));
5935: return paths;
8655: pathUpdate.attr("d", "M" + range[0] + "," + sign * outerTickSize + "V0H" + range[1] + "V" + sign * outer...(10 bytes skipped)...
8659: pathUpdate.attr("d", "M" + sign * outerTickSize + "," + range[0] + "H0V" + range[1] + "H" + sign * outer...(10 bytes skipped)...

github.com/apache/netbeans:enterprise/javaee.wildfly/src/org/netbeans/modules/javaee/wildfly/ide/commands/Constants.java: [ master, ]
300: public static final String PATH = "path";// NOI18N
227: public static final String JAXRS_RESOURCE_PATH = "resource-path";// NOI18N
366: public static final String RESOLVE_PATH = "resolve-path";// NOI18N
374: public static final String RESULT_PATH = "result-path";// NOI18N

github.com/git/git-scm.com:vendor/assets/javascripts/session.min.js: [ master, ]
8: ...(4305 bytes skipped)...e==null){e={visits:1,start:(new Date).getTime(),last_visit:(new Date).getTime(),url:a.location.href,path:a.location.path...(2214 bytes skipped)....length,h;for(;f<g;f++)h=e[f].split("="),h.length===2&&(d[h[0]]=decodeURI(h[1]))}return{host:c.host,path:c.path...(269 bytes skipped)...),"=",encodeURIComponent(String(d)),f.expires?"; expires="+(new Date(f.expires)).toUTCString():"",f.path?"; path="+f.path:"",f.domain?"; domain="+f.domain:"",a.location&&a.location.protocol==="https:"?"; secure":""].join(...(966 bytes skipped)...

github.com/git/git-scm.com:vendor/assets/javascripts/session.min.js: [ master, ]

8: ...(4305 bytes skipped)...e==null){e={visits:1,start:(new Date).getTime(),last_visit:(new Date).getTime(),url:a.location.href,path:a.location.path...(2214 bytes skipped)....length,h;for(;f<g;f++)h=e[f].split("="),h.length===2&&(d[h[0]]=decodeURI(h[1]))}return{host:c.host,path:c.path...(269 bytes skipped)...),"=",encodeURIComponent(String(d)),f.expires?"; expires="+(new Date(f.expires)).toUTCString():"",f.path?"; path="+f.path:"",f.domain?"; domain="+f.domain:"",a.location&&a.location.protocol==="https:"?"; secure":""].join(...(966 bytes skipped)...

github.com/apache/curator:curator-recipes/src/main/java/org/apache/curator/framework/recipes/cache/TreeCache.java: [ master, ]
86: private final String path;
230: final String path;
67: * <p>A utility that attempts to keep all data from all children of a ZK path locally cached. This class
68: * will watch the ZK path, respond to update/create/delete events, pull down the data, etc. You can
95: private Builder(CuratorFramework client, String path) {
97: this.path = validatePath(path);
110: path,
163: * By default, TreeCache does not auto-create parent nodes for the cached path. Change
175: ...(6 bytes skipped)... * By default, TreeCache creates {@link org.apache.zookeeper.ZooKeeper} watches for every created path.
198: * Create a TreeCache builder for the given client and path to configure advanced options.
201: * the namespace, including all published events. The given path is the root at which the
202: * TreeCache will watch and explore. If no node exists at the given path, the TreeCache will
206: * @param path the path to the root node to watch/explore; this path need not actually exist on
210: public static Builder newBuilder(CuratorFramework client, String path) {
211: return new Builder(client, path);
234: TreeNode(String path, TreeNode parent) {
235: this.path = path;
241: if ((depth < maxDepth) && selector.traverseChildren(path)) {
251: if ((depth < maxDepth) && selector.traverseChildren(path)) {
264: maybeWatch(client.getChildren()).forPath(path);
271: maybeWatch(client.getData().decompressed()).forPath(path);
273: maybeWatch(client.getData()).forPath(path);
325: maybeWatch(client.checkExists()).forPath(path);
330: parentChildMap.remove(ZKPaths.getNodeFromPath(path), this);
400: if (!childMap.containsKey(child) && selector.acceptChild(ZKPaths.makePath(path, child))) {
407: String fullPath = ZKPaths.makePath(path, child);
501: * Create a TreeCache for the given client and path with default options.
504: * the namespace, including all published events. The given path is the root at which the
505: * TreeCache will watch and explore. If no node exists at the given path, the TreeCache will
509: * @param path the path to the root node to watch/explore; this path need not actually exist on
513: public TreeCache(CuratorFramework client, String path) {
516: path,
528: * @param path path to watch
530: * @param dataIsCompressed if true, data in the path is compressed
538: String path,
548: this.root = new TreeNode(validatePath(path), null);
567: client.createContainers(root.path);
616: LinkedList<String> rootElements = new LinkedList<String>(ZKPaths.split(root.path));
620: // Target path shorter than root path
626: // Initial root path does not match
647: * Return the current set of children at the given path, mapped by child name. There are no
649: * node at this path, {@code null} is returned.
651: * @param fullPath full path to the node to check
680: * Return the current data for the given path. There are no guarantees of accuracy. This is
681: * merely the most recent view of the data. If there is no node at the given path,
684: * @param fullPath full path to the node to check
23: import static org.apache.curator.utils.PathUtils.validatePath;
49: import org.apache.curator.framework.api.Pathable;
56: import org.apache.curator.utils.PathUtils;
154: * root node and its immediate children (kind of like {@link PathChildrenCache}.
278: private <T, P extends Watchable<BackgroundPathable<T>> & BackgroundPathable<T>> Pathable<T> maybeWatch(
382: new ChildData(oldChildData.getPath(), newStat, oldChildData.getData()));
408: TreeNode node = new TreeNode(fullPath, this);
419: String eventPath = event.getPath();
420: ChildData toPublish = new ChildData(eventPath, newStat, event.getData());
421: ChildData toUpdate = cacheData ? toPublish : new ChildData(eventPath, newStat, null);
614: private TreeNode find(String findPath) {
615: PathUtils.validatePath(findPath);
617: LinkedList<String> findElements = new LinkedList<String>(ZKPaths.split(findPath));
654: public Map<String, ChildData> getCurrentChildren(String fullPath) {
655: TreeNode node = find(fullPath);
687: public ChildData getCurrentData(String fullPath) {
688: TreeNode node = find(fullPath);
47: import org.apache.curator.framework.api.BackgroundPathable;
58: import org.apache.curator.utils.ZKPaths;

github.com/apache/pdfbox:pdfbox/src/main/java/org/apache/pdfbox/cos/COSName.java: [ trunk, ]
461: public static final COSName PATH = new COSName("Path");

github.com/googlearchive/caja:third_party/java/htmlparser/src/nu/validator/htmlparser/impl/AttributeName.java: [ master, ]
722: public static final AttributeName PATH = new AttributeName(ALL_NO_NS, SAME_LOCAL("path"), ALL_NO_PREFIX, ALL_NCNAME, false);
934: public static final AttributeName CLIP_PATH = new AttributeName(ALL_NO_NS, SAME_LOCAL("clip-path"), ALL_NO_PREFIX, ALL_NCNAME, false);
1005: public static final AttributeName PATHLENGTH = new AttributeName(ALL_NO_NS, SVG_DIFFERENT("pathlength", "pathLength"), ALL_NO_PREFIX, ALL_NCNAME, false);
1120: public static final AttributeName CLIPPATHUNITS = new AttributeName(ALL_NO_NS, SVG_DIFFERENT("clippathunits", "clipPathUnits"), ALL_NO_PREFIX, ALL_NCNAME, false);
1304: PATH,
1516: CLIP_PATH,
1587: PATHLENGTH,
1702: CLIPPATHUNITS,

github.com/apache/zeppelin:zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/Note.java: [ master, ]
150: private String path;
187: public String getPath() {
191: public String getParentPath() {
257: public void setPath(String path) {
78: // serialize Paragraph#runtimeInfos and Note#path to frontend but not to note file
99: if(field.getName().equals("path")) {
147: // The front end needs to judge TRASH_FOLDER according to the path,
171: public Note(String path, String defaultInterpreterGroup, InterpreterFactory factory,
174: setPath(path);
188: return path;
192: int pos = path.lastIndexOf('/');
196: return path.substring(0, pos);
200: private String getName(String path) {
201: int pos = path.lastIndexOf('/');
202: return path.substring(pos + 1);
258: if (!path.startsWith("/")) {
259: this.path = "/" + path;
261: this.path = path;
263: this.name = getName(path);
300: // for the notes before 0.9, get path from name.
301: if (this.path == null) {
303: this.path = name;
305: this.path = "/" + name;
308: int pos = this.path.lastIndexOf('/');
309: this.path = this.path.substring(0, pos + 1) + this.name;
340: if (this.path.startsWith(folder)) {
849: return this.path.startsWith("/" + NoteManager.TRASH_FOLDER);
1076: if (this.path != null) {
1077: return this.path;
1151: //TODO(zjffdu) exclude path because FolderView.index use Note as key and consider different path
1153: // if (path != null ? !path.equals(note.path) : note.path != null) return false;
1171: // result = 31 * result + (path != null ? path.hashCode() : 0);

github.com/google/filament:third_party/draco/javascript/draco_wasm_wrapper.js: [ master, ]
15: LOGNAME:"web_user",PATH:"/",PWD:"/",HOME:"/home/web_user",LANG:("object"===typeof navigator&&navigator.languages&&navigator...(384 bytes skipped)...
21: ...(228 bytes skipped)...;var M="",pa,qa;if(oa){M=__dirname+"/";var ra=function(a,c){pa\|\|(pa=require("fs"));qa\|\|(qa=require("path"));a=qa.normalize(a);return pa.readFileSync(a,c?null:"utf8")};var la=function(a){a=ra(a,!0);a.buffe...(70 bytes skipped)...

github.com/google/filament:third_party/draco/javascript/draco_wasm_wrapper.js: [ master, ]

15: LOGNAME:"web_user",PATH:"/",PWD:"/",HOME:"/home/web_user",LANG:("object"===typeof navigator&&navigator.languages&&navigator...(384 bytes skipped)...

21: ...(228 bytes skipped)...;var M="",pa,qa;if(oa){M=__dirname+"/";var ra=function(a,c){pa||(pa=require("fs"));qa||(qa=require("path"));a=qa.normalize(a);return pa.readFileSync(a,c?null:"utf8")};var la=function(a){a=ra(a,!0);a.buffe...(70 bytes skipped)...

github.com/apache/tinkerpop:gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.java: [ master, ]
670: public default GraphTraversal<S, Path> path() {
3384: public static final String path = "path";
2186: public default GraphTraversal<S, E> simplePath() {
2198: public default GraphTraversal<S, E> cyclicPath() {
2945: public default GraphTraversal<S, Path> shortestPath() {
3431: public static final String simplePath = "simplePath";
3432: public static final String cyclicPath = "cyclicPath";
3465: public static final String shortestPath = "shortestPath";
32: import org.apache.tinkerpop.gremlin.process.traversal.Path;
505: * Map the {@link Edge} to the incident vertex that was not just traversed from in the path history.
664: * Map the {@link Traverser} to its {@link Path} history via {@link Traverser#path}.
667: * @see <a href="http://tinkerpop.apache.org/docs/${project.version}/reference/#path-step" target="_blank">Reference Documentation - Path Step</a>
671: this.asAdmin().getBytecode().addStep(Symbols.path);
744: ...(2 bytes skipped)... * Map the {@link Traverser} to a {@link Map} projection of sideEffect values, map values, and/or path values.
746: * @param pop if there are multiple objects referenced in the path, the {@link Pop} to use.
765: ...(2 bytes skipped)... * Map the {@link Traverser} to a {@link Map} projection of sideEffect values, map values, and/or path values.
1525: * Filters the current object based on the object itself or the path history.
1541: * Filters the current object based on the object itself or the path history.
1556: * Filters the current object based on the object itself or the path history.
2180: * Filter the <code>E</code> object if its {@link Traverser#path} is not {@link Path#isSimple}.
2192: * Filter the <code>E</code> object if its {@link Traverser#path} is {@link Path#isSimple}.
2940: * Executes a Shortest Path algorithm over the graph.
2953: return (GraphTraversal<S, Path>) ((Traversal.Admin) this.asAdmin())
69: import org.apache.tinkerpop.gremlin.process.traversal.step.filter.PathFilterStep;
115: import org.apache.tinkerpop.gremlin.process.traversal.step.map.PathStep;
666: * @return the traversal with an appended {@link PathStep}.
672: return this.asAdmin().addStep(new PathStep<>(this.asAdmin()));
1046: * Aggregates the emanating paths into a {@link Tree} data structure.
2182: * @return the traversal with an appended {@link PathFilterStep}.
2183: * @see <a href="http://tinkerpop.apache.org/docs/${project.version}/reference/#simplepath-step" target="_blank">Reference Documentation - SimplePath Step</a>
2187: this.asAdmin().getBytecode().addStep(Symbols.simplePath);
2188: return this.asAdmin().addStep(new PathFilterStep<E>(this.asAdmin(), true));
2194: * @return the traversal with an appended {@link PathFilterStep}.
2195: * @see <a href="http://tinkerpop.apache.org/docs/${project.version}/reference/#cyclicpath-step" target="_blank">Reference Documentation - CyclicPath Step</a>
2199: this.asAdmin().getBytecode().addStep(Symbols.cyclicPath);
2200: return this.asAdmin().addStep(new PathFilterStep<E>(this.asAdmin(), false));
2388: * Aggregates the emanating paths into a {@link Tree} data structure.
2943: * @see <a href="http://tinkerpop.apache.org/docs/${project.version}/reference/#shortestpath-step" target="_blank">Reference Documentation - ShortestPath Step</a>
2952: this.asAdmin().getBytecode().addStep(Symbols.shortestPath);
27: import org.apache.tinkerpop.gremlin.process.computer.traversal.step.map.ShortestPathVertexProgramStep;
2942: * @return the traversal with the appended {@link ShortestPathVertexProgramStep}
2954: .addStep(new ShortestPathVertexProgramStep(this.asAdmin()));

github.com/google/filament:third_party/draco/javascript/draco_wasm_wrapper_gltf.js: [ master, ]
15: LOGNAME:"web_user",PATH:"/",PWD:"/",HOME:"/home/web_user",LANG:("object"===typeof navigator&&navigator.languages&&navigator...(384 bytes skipped)...
21: ...(228 bytes skipped)...;var M="",pa,qa;if(oa){M=__dirname+"/";var ra=function(a,c){pa\|\|(pa=require("fs"));qa\|\|(qa=require("path"));a=qa.normalize(a);return pa.readFileSync(a,c?null:"utf8")};var la=function(a){a=ra(a,!0);a.buffe...(70 bytes skipped)...

github.com/google/filament:third_party/draco/javascript/draco_wasm_wrapper_gltf.js: [ master, ]

15: LOGNAME:"web_user",PATH:"/",PWD:"/",HOME:"/home/web_user",LANG:("object"===typeof navigator&&navigator.languages&&navigator...(384 bytes skipped)...

21: ...(228 bytes skipped)...;var M="",pa,qa;if(oa){M=__dirname+"/";var ra=function(a,c){pa||(pa=require("fs"));qa||(qa=require("path"));a=qa.normalize(a);return pa.readFileSync(a,c?null:"utf8")};var la=function(a){a=ra(a,!0);a.buffe...(70 bytes skipped)...

github.com/apache/jmeter:src/protocol/http/org/apache/jmeter/protocol/http/sampler/HTTPSamplerBase.java: [ trunk, ]
156: public static final String PATH = "HTTPSampler.path"; // $NON-NLS-1$
464: public void setPath(String path) {
479: public void setPath(String path, String contentEncoding) {
497: public String getPath() {
367: * i.e. there is a single file entry which has a non-empty path and
433: log.warn("File {} is invalid as no path is defined", httpFileArg);
458: * Sets the Path attribute of the UrlConfig object Also calls parseArguments
461: * @param path
462: * The new Path value
466: setPath(path, EncoderCache.URL_ARGUMENT_ENCODING);
470: * Sets the PATH property; if the request is a GET or DELETE (and the path
474: * @param path
475: * The new Path value
480: boolean fullUrl = path.startsWith(HTTP_PREFIX) \|\| path.startsWith(HTTPS_PREFIX);
484: int index = path.indexOf(QRY_PFX);
486: setProperty(PATH, path.substring(0, index));
488: parseArguments(path.substring(index + 1), contentEncoding);
490: setProperty(PATH, path);
493: setProperty(PATH, path);
498: String p = getPropertyAsString(PATH);
1006: * As a special case, if the path starts with "http[s]://",
1007: * then the path is assumed to be the entire URL.
1014: String path = this.getPath();
1016: if (path.startsWith(HTTP_PREFIX)
1017: \|\| path.startsWith(HTTPS_PREFIX)) {
1018: return new URL(path);
1028: if (!path.startsWith("/")) { // $NON-NLS-1$
1032: pathAndQuery.append(path);
1043: if (path.contains(QRY_PFX)) {// Already contains a prefix
1500: protected String encodeSpaces(String path) {
1501: return JOrphanUtils.replaceAllChars(path, ' ', "%20"); // $NON-NLS-1$
1929: * Version 2.3.3 introduced a list of files, each with their own path, name and mimetype.
2090: * Replace by replaceBy in path and body (arguments) properties
301: / Whether to remove '/path*segment/..' from redirects; default true /
375: && (files[0].getPath().length() > 0)
432: if(StringUtils.isEmpty(httpFileArg.getPath())) {
1023: StringBuilder pathAndQuery = new StringBuilder(100);
1029: pathAndQuery.append('/'); // $NON-NLS-1$
1044: pathAndQuery.append(QRY_SEP);
1046: pathAndQuery.append(QRY_PFX);
1048: pathAndQuery.append(queryString);
1053: return new URL(protocol, domain, pathAndQuery.toString());
1055: return new URL(protocol, domain, getPort(), pathAndQuery.toString());
2100: totalReplaced += JOrphanUtils.replaceValue(regex, replaceBy, caseSensitive, getPath(), this::setPath);

github.com/google/ion:third_party/icu/icu4j/main/classes/core/src/com/ibm/icu/impl/number/Parse.java: [ master, ]
245: String path;
33: * the grouping separator. Since the second option has a longer parse path (consumes more of the
192: * Holds a snapshot in time of a single parse path. This includes the digits seen so far, the
193: * current state name, and other properties like the grouping separator used on this parse path,
243: // Identification for path tracing:
295: // Identification for path tracing:
297: path = "";
358: path = other.path + other.id;
485: sb.append(path);
2055: * // Add parse path going to firstOffsetOrTag
2058: * // Add parse path leaving the string
30: * <p>The parser may traverse multiple parse paths in the same strings if there is ambiguity. For
82: * <li>Instead of traversing multiple possible parse paths, a "greedy" parsing strategy is
200: // The "score" is used to help rank two otherwise equivalent parse paths. Currently, the only
929: * string or when there are no possible parse paths remaining in the string.
1244: // No parse paths continue past this point. We have found the longest parsable string
2048: * paths.
2051: * nextOffsetOrTag. These two arguments should add parse paths according to the following rules:
2062: * <p>Note that there may be multiple parse paths added by these lines. This is important in order

github.com/googlearchive/caja:third_party/java/htmlparser/src/nu/validator/htmlparser/impl/ElementName.java: [ master, ]
492: public static final ElementName PATH = new ElementName("path", "path", TreeBuilder.OTHER, false, false, false);
527: public static final ElementName MPATH = new ElementName("mpath", "mpath", TreeBuilder.OTHER, false, false, false);
653: public static final ElementName CLIPPATH = new ElementName("clippath", "clipPath", TreeBuilder.OTHER, false, false, false);
681: public static final ElementName TEXTPATH = new ElementName("textpath", "textPath", TreeBuilder.OTHER, false, false, false);
884: PATH,
919: MPATH,
1045: CLIPPATH,
1073: TEXTPATH,

github.com/apache/cloudstack:api/src/main/java/org/apache/cloudstack/api/ApiConstants.java: [ master, ]
277: public static final String PATH = "path";
66: public static final String DATASTORE_PATH = "datastorepath";
136: public static final String DOMAIN_PATH = "domainpath";
192: public static final String IMAGE_PATH = "imagepath";
718: public static final String HEALTHCHECK_PINGPATH = "pingpath";

github.com/apache/cloudstack:plugins/hypervisors/kvm/src/main/java/com/cloud/hypervisor/kvm/resource/LibvirtVMDef.java: [ master, ]
1621: private File path = new File("");
1891: private String path = "/dev/random";
107: public static final String GUEST_NVRAM_PATH = "guest.nvram.path";
501: public void setEmulatorPath(String emulator) {
657: private String _sourcePath;
892: public String getDiskPath() {
908: public void setDiskPath(String volPath) {
1143: private String _scriptPath;
1152: private String _dpdkSourcePath;
1314: public String getDpdkOvsPath() {
1318: public void setDpdkOvsPath(String path) {
1399: private final String _ttyPath;
1661: public File getPath() {
1815: private final String _sourcePath;
1816: private final String _targetPath;
1932: public String getPath() {
1319: _dpdkSourcePath = path;
1339: netBuilder.append("<source type='unix' path='"+ _dpdkSourcePath + _dpdkSourcePort +
1358: netBuilder.append("<script path='" + _scriptPath + "'/>\n");
1404: public ConsoleDef(String type, String path, String source, short port) {
1406: _ttyPath = path;
1421: consoleBuilder.append("<source path='" + _source + "'/>\n");
1559: serialBuidler.append("<source path='" + _source + "'/>\n");
1630: public ChannelDef(String name, ChannelType type, File path) {
1632: this.path = path;
1642: public ChannelDef(String name, ChannelType type, ChannelState state, File path) {
1644: this.path = path;
1662: return path;
1669: if (path == null) {
1672: virtioSerialBuilder.append("<source mode='bind' path='" + path.toString() + "'/>\n");
1897: public RngDef(String path) {
1898: this.path = path;
1901: public RngDef(String path, int rngRateBytes, int rngRatePeriod) {
1902: this.path = path;
1915: public RngDef(String path, RngBackendModel rngBackendModel) {
1916: this.path = path;
1920: public RngDef(String path, RngBackendModel rngBackendModel, int rngRateBytes, int rngRatePeriod) {
1921: this.path = path;
1927: public RngDef(String path, RngModel rngModel) {
1928: this.path = path;
1933: return path;
1957: rngBuilder.append("<backend model='" + rngBackendModel + "'>" + path + "</backend>");
697: public void defFileBasedDisk(String filePath, String diskLabel, DiskBus bus, DiskFmtType diskFmtType) {
701: _sourcePath = filePath;
746: public void defFileBasedDisk(String filePath, int devId, DiskBus bus, DiskFmtType diskFmtType) {
751: _sourcePath = filePath;
758: public void defFileBasedDisk(String filePath, int devId, DiskFmtType diskFmtType,boolean isWindowsOS) {
763: _sourcePath = filePath;
775: public void defISODisk(String volPath) {
778: _sourcePath = volPath;
785: public void defISODisk(String volPath, boolean isUefiEnabled) {
788: _sourcePath = volPath;
795: public void defISODisk(String volPath, Integer devId) {
797: defISODisk(volPath);
801: _sourcePath = volPath;
809: public void defISODisk(String volPath, Integer devId,boolean isSecure) {
811: defISODisk(volPath, devId);
815: _sourcePath = volPath;
829: _sourcePath = diskName;
839: _sourcePath = diskName;
850: _sourcePath = diskName;
866: _sourcePath = diskName;
893: return _sourcePath;
909: _sourcePath = volPath;
1012: if (_sourcePath != null) {
1013: diskBuilder.append("file='" + _sourcePath + "'");
1020: if (_sourcePath != null) {
1021: diskBuilder.append(" dev='" + _sourcePath + "'");
1027: diskBuilder.append(" name='" + _sourcePath + "'");
1170: public void defDpdkNet(String dpdkSourcePath, String dpdkPort, String macAddress, NicModel model,
1173: _dpdkSourcePath = dpdkSourcePath;
1209: public void defEthernet(String targetName, String macAddr, NicModel model, String scriptPath) {
1210: defEthernet(targetName, macAddr, model, scriptPath, 0);
1213: public void defEthernet(String targetName, String macAddr, NicModel model, String scriptPath, Integer networkRateKBps) {
1219: _scriptPath = scriptPath;
1315: return _dpdkSourcePath;
1357: if (_scriptPath != null) {
1416: if (_ttyPath != null) {
1417: consoleBuilder.append("tty='" + _ttyPath + "'");
1818: public FilesystemDef(String sourcePath, String targetPath) {
1819: _sourcePath = sourcePath;
1820: _targetPath = targetPath;
1827: fsBuilder.append(" <source dir='" + _sourcePath + "'/>\n");
1828: fsBuilder.append(" <target dir='" + _targetPath + "'/>\n");

github.com/apache/jena:jena-arq/src/main/java/org/apache/jena/sparql/lang/arq/ARQParser.java: [ master, ]
3483: final public Path Path() throws ParseException {Path p ;
3284: final public void TriplesSameSubjectPath(TripleCollector acc) throws ParseException {Node s ;
3329: final public void PropertyListPath(Node s, TripleCollector acc) throws ParseException {
3438: final public Path VerbPath() throws ParseException {Node p ; Path path ;
3450: final public void ObjectListPath(Node s, Node p, Path path, TripleCollector acc) throws ParseException {Node o ;
3468: final public void ObjectPath(Node s, Node p, Path path, TripleCollector acc) throws ParseException {Node o ;
3475: final public Path PathUnit() throws ParseException {Path p ;
3489: final public Path PathAlternative() throws ParseException {Path p1 , p2 ;
3510: final public Path PathSequence() throws ParseException {Path p1 , p2 ;
3547: final public Path PathElt() throws ParseException {String str ; Node n ; Path p ;
3565: final public Path PathEltOrInverse() throws ParseException {String str ; Node n ; Path p ;
3594: final public Path PathMod(Path p) throws ParseException {long i1 ; long i2 ;
3684: final public Path PathPrimary() throws ParseException {String str ; Path p ; Node n ;
3742: final public Path PathNegatedPropertySet() throws ParseException {P_Path0 p ; P_NegPropSet pNegSet ;
3797: final public P_Path0 PathOneInPropertySet() throws ParseException {String str ; Node n ;
3876: final public Node TriplesNodePath(TripleCollectorMark acc) throws ParseException {Node n ;
3896: final public Node BlankNodePropertyListPath(TripleCollector acc) throws ParseException {Token t ;
3961: final public Node CollectionPath(TripleCollectorMark acc) throws ParseException {Node listHead = nRDFnil ; Node lastCell = null ; in...(27 bytes skipped)...
4017: final public void AnnotationPath(TripleCollector acc, Node s, Node p, Path path, Node o) throws ParseException {
4093: final public Node GraphNodePath(TripleCollectorMark acc) throws ParseException {Node n ;
3352: final public void PropertyListPathNotEmpty(Node s, TripleCollector acc) throws ParseException {Path path = null ; Node p = null ;
9: import org.apache.jena.sparql.path.* ;
3259: final public void ObjectList(Node s, Node p, Path path, TripleCollector acc) throws ParseException {Node o ;
3260: Object(s, p, path, acc);
3273: Object(s, p, path, acc);
3277: final public void Object(Node s, Node p, Path path, TripleCollector acc) throws ParseException {Node o ;
3280: insert(tempAcc, mark, s, p, path, o) ; insert(acc, tempAcc) ;
3281: Annotation(acc, s, p, path, o);
3364: path = VerbPath();
3377: ObjectListPath(s, p, path, acc);
3390: path = null ; p = null ;
3415: path = VerbPath();
3428: ObjectListPath(s, p, path, acc);
3439: path = Path();
3440: {if ("" != null) return path ;}
3451: ObjectPath(s, p, path, acc);
3464: ObjectPath(s, p, path, acc);
3471: insert(tempAcc, mark, s, p, path, o) ; insert(acc, tempAcc) ;
3472: AnnotationPath(acc, s, p, path, o);
3477: p = Path();
3705: p = Path();
3712: p = Path();
3720: p = Path();
3728: p = Path();
4021: Node pAnn = preConditionAnnotation(s, p, path, o, token.beginLine, token.beginColumn) ;
4033: final public void Annotation(TripleCollector acc, Node s, Node p, Path path, Node o) throws ParseException {
4037: Node pAnn = preConditionAnnotation(s, p, path, o, token.beginLine, token.beginColumn) ;
2450: TriplesSameSubjectPath(acc);
3317: s = TriplesNodePath(tempAcc);
3318: PropertyListPath(s, tempAcc);
3470: o = GraphNodePath(tempAcc);
3484: p = PathAlternative();
3490: p1 = PathSequence();
3503: p2 = PathSequence();
3504: p1 = PathFactory.pathAlt(p1, p2) ;
3511: p1 = PathEltOrInverse();
3527: p2 = PathEltOrInverse();
3528: p1 = PathFactory.pathSeq(p1, p2) ;
3533: p2 = PathElt();
3534: p1 = PathFactory.pathSeq(p1, new P_Inverse(p2)) ;
3548: p = PathPrimary();
3554: p = PathMod(p);
3576: p = PathElt();
3581: p = PathElt();
3582: p = PathFactory.pathInverse(p) ;
3598: {if ("" != null) return PathFactory.pathZeroOrOne(p) ;}
3603: {if ("" != null) return PathFactory.pathZeroOrMore1(p) ;}
3608: {if ("" != null) return PathFactory.pathOneOrMore1(p) ;}
3617: {if ("" != null) return PathFactory.pathZeroOrMoreN(p) ;}
3623: {if ("" != null) return PathFactory.pathOneOrMoreN(p) ;}
3634: {if ("" != null) return PathFactory.pathMod(p, i1, PathFactory.UNSET) ;}
3640: {if ("" != null) return PathFactory.pathMod(p, i1, i2) ;}
3652: {if ("" != null) return PathFactory.pathFixedLength(p, i1) ;}
3666: {if ("" != null) return PathFactory.pathMod(p, PathFactory.UNSET, i2) ;}
3690: n = createNode(str) ; p = PathFactory.pathLink(n) ;
3695: p = PathFactory.pathLink(nRDFtype) ;
3700: p = PathNegatedPropertySet();
3713: p = PathFactory.pathDistinct(p) ;
3721: p = PathFactory.pathShortest(p) ;
3729: p = PathFactory.pathMulti(p) ;
3750: p = PathOneInPropertySet();
3762: p = PathOneInPropertySet();
3776: p = PathOneInPropertySet();
3879: n = CollectionPath(acc);
3884: n = BlankNodePropertyListPath(acc);
3972: n = GraphNodePath(acc);
4125: n = TriplesNodePath(acc);
2447: final public Element TriplesBlock(ElementPathBlock acc) throws ParseException {
2449: acc = new ElementPathBlock() ;
3172: ElementPathBlock tempAcc = new ElementPathBlock() ;
3278: ElementPathBlock tempAcc = new ElementPathBlock() ; int mark = tempAcc.mark() ;
3311: PropertyListPathNotEmpty(s, acc);
3316: ElementPathBlock tempAcc = new ElementPathBlock() ;
3343: PropertyListPathNotEmpty(s, acc);
3469: ElementPathBlock tempAcc = new ElementPathBlock() ; int mark = tempAcc.mark() ;
3899: PropertyListPathNotEmpty(n, acc);
4023: PropertyListPathNotEmpty(x, acc);

github.com/kythe/kythe:third_party/bazel/src/main/java/com/google/devtools/build/lib/buildeventstream/proto/build_event_stream.proto: [ master, ]
1136: string path = 1;
474: repeated string path_prefix = 4;
469: // A sequence of prefixes to apply to the file name to construct a full path.
520: // (e.g., a file path).
524: // (e.g., a file path).
735: // Path to logs of passed runs.
738: // Path to logs of failed runs;
1118: // The message that contains what type of action to perform on a given path and
1132: // The path of the symlink to be created or deleted, absolute or relative to
1141: // If action is CREATE, this is the target path that the symlink should point
1142: // to. If the path points underneath the output base, it is relative to the
539: // List of paths to log files

github.com/apache/netbeans:websvccommon/websvc.saas.codegen/src/org/netbeans/modules/websvc/saas/codegen/Constants.java: [ master, ]
103: public static final String PATH = REST_API_PACKAGE + PATH_ANNOTATION;
61: public static final String PATH_PARAMS = "pathParams"; // NOI18n
77: public static final String PATH_ANNOTATION = "Path"; //NOI18N
79: public static final String URI_PARAM_ANNOTATION = "PathParam"; //NOI18N

github.com/apache/jena:jena-shacl/src/main/java/org/apache/jena/shacl/vocabulary/SHACL.java: [ master, ]
262: public static final Node path = createProperty( "http://www.w3.org/ns/shacl#path" );
45: public static final Node alternativePath = createProperty( "http://www.w3.org/ns/shacl#alternativePath" );
154: public static final Node inversePath = createProperty( "http://www.w3.org/ns/shacl#inversePath" );
243: public static final Node oneOrMorePath = createProperty( "http://www.w3.org/ns/shacl#oneOrMorePath" );
315: public static final Node resultPath = createProperty( "http://www.w3.org/ns/shacl#resultPath" );
410: public static final Node zeroOrMorePath = createProperty( "http://www.w3.org/ns/shacl#zeroOrMorePath" );
415: public static final Node zeroOrOnePath = createProperty( "http://www.w3.org/ns/shacl#zeroOrOnePath" );
42: / <p>The (single) value of this property must be a list of path** elements, representing
139: * those explicitly enumerated via sh:property/sh:path.</p>
151: / <p>The (single) value of this property represents an inverse path** (object to
240: / <p>The (single) value of this property represents a path** that is matched one
261: / <p>Specifies the property path** of a property shape.</p> */
312: / <p>The path of a validation result, based on the path** of the validated property
407: / <p>The (single) value of this property represents a path** that is matched zero
412: / <p>The (single) value of this property represents a path** that is matched zero
445: * via sh:property/sh:path.</p>
669: / <p>The class of parameter declarations, consisting of a path** predicate and (possibly)
702: * focus node for a given property or path.</p>
43: * the elements of alternative paths.</p>

github.com/firebase/firebase-android-sdk:firebase-database/src/main/java/com/google/firebase/database/connection/PersistentConnectionImpl.java: [ master, ]
45: private final List<String> path;
186: private final List<String> path;
227: private static final String REQUEST_PATH = "p";
264: private static final String SERVER_DATA_UPDATE_PATH = "p";
266: private static final String SERVER_DATA_START_PATH = "s";
267: private static final String SERVER_DATA_END_PATH = "e";
202: public List<String> getPath() {
234: private static final String REQUEST_COMPOUND_HASH_PATHS = "ps";
48: public QuerySpec(List<String> path, Map<String, Object> queryParams) {
49: this.path = path;
62: if (!path.equals(that.path)) {
70: int result = path.hashCode();
77: return ConnectionUtils.pathToString(this.path) + " (params: " + queryParams + ")";
191: String action, List<String> path, Object data, RequestResultCallback onComplete) {
193: this.path = path;
203: return path;
381: List<String> path,
386: QuerySpec query = new QuerySpec(path, queryParams);
404: public Task<Object> get(List<String> path, Map<String, Object> queryParams) {
405: QuerySpec query = new QuerySpec(path, queryParams);
411: request.put(REQUEST_PATH, ConnectionUtils.pathToString(query.path));
447: public void put(List<String> path, Object data, RequestResultCallback onComplete) {
448: putInternal(REQUEST_ACTION_PUT, path, data, /hash=/ null, onComplete);
453: List<String> path, Object data, String hash, RequestResultCallback onComplete) {
454: putInternal(REQUEST_ACTION_PUT, path, data, hash, onComplete);
458: public void merge(List<String> path, Map<String, Object> data, RequestResultCallback onComplete) {
459: putInternal(REQUEST_ACTION_MERGE, path, data, /hash=/ null, onComplete);
557: public void unlisten(List<String> path, Map<String, Object> queryParams) {
558: QuerySpec query = new QuerySpec(path, queryParams);
577: public void onDisconnectPut(List<String> path, Object data, RequestResultCallback onComplete) {
580: sendOnDisconnect(REQUEST_ACTION_ONDISCONNECT_PUT, path, data, onComplete);
583: new OutstandingDisconnect(REQUEST_ACTION_ONDISCONNECT_PUT, path, data, onComplete));
598: List<String> path, Map<String, Object> updates, final RequestResultCallback onComplete) {
601: sendOnDisconnect(REQUEST_ACTION_ONDISCONNECT_MERGE, path, updates, onComplete);
604: new OutstandingDisconnect(REQUEST_ACTION_ONDISCONNECT_MERGE, path, updates, onComplete));
610: public void onDisconnectCancel(List<String> path, RequestResultCallback onComplete) {
615: sendOnDisconnect(REQUEST_ACTION_ONDISCONNECT_CANCEL, path, null, onComplete);
618: new OutstandingDisconnect(REQUEST_ACTION_ONDISCONNECT_CANCEL, path, null, onComplete));
837: String action, List<String> path, Object data, final RequestResultCallback onComplete) {
839: request.put(REQUEST_PATH, ConnectionUtils.pathToString(path));
885: request.put(REQUEST_PATH, ConnectionUtils.pathToString(listen.query.path));
911: private Collection<OutstandingListen> removeListens(List<String> path) {
912: if (logger.logsDebug()) logger.debug("removing all listens at path " + path);
917: if (query.path.equals(path)) {
936: String pathString = (String) body.get(SERVER_DATA_UPDATE_PATH);
941: if (logger.logsDebug()) logger.debug("ignoring empty merge for path " + pathString);
943: List<String> path = ConnectionUtils.stringToPath(pathString);
944: delegate.onDataUpdate(path, payloadData, isMerge, tagNumber);
947: String pathString = (String) body.get(SERVER_DATA_UPDATE_PATH);
948: List<String> path = ConnectionUtils.stringToPath(pathString);
955: String startString = (String) range.get(SERVER_DATA_START_PATH);
956: String endString = (String) range.get(SERVER_DATA_END_PATH);
963: if (logger.logsDebug()) logger.debug("Ignoring empty range merge for path " + pathString);
965: this.delegate.onRangeMergeUpdate(path, rangeMerges, tag);
968: String pathString = (String) body.get(SERVER_DATA_UPDATE_PATH);
969: List<String> path = ConnectionUtils.stringToPath(pathString);
970: onListenRevoked(path);
986: private void onListenRevoked(List<String> path) {
989: Collection<OutstandingListen> listens = removeListens(path);
1204: private Map<String, Object> getPutObject(List<String> path, Object data, String hash) {
1206: request.put(REQUEST_PATH, ConnectionUtils.pathToString(path));
1216: List<String> path,
1220: Map<String, Object> request = getPutObject(path, data, hash);
1302: request.put(REQUEST_PATH, ConnectionUtils.pathToString(listen.getQuery().path));
1317: for (List<String> path : compoundHash.getPosts()) {
1318: posts.add(ConnectionUtils.pathToString(path));
1395: + ConnectionUtils.pathToString(query.path)
957: List<String> start = startString != null ? ConnectionUtils.stringToPath(startString) : null;
958: List<String> end = endString != null ? ConnectionUtils.stringToPath(endString) : null;
1181: disconnect.getPath(),
1322: hash.put(REQUEST_COMPOUND_HASH_PATHS, posts);

github.com/apache/flume:flume-ng-sinks/flume-hdfs-sink/src/main/java/org/apache/flume/sink/hdfs/BucketWriter.java: [ trunk, ]
326: private final String path = bucketPath;
368: private final String path = bucketPath;
88: private volatile String filePath;
93: private volatile String bucketPath;
94: private volatile String targetPath;
104: private final String onCloseCallbackPath;
369: private final String finalPath = targetPath;
32: import org.apache.hadoop.fs.Path;
195: Path.class);
205: private Boolean isFileClosed(FileSystem fs, Path tmpFilePath) throws Exception {
255: fileSystem = new Path(bucketPath).getFileSystem(config);
262: fileSystem = new Path(bucketPath).getFileSystem(config);
348: LOG.warn("Closing file: " + path + " failed. Will " +
358: LOG.warn("Unsuccessfully attempted to close " + path + " " +
376: LOG.warn("Unsuccessfully attempted to rename " + path + " " +
382: renameBucket(path, finalPath, fs);
384: LOG.warn("Renaming file: " + path + " failed. Will " +
402: ((DistributedFileSystem) fileSystem).recoverLease(new Path(bucketPath));
585: "will not continue rolling files under this path due to " +
674: final Path srcPath = new Path(bucketPath);
675: final Path dstPath = new Path(targetPath);
120: Context context, String filePath, String fileName, String inUsePrefix,
125: String onCloseCallbackPath, long callTimeout,
129: context, filePath, fileName, inUsePrefix,
134: onCloseCallbackPath, callTimeout,
140: Context context, String filePath, String fileName, String inUsePrefix,
145: String onCloseCallbackPath, long callTimeout,
152: this.filePath = filePath;
165: this.onCloseCallbackPath = onCloseCallbackPath;
206: return (Boolean)(isClosedMethod.invoke(fs, tmpFilePath));
215: if ((filePath == null) \|\| (writer == null)) {
242: bucketPath = filePath + "/" + inUsePrefix
244: targetPath = filePath + "/" + fullFileName;
246: LOG.info("Creating " + bucketPath);
257: writer.open(bucketPath);
264: writer.open(bucketPath, codeC, compType);
287: bucketPath, rollInterval);
394: * Tries to start the lease recovery process for the current bucketPath
399: if (bucketPath != null && fileSystem instanceof DistributedFileSystem) {
401: LOG.debug("Starting lease recovery for {}", bucketPath);
404: LOG.warn("Lease recovery failed for {}", bucketPath, ex);
438: LOG.info("Closing {}", bucketPath);
443: LOG.info("HDFSWriter is already closed: {}", bucketPath);
446: // NOTE: timed rolls go through this codepath as well as other roll types
457: if (bucketPath != null && fileSystem != null) {
460: renameBucket(bucketPath, targetPath, fileSystem);
462: LOG.warn("failed to rename() file (" + bucketPath +
487: LOG.info("Closing idle bucketWriter {} at {}", bucketPath,
505: onCloseCallback.run(onCloseCallbackPath);
614: bucketPath + ") and rethrowing exception.",
657: * Rename bucketPath file from .tmp to permanent location.
668: private void renameBucket(String bucketPath, String targetPath, final FileSystem fs)
670: if (bucketPath.equals(targetPath)) {
680: if (fs.exists(srcPath)) { // could block
681: LOG.info("Renaming " + srcPath + " to " + dstPath);
683: fs.rename(srcPath, dstPath); // could block
692: return "[ " + this.getClass().getSimpleName() + " targetPath = " + targetPath +
693: ", bucketPath = " + bucketPath + " ]";
742: callTimeout + " ms" + " on file: " + bucketPath, eT);