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 &#64;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 &lt;scheme&gt;://&lt;authority&gt;&lt;absolute path&gt;?&lt;query&gt;#&lt;fragment&gt;}
1172:      * of two patterns: {@code &lt;relative or absolute path&gt;?&lt;query&gt;#&lt;fragment&gt;}
1173:      * or {@code //&lt;authority&gt;&lt;absolute path&gt;?&lt;query&gt;#&lt;fragment&gt;}
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/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/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/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 '/pathsegment/..' 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);