Found 175510 results in 15094 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()) {
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, ]
108:     private final String path;
76:     public static final String PATH_DIRECTIVE = "path";
40: public class PathEntry extends ImportOptions {
196:     public PathEntry(ManifestHeader.Entry entry, long bundleLastModified) {
290:     public String getPath() {
146:     public static @Nullable Iterator<PathEntry> getContentPaths(@NotNull final Manifest manifest, long bundleLastModified) {
158:     public static @Nullable Iterator<PathEntry> getContentPaths(final Bundle bundle) {
169:     public static @Nullable Iterator<PathEntry> getContentPaths(final Map<String, String> headers, long bundleLastModified) {
38:  * A path entry from the manifest for initial content.
73:      * The path directive specifying the target node where initial content will
107:     /** The path for the initial content. */
129:      * Target path where initial content will be loaded. If it´s null then
197:         this.path = entry.getValue();
243:         // path directive
244:         final String pathValue = entry.getDirectiveValue(PATH_DIRECTIVE);
291:         return this.path;
140:      * Parses the "Sling-Initial-Content" header from the given manifest and returns the resolved PathEntries
144:      * @return an iterator over the parsed {@code PathEntry} items or {@code null} in case no "Sling-Initial-Content" header was found in the manifest
153:      * Parses the "Sling-Initial-Content" header from the given bundle and returns the resolved PathEntries
156:      * @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)...
163:      * Parses the "Sling-Initial-Content" header from the given headers and returns the resolved PathEntries
167:      * @return an iterator over the parsed {@code PathEntry} items or {@code null} in case no "Sling-Initial-Content" header was found
170:         final List<PathEntry> entries = new ArrayList<>();
180:                 entries.add(new PathEntry(entry, bundleLastModified ));
245:         if (pathValue != null) {
246:             this.target = pathValue;
279:         if (pathValue != null) {
149:         return getContentPaths(headers, bundleLastModified);
159:         return getContentPaths(toMap(bundle.getHeaders()), bundle.getLastModified());
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/apache/sling-org-apache-sling-models-api:src/main/java/org/apache/sling/models/annotations/injectorspecific/ResourcePath.java: [ master, ]
43:     public String path() default "";
38: public @interface ResourcePath {
48:     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.
46:      * Specifies more than one path for the resource. If not provided, a single path is derived from the property name.
51:      * Specifies the name of the property containing the resource path. If empty or not set, then the name
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);
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/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
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, ]
1081:   string path = 1;
470:   repeated string path_prefix = 4;
465:   // A sequence of prefixes to apply to the file name to construct a full path.
516:   // (e.g., a file path).
520:   // (e.g., a file path).
731:   // Path to logs of passed runs.
734:   // Path to logs of failed runs;
1063: // The message that contains what type of action to perform on a given path and
1077:   // The path of the symlink to be created or deleted, absolute or relative to
1086:   // If action is CREATE, this is the target path that the symlink should point
1087:   // to. If the path points underneath the output base, it is relative to the
535:   // 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;
4874:     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) {
4891:     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());
4887:       path = null;
4892:       this.path = path;
4903:       FSImageSerialization.writeString(path, out);
4910:       this.path = FSImageSerialization.readString(in);
4917:       builder.append("SetStoragePolicyOp [path=")
4918:           .append(path)
4931:       XMLUtils.addSaxString(contentHandler, "PATH", path);
4938:       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, ]
267:         private String path;
282:         public String getPath() {
291:         public void setPath(final String path) {
372:     public static class ExcludePath {
376:         private List<String> paths = new ArrayList<>();
401:         public void setPaths(final List<String> paths) {
410:         public List<String> getPaths() {
278:          * Gets path.
280:          * @return the path
283:             return path;
287:          * Sets path.
289:          * @param path the path
292:             this.path = path;
370:      * The type Exclude path.
39:     private ExcludePath exclude = new ExcludePath();
146:     public ExcludePath getExclude() {
155:     public void setExclude(final ExcludePath exclude) {
397:          * Sets paths.
399:          * @param paths the paths
402:             this.paths = paths;
406:          * get paths.
408:          * @return paths paths
411:             return paths;
github.com/apache/incubator-shenyu:shenyu-common/src/main/java/org/apache/shenyu/common/constant/Constants.java: [ master, ]
163:     String PATH = "path";
43:     String CONTEXT_PATH = "contextPath";
218:     String PATH_SEPARATOR = "/";
339:     String FILTER_PATH = "filterPath";
464:     String SCRIPT_PATH = "/META-INF/scripts/";
183:     String SIGN_PATH_NOT_EXIST = "you have not configured the sign path.";
439:     String CONTEXT_PATH_NAME_PREFIX = "/context-path";
41:      * The constant context path.
161:      * The constant PATH.
181:      * The constant SIGN_PATH_NOT_EXIST.
437:      * context path name prefix.
462:      * redis script path.
337:      * jwt handle key for filterPath.
github.com/google/error-prone:check_api/src/main/java/com/google/errorprone/util/ASTHelpers.java: [ master, ]
1513:     public abstract TreePath path();
378:   public static <T> TreePath findPathFromEnclosingNodeToTopLevel(TreePath path, Class<T> klass) {
375:    * Given a TreePath, finds the first enclosing node of the given type and returns the path from
379:     if (path != null) {
381:         path = path.getParentPath();
382:       } while (path != null && !klass.isInstance(path.getLeaf()));
384:     return path;
392:   public static <T> T findEnclosingNode(TreePath path, Class<T> klass) {
393:     path = findPathFromEnclosingNodeToTopLevel(path, klass);
394:     return (path == null) ? null : klass.cast(path.getLeaf());
1375:    * The return value is normalized to always use '/' to separate elements of the path and to always
1387:    * normalized to always use '/' to separate elements of the path and to always have a leading '/'.
1515:     static TargetType create(Type type, TreePath path) {
1516:       return new AutoValue_ASTHelpers_TargetType(type, path);
1573:    * Returns the target type of the tree at the given {@link VisitorState}'s path, or else {@code
1767:       for (TreePath path = parent; path != null; path = path.getParentPath()) {
1768:         Tree enclosing = path.getLeaf();
93: import com.sun.source.util.TreePath;
337:         Tree parent = state.getPath().getParentPath().getLeaf();
351:       Tree parent = state.getPath().getParentPath().getLeaf();
388:    * Given a TreePath, walks up the tree until it finds a node of the given type. Returns null if no
400:     for (Tree parent : state.getPath()) {
801:                 /* @Inherited won't work if the annotation isn't on the classpath, but we can still
1104:     JCCompilationUnit compilationUnit = (JCCompilationUnit) state.getPath().getCompilationUnit();
1118:     TreePath pathToExpr = new TreePath(state.getPath(), expr);
1119:     return nullnessAnalysis.getNullness(pathToExpr, state.context);
1268:    * Returns true if the leaf node in the {@link TreePath} from {@code state} sits somewhere
1272:     for (Tree ancestor : state.getPath()) {
1287:    * Returns true if the leaf node in the {@link TreePath} from {@code state} sits somewhere
1291:     for (Tree ancestor : state.getPath()) {
1392:       return uri.getPath();
1397:       // It's possible (though it violates the zip file spec) for paths to zip file entries to use
1471:     return stream(state.getPath())
1581:     if (!canHaveTargetType(state.getPath().getLeaf())) {
1585:     TreePath parent = state.getPath();
1588:       parent = parent.getParentPath();
1639:     private final TreePath parent;
1642:     private TargetTypeVisitor(ExpressionTree current, VisitorState state, TreePath parent) {
1678:       Tree t = parent.getParentPath().getLeaf();
2239:     for (Tree ancestor : state.getPath()) {
github.com/apache/zookeeper:zookeeper-server/src/main/java/org/apache/zookeeper/server/ZooKeeperServer.java: [ master, ]
963:         String path;
221:     final Map<String, ChangeRecord> outstandingChangesForPath = new HashMap<String, ChangeRecord>();
2166:     private String parentPath(String path) throws KeeperException.BadArgumentsException {
2174:     private String effectiveACLPath(Request request) throws KeeperException.BadArgumentsException, KeeperException.InvalidACLException ...(1 bytes skipped)...
198:     private final RequestPathMetricsCollector requestPathMetricsCollector;
412:     public RequestPathMetricsCollector getRequestPathMetricsCollector() {
291:      * When a request is completed or dropped, the relevant code path calls the
560:         File path = zkDb.snapLog.getDataDir();
561:         return getDirSize(path);
569:         File path = zkDb.snapLog.getSnapDir();
570:         return getDirSize(path);
953:         ChangeRecord(long zxid, String path, StatPersisted stat, int childCount, List<ACL> acl) {
955:             this.path = path;
976:             ChangeRecord changeRecord = new ChangeRecord(zxid, path, stat, childCount,
1807:                     if (outstandingChangesForPath.get(cr.path) == cr) {
1808:                         outstandingChangesForPath.remove(cr.path);
1990:      * @param path :    the ZNode path
1993:     public void checkACL(ServerCnxn cnxn, List<ACL> acl, int perm, List<Id> ids, String path, List<ACL> setAcls) throws KeeperException.NoAuthException {
2022:                                 new ServerAuthenticationProvider.MatchValues(path, authId.getId(), id.getId(), perm, setAcls))) {
2033:      * check a path whether exceeded the quota.
2035:      * @param path
2036:      *            the path of the node, used for the quota prefix check
2044:     public void checkQuota(String path, byte[] lastData, byte[] data, int type) throws KeeperException.QuotaExceededException {
2050:         String lastPrefix = zkDatabase.getDataTree().getMaxPrefixWithQuota(path);
2055:         final String namespace = PathUtils.getTopNamespace(path);
2069:      * check a path whether exceeded the quota.
2072:                   the path of the node which has a quota.
2160:      * Trim a path to get the immediate predecessor.
2162:      * @param path
2167:         int lastSlash = path.lastIndexOf('/');
2168:         if (lastSlash == -1 || path.indexOf('\0') != -1 || getZKDatabase().isSpecialPath(path)) {
2169:             throw new KeeperException.BadArgumentsException(path);
2171:         return lastSlash == 0 ? "/" : path.substring(0, lastSlash);
2176:         String path = null;
2186:                 path = parentPath(req.getPath());
2193:                 path = parentPath(req.getPath());
2200:                 path = req.getPath();
2209:                 path = req.getPath();
2220:             PrepRequestProcessor.fixupACL(path, request.authInfo, acl);
2223:         return path;
2280:             LOG.debug("ACL check against illegal node path: {}", e.getMessage());
55: import org.apache.zookeeper.common.PathUtils;
426:         pwriter.println(zkDb.snapLog.getSnapDir().getAbsolutePath());
430:         pwriter.println(zkDb.snapLog.getDataDir().getAbsolutePath());
451:             zkDb.snapLog.getSnapDir().getAbsolutePath(),
452:             zkDb.snapLog.getDataDir().getAbsolutePath(),
2085:         String limitNode = Quotas.limitPath(lastPrefix);
2104:         //check the statPath quota
2105:         String statNode = Quotas.statPath(lastPrefix);
2258:         String pathToCheck;
2267:             pathToCheck = effectiveACLPath(request);
2268:             if (pathToCheck != null) {
2269:                 checkACL(request.cnxn, zkDb.getACL(pathToCheck, null), effectiveACLPerms(request), request.authInfo, pathToCheck, null);
87: import org.apache.zookeeper.server.util.RequestPathMetricsCollector;
320:         this.requestPathMetricsCollector = new RequestPathMetricsCollector();
359:         this.requestPathMetricsCollector = new RequestPathMetricsCollector();
413:         return requestPathMetricsCollector;
727:         requestPathMetricsCollector.start();
884:         requestPathMetricsCollector.shutdown();
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() {
49:      * @param path The ZooKeeper path being operated on.
53:     public static KeeperException create(Code code, String path) {
55:         r.path = path;
64:     public static KeeperException create(int code, String path) {
66:         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/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/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/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/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, ]
88:         private final String path;
234:         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
97:         private Builder(CuratorFramework client, String path)
100:             this.path = validatePath(path);
113:             return new TreeCache(client, path, cacheData, dataIsCompressed, maxDepth, executor, createParentNodes, disableZkWatches, selector);
164:          * By default, TreeCache does not auto-create parent nodes for the cached path. Change
177: ...(6 bytes skipped)...   * By default, TreeCache creates {@link org.apache.zookeeper.ZooKeeper} watches for every created path.
202:      * Create a TreeCache builder for the given client and path to configure advanced options.
205:      * the namespace, including all published events.  The given path is the root at which the
206:      * TreeCache will watch and explore.  If no node exists at the given path, the TreeCache will
210:      * @param path   the path to the root node to watch/explore; this path need not actually exist on
214:     public static Builder newBuilder(CuratorFramework client, String path)
216:         return new Builder(client, path);
238:         TreeNode(String path, TreeNode parent)
240:             this.path = path;
247:             if ((depth < maxDepth) && selector.traverseChildren(path))
259:             if ((depth < maxDepth) && selector.traverseChildren(path))
276:                 maybeWatch(client.getChildren()).forPath(path);
286:                     maybeWatch(client.getData().decompressed()).forPath(path);
290:                     maybeWatch(client.getData()).forPath(path);
353:                 maybeWatch(client.checkExists()).forPath(path);
361:                     parentChildMap.remove(ZKPaths.getNodeFromPath(path), this);
442:                         if ( !childMap.containsKey(child) && selector.acceptChild(ZKPaths.makePath(path, child)) )
451:                         String fullPath = ZKPaths.makePath(path, child);
560:      * Create a TreeCache for the given client and path with default options.
563:      * the namespace, including all published events.  The given path is the root at which the
564:      * TreeCache will watch and explore.  If no node exists at the given path, the TreeCache will
568:      * @param path   the path to the root node to watch/explore; this path need not actually exist on
572:     public TreeCache(CuratorFramework client, String path)
574:         this(client, path, true, false, Integer.MAX_VALUE, Executors.newSingleThreadExecutor(defaultThreadFactory), false, fa...(37 bytes skipped)...
579:      * @param path             path to watch
581:      * @param dataIsCompressed if true, data in the path is compressed
587:     TreeCache(CuratorFramework client, String path, boolean cacheData, boolean dataIsCompressed, int maxDepth, final ExecutorService executorService, ...(80 bytes skipped)...
591:         this.root = new TreeNode(validatePath(path), null);
612:             client.createContainers(root.path);
670:         LinkedList<String> rootElements = new LinkedList<String>(ZKPaths.split(root.path));
674:                 // Target path shorter than root path
680:                 // Initial root path does not match
703:      * Return the current set of children at the given path, mapped by child name. There are no
705:      * node at this path, {@code null} is returned.
707:      * @param fullPath full path to the node to check
743:      * Return the current data for the given path. There are no guarantees of accuracy. This is
744:      * merely the most recent view of the data. If there is no node at the given path,
747:      * @param fullPath full path to the node to check
31: import org.apache.curator.framework.api.Pathable;
38: import org.apache.curator.utils.PathUtils;
64: import static org.apache.curator.utils.PathUtils.validatePath;
154:          * root node and its immediate children (kind of like {@link PathChildrenCache}.
295:         private <T, P extends Watchable<BackgroundPathable<T>> & BackgroundPathable<T>> Pathable<T> maybeWatch(
420: ...(5 bytes skipped)...                   childDataUpdater.compareAndSet(this, oldChildData, new ChildData(oldChildData.getPath(), newStat, oldChildData.getData()));
452:                         TreeNode node = new TreeNode(fullPath, this);
467:                     String eventPath = event.getPath();
468:                     ChildData toPublish = new ChildData(eventPath, newStat, event.getData());
469:                     ChildData toUpdate = cacheData ? toPublish : new ChildData(eventPath, newStat, null);
667:     private TreeNode find(String findPath)
669:         PathUtils.validatePath(findPath);
671:         LinkedList<String> findElements = new LinkedList<String>(ZKPaths.split(findPath));
710:     public Map<String, ChildData> getCurrentChildren(String fullPath)
712:         TreeNode node = find(fullPath);
750:     public ChildData getCurrentData(String fullPath)
752:         TreeNode node = find(fullPath);
29: import org.apache.curator.framework.api.BackgroundPathable;
40: import org.apache.curator.utils.ZKPaths;
github.com/apache/zeppelin:zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/Note.java: [ master, ]
149:   private String path;
187:   public String getPath() {
191:   public String getParentPath() {
282:   public void setPath(String path) {
77:   // serialize Paragraph#runtimeInfos and Note#path to frontend but not to note file
98:       if(field.getName().equals("path")) {
146:   // The front end needs to judge TRASH_FOLDER according to the path,
166:   public Note(String path, String defaultInterpreterGroup, InterpreterFactory factory,
169:     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);
283:     if (!path.startsWith("/")) {
284:       this.path = "/" + path;
286:       this.path = path;
288:     this.name = getName(path);
325:     // for the notes before 0.9, get path from name.
326:     if (this.path == null) {
328:         this.path = name;
330:         this.path = "/" + name;
333:       int pos = this.path.lastIndexOf('/');
334:       this.path = this.path.substring(0, pos + 1) + this.name;
365:           if (this.path.startsWith(folder)) {
890:     return this.path.startsWith("/" + NoteManager.TRASH_FOLDER);
1117:     if (this.path != null) {
1118:       return this.path;
1192:     //TODO(zjffdu) exclude path because FolderView.index use Note as key and consider different path
1194:     //    if (path != null ? !path.equals(note.path) : note.path != null) return false;
1212:     //    result = 31 * result + (path != null ? path.hashCode() : 0);
184:     setPath(noteInfo.getPath());
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/google/filament:third_party/draco/javascript/draco_wasm_wrapper.js: [ master, ]
15: LOGNAME:"web_user",PATH:"/",PWD:"/",HOME:"/home/web_user",LANG:("object"===typeof navigator&&navigator.languages&&navigator...(384 bytes skipped)...
21: ...(228 bytes skipped)...;var M="",pa,qa;if(oa){M=__dirname+"/";var ra=function(a,c){pa||(pa=require("fs"));qa||(qa=require("path"));a=qa.normalize(a);return pa.readFileSync(a,c?null:"utf8")};var la=function(a){a=ra(a,!0);a.buffe...(70 bytes skipped)...
github.com/google/filament:third_party/draco/javascript/draco_wasm_wrapper_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/apache/hive:standalone-metastore/metastore-server/src/main/java/org/apache/hadoop/hive/metastore/HMSHandler.java: [ master, ]
5177:     final Path path;
5176:   private static class PathAndDepth implements Comparable<PathAndDepth> {
5180:     public PathAndDepth(Path path, int depth) {
5387:   private void verifyIsWritablePath(Path dir) throws MetaException {
35: import org.apache.hadoop.fs.Path;
1030:         throw new InvalidObjectException("You must specify a path for the catalog");
1034:       Path catPath = new Path(catalog.getLocationUri());
1041:             throw new MetaException("Unable to create catalog path " + catPath +
1245:         wh.deleteDir(wh.getDnsPath(new Path(cat.getLocationUri())), false, false, false);
1292:     final Path defaultDbExtPath = wh.getDefaultDatabasePath(db.getName(), true);
1293:     final Path defaultDbMgdPath = wh.getDefaultDatabasePath(db.getName(), false);
1294:     final Path dbExtPath = (passedInURI != null) ? wh.getDnsPath(new Path(passedInURI)) : wh.determineDatabasePath(cat, db);
1295:     final Path dbMgdPath = (passedInManagedURI != null) ? wh.getDnsPath(new Path(passedInManagedURI)) : null;
1338:           LOG.debug("Creating database path " + dbExtPath);
1340:             throw new MetaException("Unable to create database path " + dbExtPath +
1353:                   LOG.info("Creating database path in managed directory " + dbMgdPath);
1355:                     throw new MetaException("Unable to create database managed path " + dbMgdPath + ", failed to create database " + db.getName());
1363:               LOG.info("Created database path in managed directory " + dbMgdPath);
1378:                   LOG.info("Creating database path in external directory " + dbExtPath);
1385:               LOG.info("Created database path in external directory " + dbExtPath);
1387:               LOG.warn("Failed to create external path " + dbExtPath + " for database " + db.getName() + ". This may result in access not being allowed if the "
1391:             throw new MetaException("Failed to create external path " + dbExtPath + " for database " + db.getName() + ". This may result in access not being allowed if the "
1395:           LOG.info("Database external path won't be created since the external warehouse directory is not defined");
1562:       newDB.setLocationUri(wh.getDnsPath(new Path(newDB.getLocationUri())).toString());
1616:     List<Path> tablePaths = new ArrayList<>();
1617:     List<Path> partitionPaths = new ArrayList<>();
1666:       Path path = new Path(db.getLocationUri()).getParent();
1667:       if (!wh.isWritable(path)) {
1668:         throw new MetaException("Database not dropped since its external warehouse location " + path + " is not writable by " +
1671:       path = wh.getDatabaseManagedPath(db).getParent();
1672:       if (!wh.isWritable(path)) {
1673:         throw new MetaException("Database not dropped since its managed warehouse location " + path + " is not writable by " +
1677:       Path databasePath = wh.getDnsPath(wh.getDatabasePath(db));
1712:               Path materializedViewPath = wh.getDnsPath(new Path(materializedView.getSd().getLocation()));
1752:             Path tablePath = null;
1756:               tablePath = wh.getDnsPath(new Path(table.getSd().getLocation()));
1799:         for (Path tablePath : tablePaths) {
1803:         final Path path = (dbFinal.getManagedLocationUri() != null) ?
1804:             new Path(dbFinal.getManagedLocationUri()) : wh.getDatabaseManagedPath(dbFinal);
1809:               return wh.deleteDir(path, true, dbFinal);
1813:             LOG.error("Failed to delete database's managed warehouse directory: " + path);
1816:           LOG.error("Failed to delete database's managed warehouse directory: " + path + " " + e.getMessage());
1822:               return wh.deleteDir(new Path(dbFinal.getLocationUri()), true, dbFinal);
2388:     Path tblPath = null;
2414:           tblPath = wh.getDnsPath(new Path(tbl.getSd().getLocation()));
2954:     Path tblPath = null;
2955:     List<Path> partPaths = null;
2996:         tblPath = new Path(tbl.getSd().getLocation());
3066:   private void deleteTableData(Path tablePath, boolean ifPurge, boolean shouldEnableCm) {
3080:   private void deleteTableData(Path tablePath, boolean ifPurge, Database db) {
3100:   private void deletePartitionData(List<Path> partPaths, boolean ifPurge, boolean shouldEnableCm) {
3102:       for (Path partPath : partPaths) {
3117:   private void deletePartitionData(List<Path> partPaths, boolean ifPurge, Database db) {
3119:       for (Path partPath : partPaths) {
3131:    * Delete data from path excluding cmdir
3134:    * @param path
3139:   private void deleteDataExcludeCmroot(Path path, boolean ifPurge, boolean shouldEnableCm) {
3142:         //Don't delete cmdir if its inside the partition path
3143:         FileStatus[] statuses = path.getFileSystem(conf).listStatus(path,
3144:             ReplChangeManager.CMROOT_PATH_FILTER);
3149:         FileStatus[] statusWithoutFilter = path.getFileSystem(conf).listStatus(path);
3151:           wh.deleteDir(path, true, ifPurge, shouldEnableCm);
3155:         wh.deleteDir(path, true, ifPurge, shouldEnableCm);
3158:       LOG.error("Failed to delete directory: " + path +
3178:    * @return The list of the Path objects to delete (only in case checkLocation is true)
3183:   private List<Path> dropPartitionsAndGetLocations(RawStore ms, String catName, String dbName,
3184:                                                    String tableName, Path tablePath, boolean checkLocation)
3192:     List<Path> partPaths = new ArrayList<>();
3197:         // No more partitions left to drop. Return with the collected path list to delete.
3205:             Path partPath = wh.getDnsPath(new Path(pathString));
3207:             // path objects
3356:   private List<Path> getLocationsForTruncate(final RawStore ms,
3362:     List<Path> locations = new ArrayList<>();
3366:           locations.add(new Path(partition.getSd().getLocation()));
3369:         locations.add(new Path(table.getSd().getLocation()));
3373:         locations.add(new Path(partition.getSd().getLocation()));
3381:     wh.recycleDirToCmPath(new Path(request.getDataPath()), request.isPurge());
3388:     // Deprecated path, won't work for txn tables.
3421:         for (Path location : getLocationsForTruncate(getMS(), parsedDbName[CAT_NAME], parsedDbName[DB_NAME], tableNam...(2 bytes skipped)...
3451:   private void addTruncateBaseFile(Path location, long writeId, FileSystem fs) throws Exception {
3452:     Path basePath = new Path(location, AcidConstants.baseDir(writeId));
3459:   private void truncateDataFiles(Path location, FileSystem fs, boolean isSkipTrash, boolean needCmRecycle)
3470:       FileStatus[] statuses = fs.listStatus(location, FileUtils.HIDDEN_FILES_PATH_FILTER);
3939:     Path partLocation = null;
3967:       partLocation = new Path(tbl.getSd().getLocation(), Warehouse
4280:         wh.deleteDir(new Path(e.getKey().location), true, db);
4629:     Path partLocation = null;
4639:         partLocation = new Path(tbl.getSd().getLocation(), Warehouse
4646:       partLocation = wh.getDnsPath(new Path(partLocationStr));
4769:           wh.deleteDir(new Path(part.getSd().getLocation()), true, false,
4913:     Path sourcePath = new Path(sourceTable.getSd().getLocation(),
4915:     Path destPath = new Path(destinationTable.getSd().getLocation(),
4949:         Path destPartitionPath = new Path(destinationTable.getSd().getLocation(),
4957:       Path destParentPath = destPath.getParent();
4960:           throw new MetaException("Unable to create path " + destParentPath);
5032:     Path partPath = null;
5036:     Path archiveParentDir = null;
5074:         partPath = new Path(part.getSd().getLocation());
5159:   private void deleteParentRecursive(Path parent, int depth, boolean mustPurge, boolean needRecycle)
5175:   /** Stores a path and its size. */
5181:       this.path = path;
5187:       return Objects.hash(path.hashCode(), depth);
5199:       return depth == that.depth && Objects.equals(path, that.path);
5220:     List<Path> archToDelete = new ArrayList<>();
5289:         // TODO - we need to speed this up for the normal path where all partitions are under
5299:           Path archiveParentDir = MetaStoreUtils.getOriginalLocation(part);
5304:           Path partPath = new Path(part.getSd().getLocation());
5333:         for (Path path : archToDelete) {
5334:           wh.deleteDir(path, true, mustPurge, needsCm);
5338:         // Parents with the deepest path are always processed first. It guarantees that the emptiness
5343:           wh.deleteDir(p.path, true, mustPurge, needsCm);
5356:             Path path = p.path;
5357:             if (wh.isWritable(path) && wh.isEmptyDir(path)) {
5358:               wh.deleteDir(path, true, mustPurge, needsCm);
5381:     Path parent = p.path.getParent();
5867:         Path tblPath = wh.getDnsPath(new Path(newLocation));
6092:         Path tblPath = wh.getDnsPath(new Path(newLocation));
8488:             wh.addToChangeManagement(new Path(uri.getUri()));
8717:         // The files in the commit txn message during load will have files with path corresponding to source
8721:           String name = (new Path(decodedPath[0])).getName();
8722:           Path newPath = FileUtils.getTransformedPath(name, decodedPath[3], root);
759:           wh.getDefaultDatabasePath(DEFAULT_DATABASE_NAME, true).toString(), null);
1039:         if (!wh.isDir(catPath)) {
1040:           if (!wh.mkdirs(catPath)) {
1071:             wh.deleteDir(catPath, true, false, false);
1297:     if ((defaultDbExtPath.equals(dbExtPath) && defaultDbMgdPath.equals(dbMgdPath)) &&
1298:         ((dbMgdPath == null) || dbMgdPath.equals(defaultDbMgdPath))) {
1307:       db.setLocationUri(dbExtPath.toString());
1308:       if (dbMgdPath != null) {
1309:         db.setManagedLocationUri(dbMgdPath.toString());
1330:         db.setLocationUri(dbExtPath.toString());
1331:         if (dbMgdPath != null) {
1332:           db.setManagedLocationUri(dbMgdPath.toString());
1337:         if (!wh.isDir(dbExtPath)) {
1339:           if (!wh.mkdirs(dbExtPath)) {
1346:         if (dbMgdPath != null) {
1352:                 if (!wh.isDir(dbMgdPath)) {
1354:                   if (!wh.mkdirs(dbMgdPath)) {
1366:                   "Unable to create database managed directory " + dbMgdPath + ", failed to create database " + db.getName());
1370:                 "Unable to create database managed directory " + dbMgdPath + ", failed to create database " + db.getName() + ":" + e.getMessage());
1373:         if (dbExtPath != null) {
1377:                 if (!wh.isDir(dbExtPath)) {
1379:                   return wh.mkdirs(dbExtPath);
1416:           if (madeManagedDir && dbMgdPath != null) {
1417:             wh.deleteDir(dbMgdPath, true, db);
1420:           if (madeManagedDir && dbMgdPath != null) {
1424:                   wh.deleteDir(dbMgdPath, true, db);
1430:                   "Couldn't delete managed directory " + dbMgdPath + " after " + "it was created for database " + db.getName() + " " + e.getMessage());
1434:           if (madeExternalDir && dbExtPath != null) {
1438:                   wh.deleteDir(dbExtPath, true, db);
1443:               LOG.error("Couldn't delete external directory " + dbExtPath + " after " + "it was created for database "
1714:               if (!FileUtils.isSubdirectory(databasePath.toString(),
1715:                   materializedViewPath.toString())) {
1716:                 if (!wh.isWritable(materializedViewPath.getParent())) {
1718: ...(0 bytes skipped)...                      materializedView.getTableName() + " has a parent location " + materializedViewPath.getParent() +
1721:                 tablePaths.add(materializedViewPath);
1751:             // add it's locations to the list of paths to delete
1758:                 if (!wh.isWritable(tablePath.getParent())) {
1761:                           + tablePath.getParent() + " which is not writable by " + SecurityUtils.getUser());
1763:                 tablePaths.add(tablePath);
1770:                 tablePath, tableDataShouldBeDeleted);
1800:           deleteTableData(tablePath, false, db);
2408:           tblPath = wh.getDefaultTablePath(db, tbl);
2416:         tbl.getSd().setLocation(tblPath.toString());
2419:       if (tblPath != null) {
2420:         if (!wh.isDir(tblPath)) {
2421:           if (!wh.mkdirs(tblPath)) {
2422:             throw new MetaException(tblPath
2505:           wh.deleteDir(tblPath, true, false, ReplChangeManager.shouldEnableCm(db, tbl));
2997:         if (!wh.isWritable(tblPath.getParent())) {
3000:               tblPath.getParent() + " is not writable by " +
3008:         partPaths = dropPartitionsAndGetLocations(ms, catName, dbname, name, tblPath, tableDataShouldBeDeleted);
3036:         deleteTableData(tblPath, ifPurge, ReplChangeManager.shouldEnableCm(db, tbl));
3061:    * @param tablePath
3067:     if (tablePath != null) {
3068:       deleteDataExcludeCmroot(tablePath, ifPurge, shouldEnableCm);
3075:    * @param tablePath
3081:     if (tablePath != null) {
3083:         wh.deleteDir(tablePath, true, ifPurge, db);
3085:         LOG.error("Failed to delete table directory: " + tablePath +
3103:         deleteDataExcludeCmroot(partPath, ifPurge, shouldEnableCm);
3121:           wh.deleteDir(partPath, true, ifPurge, db);
3123:           LOG.error("Failed to delete partition directory: " + partPath +
3146:           wh.deleteDir(status.getPath(), true, ifPurge, shouldEnableCm);
3165:    * locations of partitions which may not be subdirectories of tablePath checks to make sure the
3170:    * Provides a list of locations of partitions which may not be subdirectories of tablePath.
3176:    * @param tablePath The tablePath of which subdirectories does not have to be checked
3187:     String tableDnsPath = null;
3188:     if (tablePath != null) {
3189:       tableDnsPath = wh.getDnsPath(tablePath).toString();
3195:           tableDnsPath, batchSize);
3203:           String pathString = partitionLocations.get(partName);
3204:           if (pathString != null) {
3206:             // Double check here. Maybe Warehouse.getDnsPath revealed relationship between the
3208:             if (tableDnsPath == null ||
3209:                 !FileUtils.isSubdirectory(tableDnsPath, partPath.toString())) {
3210:               if (!wh.isWritable(partPath.getParent())) {
3212:                     + partName + " has parent location " + partPath.getParent()
3215:               partPaths.add(partPath);
3453:     fs.mkdirs(basePath);
3456:     AcidMetaDataFile.writeToFile(fs, basePath, AcidMetaDataFile.DataFormat.TRUNCATED);
3462:         !FileUtils.pathHasSnapshotSubDir(location, fs)) {
3475:         wh.deleteDir(status.getPath(), true, isSkipTrash, needCmRecycle);
4864:     boolean pathCreated = false;
4951:         destPartition.getSd().setLocation(destPartitionPath.toString());
4958:       if (!wh.isDir(destParentPath)) {
4959:         if (!wh.mkdirs(destParentPath)) {
4967:       pathCreated = wh.renameDir(sourcePath, destPath, false);
4991:       if (!success || !pathCreated) {
4993:         if (pathCreated) {
4994:           wh.renameDir(destPath, sourcePath, false);
5070:         verifyIsWritablePath(archiveParentDir);
5075:         verifyIsWritablePath(partPath);
5095:       } else if (deleteData && ((partPath != null) || (archiveParentDir != null))) {
5098:             LOG.info("dropPartition() will purge " + partPath + " directly, skipping trash.");
5101:             LOG.info("dropPartition() will move " + partPath + " to trash-directory.");
5110:             assert (partPath != null);
5111:             wh.deleteDir(partPath, true, mustPurge, needsCm);
5112:             deleteParentRecursive(partPath.getParent(), part_vals.size() - 1, mustPurge, needsCm);
5198:       PathAndDepth that = (PathAndDepth) o;
5204:     public int compareTo(PathAndDepth o) {
5219:     List<PathAndDepth> dirsToDelete = new ArrayList<>();
5300:           verifyIsWritablePath(archiveParentDir);
5305:           verifyIsWritablePath(partPath);
5306:           dirsToDelete.add(new PathAndDepth(partPath, part.getValues().size()));
5341:         PriorityQueue<PathAndDepth> parentsToDelete = new PriorityQueue<>();
5342:         for (PathAndDepth p : dirsToDelete) {
5347:         HashSet<PathAndDepth> processed = new HashSet<>();
5350:             PathAndDepth p = parentsToDelete.poll();
5380:   private static void addParentForDel(PriorityQueue<PathAndDepth> parentsToDelete, PathAndDepth p) {
5383:       parentsToDelete.add(new PathAndDepth(parent, p.depth - 1));
5702:         pSpec.setRootPath(table.getSd().getLocation());
5868:         new_part.getSd().setLocation(tblPath.toString());
6093:         newTable.getSd().setLocation(tblPath.toString());
7321:         pSpec.setRootPath(table.getSd().getLocation());
8720:           String[] decodedPath = ReplChangeManager.decodeFileUri(file);
8723:           insertData.addToFilesAdded(newPath.toUri().toString());
8724:           insertData.addToSubDirectoryList(decodedPath[3]);
8726:             insertData.addToFilesAddedChecksum(ReplChangeManager.checksumFor(newPath, newPath.getFileSystem(conf)));
8728:             LOG.error("failed to get checksum for the file " + newPath + " with error: " + e.getMessage());
9903:       getMS().alterPool(request.getPool(), request.getPoolPath());
9928:       getMS().dropWMPool(request.getResourcePlanName(), request.getPoolPath(), request.getNs());
9968:             request.getTriggerName(), request.getPoolPath(), request.getNs());
9971:             request.getTriggerName(), request.getPoolPath(), request.getNs());
1769:             partitionPaths = dropPartitionsAndGetLocations(ms, catName, name, table.getTableName(),
1797:         deletePartitionData(partitionPaths, false, db);
3034:         deletePartitionData(partPaths, ifPurge, ReplChangeManager.shouldEnableCm(db, tbl));
3095:    * @param partPaths
3101:     if (partPaths != null && !partPaths.isEmpty()) {
3112:    * @param partPaths
3118:     if (partPaths != null && !partPaths.isEmpty()) {
3198:         return partPaths;
3461:     if (!HdfsUtils.isPathEncrypted(getConf(), fs.getUri(), location) &&
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;
382:       List<String> path,
387:     QuerySpec query = new QuerySpec(path, queryParams);
405:   public Task<Object> get(List<String> path, Map<String, Object> queryParams) {
406:     QuerySpec query = new QuerySpec(path, queryParams);
412:     request.put(REQUEST_PATH, ConnectionUtils.pathToString(query.path));
423:                 delegate.onDataUpdate(query.path, body, /*isMerge=*/ false, /*tagNumber=*/ null);
465:   public void put(List<String> path, Object data, RequestResultCallback onComplete) {
466:     putInternal(REQUEST_ACTION_PUT, path, data, /*hash=*/ null, onComplete);
471:       List<String> path, Object data, String hash, RequestResultCallback onComplete) {
472:     putInternal(REQUEST_ACTION_PUT, path, data, hash, onComplete);
476:   public void merge(List<String> path, Map<String, Object> data, RequestResultCallback onComplete) {
477:     putInternal(REQUEST_ACTION_MERGE, path, data, /*hash=*/ null, onComplete);
575:   public void unlisten(List<String> path, Map<String, Object> queryParams) {
576:     QuerySpec query = new QuerySpec(path, queryParams);
595:   public void onDisconnectPut(List<String> path, Object data, RequestResultCallback onComplete) {
598:       sendOnDisconnect(REQUEST_ACTION_ONDISCONNECT_PUT, path, data, onComplete);
601:           new OutstandingDisconnect(REQUEST_ACTION_ONDISCONNECT_PUT, path, data, onComplete));
616:       List<String> path, Map<String, Object> updates, final RequestResultCallback onComplete) {
619:       sendOnDisconnect(REQUEST_ACTION_ONDISCONNECT_MERGE, path, updates, onComplete);
622:           new OutstandingDisconnect(REQUEST_ACTION_ONDISCONNECT_MERGE, path, updates, onComplete));
628:   public void onDisconnectCancel(List<String> path, RequestResultCallback onComplete) {
633:       sendOnDisconnect(REQUEST_ACTION_ONDISCONNECT_CANCEL, path, null, onComplete);
636:           new OutstandingDisconnect(REQUEST_ACTION_ONDISCONNECT_CANCEL, path, null, onComplete));
855:       String action, List<String> path, Object data, final RequestResultCallback onComplete) {
857:     request.put(REQUEST_PATH, ConnectionUtils.pathToString(path));
903:     request.put(REQUEST_PATH, ConnectionUtils.pathToString(listen.query.path));
929:   private Collection<OutstandingListen> removeListens(List<String> path) {
930:     if (logger.logsDebug()) logger.debug("removing all listens at path " + path);
935:       if (query.path.equals(path)) {
954:       String pathString = (String) body.get(SERVER_DATA_UPDATE_PATH);
959:         if (logger.logsDebug()) logger.debug("ignoring empty merge for path " + pathString);
961:         List<String> path = ConnectionUtils.stringToPath(pathString);
962:         delegate.onDataUpdate(path, payloadData, isMerge, tagNumber);
965:       String pathString = (String) body.get(SERVER_DATA_UPDATE_PATH);
966:       List<String> path = ConnectionUtils.stringToPath(pathString);
973:         String startString = (String) range.get(SERVER_DATA_START_PATH);
974:         String endString = (String) range.get(SERVER_DATA_END_PATH);
981:         if (logger.logsDebug()) logger.debug("Ignoring empty range merge for path " + pathString);
983:         this.delegate.onRangeMergeUpdate(path, rangeMerges, tag);
986:       String pathString = (String) body.get(SERVER_DATA_UPDATE_PATH);
987:       List<String> path = ConnectionUtils.stringToPath(pathString);
988:       onListenRevoked(path);
1004:   private void onListenRevoked(List<String> path) {
1007:     Collection<OutstandingListen> listens = removeListens(path);
1222:   private Map<String, Object> getPutObject(List<String> path, Object data, String hash) {
1224:     request.put(REQUEST_PATH, ConnectionUtils.pathToString(path));
1234:       List<String> path,
1238:     Map<String, Object> request = getPutObject(path, data, hash);
1320:     request.put(REQUEST_PATH, ConnectionUtils.pathToString(listen.getQuery().path));
1335:       for (List<String> path : compoundHash.getPosts()) {
1336:         posts.add(ConnectionUtils.pathToString(path));
1413:               + ConnectionUtils.pathToString(query.path)
975:         List<String> start = startString != null ? ConnectionUtils.stringToPath(startString) : null;
976:         List<String> end = endString != null ? ConnectionUtils.stringToPath(endString) : null;
1199:           disconnect.getPath(),
1340:       hash.put(REQUEST_COMPOUND_HASH_PATHS, posts);
android.googlesource.com/platform/external/hsqldb:src/org/hsqldb/Tokens.java: [ master, ]
1283:     public static final int PATH                        = 472;
112:     static final String T_CURRENT_PATH      = "CURRENT_PATH";
541:     public static final String T_PATH                 = "PATH";
877:     public static final int CURRENT_PATH                     = 62;
1662:         reservedKeys.put(Tokens.T_CURRENT_PATH, CURRENT_PATH);
chromium.googlesource.com/android_tools:sdk/sources/android-25/benchmarks/regression/R.java: [ master, ]
1967:     public static final int path = 0;
709:     public final int mpath = 0;
909:     public final int msearchSuggestPath = 0;
1968:     public static final int pathData = 0;
1969:     public static final int pathPattern = 0;
1970:     public static final int pathPrefix = 0;
2167:     public static final int searchSuggestPath = 0;
710:     public final int mpathData = 0;
711:     public final int mpathPattern = 0;
712:     public final int mpathPrefix = 0;
713:     public final int mpatternPathData = 0;
1171:     public final int mtrimPathEnd = 0;
1172:     public final int mtrimPathOffset = 0;
1173:     public final int mtrimPathStart = 0;
1971:     public static final int patternPathData = 0;
2429:     public static final int trimPathEnd = 0;
2430:     public static final int trimPathOffset = 0;
2431:     public static final int trimPathStart = 0;
android.googlesource.com/platform/external/universal-tween-engine:java/api/src/aurelienribon/tweenengine/Tween.java: [ master, ]
345: 	private TweenPath path;
715: 	public Tween path(TweenPath path) {
360: 	private float[] pathBuffer = new float[(2+waypointsLimit)*combinedAttrsLimit];
211: 		tween.path(TweenPaths.catmullRom);
249: 		tween.path(TweenPaths.catmullRom);
379: 		path = null;
623: 	 * Adds a waypoint to the path. The default path runs from the start values
624: 	 * to the end values linearly. If you add waypoints, the default path will
626: 	 * you can change this behavior by using the {@link #path(TweenPath)}
640: 	 * Adds a waypoint to the path. The default path runs from the start values
641: 	 * to the end values linearly. If you add waypoints, the default path will
643: 	 * you can change this behavior by using the {@link #path(TweenPath)}
662: 	 * Adds a waypoint to the path. The default path runs from the start values
663: 	 * to the end values linearly. If you add waypoints, the default path will
665: 	 * you can change this behavior by using the {@link #path(TweenPath)}
686: 	 * Adds a waypoint to the path. The default path runs from the start values
687: 	 * to the end values linearly. If you add waypoints, the default path will
689: 	 * you can change this behavior by using the {@link #path(TweenPath)}
710: 	 * @param path A TweenPath implementation.
716: 		this.path = path;
858: 		if (waypointsCnt == 0 || path == null) {
871: 				accessorBuffer[i] = path.compute(t, pathBuffer, waypointsCnt+2);
388: 		if (pathBuffer.length != (2+waypointsLimit)*combinedAttrsLimit) {
389: 			pathBuffer = new float[(2+waypointsLimit)*combinedAttrsLimit];
708: 	 * but you can find other paths in the {@link TweenPaths} class.
712: 	 * @see TweenPath
865: 				pathBuffer[0] = startValues[i];
866: 				pathBuffer[1+waypointsCnt] = targetValues[i];
868: 					pathBuffer[ii+1] = waypoints[ii*combinedAttrsCnt+i];
713: 	 * @see TweenPaths
android.googlesource.com/platform/external/cldr:tools/cldr-code/src/main/java/org/unicode/cldr/icu/LDMLConstants.java: [ master, ]
37:     public static final String PATH = "path";
android.googlesource.com/platform/libcore:benchmarks/src/benchmarks/regression/R.java: [ master, ] Duplicate result
chromium.googlesource.com/android_tools:sdk/sources/android-25/com/android/server/pm/PackageManagerService.java: [ master, ]
649:         public final String path;
547:     final String mAsecInternalPath;
12704:         final String resolvedPath;
13328:         abstract String getCodePath();
13330:         abstract String getResourcePath();
13553:         String getCodePath() {
13558:         String getResourcePath() {
13618:     static String cidFromCodePath(String fullCodePath) {
13634:         String packagePath;
13635:         String resourcePath;
13708:         String getCodePath() {
13713:         String getResourcePath() {
13800:         private void setMountPath(String mountPath) {
13995:         String getCodePath() {
14000:         String getResourcePath() {
14043:     private static String getNextCodePath(String oldCodePath, String prefix, String suffix) {
14079:     private File getNextCodePath(File targetDir, String packageName) {
390:     static final int SCAN_NO_PATHS = 1<<5;
7578:     void removeCodePathLI(File codePath) {
9375:     private void setNativeLibraryPaths(PackageParser.Package pkg) {
13853:         private List<String> getAllCodePaths() {
14092:     static String deriveCodePathName(String codePath) {
14409:     public List<String> getPreviousCodePaths(String packageName) {
652:         SharedLibraryEntry(String _path, String _apk) {
653:             path = _path;
2164:             // Clean up orphaned packages for which the code path doesn't exist
2224:                         final String lib = libEntry.path;
2315:                 // failed to look up canonical path, continue with original one
2470:                             Slog.e(TAG, "Ignoring unexpected fallback path " + scanFile);
6918:                 // The path has changed from what was last scanned...  check the
6919:                 // version of the new path against what we have stored to determine
6921:                 if (DEBUG_INSTALL) Slog.d(TAG, "Path changing from " + ps.codePath);
6923:                     // The system package has been updated and the code path does not match
6929:                         Slog.w(PackageManagerService.TAG, "Code path for hidden system pkg "
7054:         // vendor path).
7071:                 Slog.e(TAG, "Resource path not set for package " + pkg.packageName);
7078:         // Set application objects path explicitly.