Found 163228 results in 14821 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/internal/PathEntry.java: [ master, ]
101:     private final String path;
69:     public static final String PATH_DIRECTIVE = "path";
33: public class PathEntry extends ImportOptions {
154:     public PathEntry(ManifestHeader.Entry entry, long bundleLastModified) {
248:     public String getPath() {
132:     public static Iterator<PathEntry> getContentPaths(final Bundle bundle) {
31:  * A path entry from the manifest for initial content.
66:      * The path directive specifying the target node where initial content will
100:     /** The path for the initial content. */
122:      * Target path where initial content will be loaded. If it´s null then
155:         this.path = entry.getValue();
201:         // path directive
202:         final String pathValue = entry.getDirectiveValue(PATH_DIRECTIVE);
249:         return this.path;
133:         final List<PathEntry> entries = new ArrayList<>();
144:                 entries.add(new PathEntry(entry, bundleLastModified ));
203:         if (pathValue != null) {
204:             this.target = pathValue;
237:         if (pathValue != null) {
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/apache/flex-whiteboard:fthomas/developerToolSuite/trunk/org.apache.flex.utilities.developerToolSuite.executor-lib/src/main/flex/org/apache/flex/utilities/developerToolSuite/executor/infrastructure/message/ValidateJavaPathMessage.as: [ trunk, ]
26:         public function get path():String {
18:     public class ValidateJavaPathMessage {
22:         public function ValidateJavaPathMessage(path:String) {
20:         private var _path:String;
23:             _path = path;
27:             return _path;
github.com/GoogleCloudPlatform/datanucleus-appengine:testing/selenium-core/xpath/javascript-xpath-0.1.8.js: [ master, ]
645: UnionExpr.prototype.path = function(path) {
74: var PathExpr;
673: PathExpr = function(filter) {
2755:     win.XPathExpression = function(expr) {
2773:     win.XPathResult = function (value, type) {
614:     union.path(expr);
619:             throw Error('missing next union location path');
621:         union.path(PathExpr.parse(lexer));
646:     this.paths.push(path);
648:     if (path.needContextPosition) {
651:     if (path.needContextNode) {
686:     var op, expr, path, token;
698:         path = new PathExpr(FilterExpr.root()); // RootExpr
704:         path.step(op, expr);
710:             path = new PathExpr(FilterExpr.context());
711:             path.step('/', expr);
716:             path = new PathExpr(expr);
725:         path.step(op, Step.parse(lexer));
728:     return path;
806:     t += indent + 'path:' + '\n';
1: /*  JavaScript-XPath 0.1.8
4:  *  JavaScript-XPath is freely distributable under the terms of an MIT-style license.
5:  *  For details, see the JavaScript-XPath web site: http://coderepos.org/share/wiki/JavaScript-XPath
24: if (window.jsxpath) {
25:     config = window.jsxpath;
57:                         && document.implementation.hasFeature("XPath", null));
600:     this.paths = [];
609:     expr = PathExpr.parse(lexer);
635:     var paths = this.paths;
637:     for (var i = 0, l = paths.length; i < l; i ++) {
638:         var exrs = paths[i].evaluate(ctx);
639:         if (!exrs.isNodeSet) throw Error('PathExpr must be nodeset');
660:     for (var i = 0; i < this.paths.length; i ++) {
661:         t += this.paths[i].show(indent);
668:  * class: PathExpr
670: if (!window.PathExpr && window.defaultConfig)
671:     window.PathExpr = null;
683: PathExpr.ops = { '//': 1, '/': 1 };
685: PathExpr.parse = function(lexer) {
731: PathExpr.prototype = new BaseExpr();
733: PathExpr.prototype.evaluate = function(ctx) {
786: PathExpr.prototype.step = function(op, step) {
803: PathExpr.prototype.show = function(indent) {
1013:             // fix for "xpath href with spaces" (http://jira.openqa.org/browse/SEL-347)   
2273:         return node.__jsxpath_id__ || (node.__jsxpath_id__ = this.uuid++);
2769:     win.XPathExpression.prototype.evaluate = function(node, type) {
2770:         return new win.XPathResult(this.expr.evaluate(new Ctx(node)), type);
2807:     win.XPathResult.prototype.iterateNext = function() { return this.nodes[this.index++] };
2808:     win.XPathResult.prototype.snapshotItem = function(i) { return this.nodes[i] };
2810:     win.XPathResult.ANY_TYPE = 0;
2811:     win.XPathResult.NUMBER_TYPE = 1;
2812:     win.XPathResult.STRING_TYPE = 2;
2813:     win.XPathResult.BOOLEAN_TYPE = 3;
2814:     win.XPathResult.UNORDERED_NODE_ITERATOR_TYPE = 4;
2815:     win.XPathResult.ORDERED_NODE_ITERATOR_TYPE = 5;
2816:     win.XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE = 6;
2817:     win.XPathResult.ORDERED_NODE_SNAPSHOT_TYPE = 7;
2818:     win.XPathResult.ANY_UNORDERED_NODE_TYPE = 8;
2819:     win.XPathResult.FIRST_ORDERED_NODE_TYPE = 9;
2823:         return new win.XPathExpression(expr, null);
github.com/apache/airavata-custos:credential-store/credential-core/src/main/java/org/apache/airavata/custos/vault/annotations/VaultPath.java: [ master, ]
31:     public String path();
29: public @interface VaultPath {
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;
552:     public String getPath() {
556:     public URL setPath(String path) {
560:     public String getAbsolutePath() {
1516:     public String getPathKey() {
56: 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;
280:             // case: file:/path/to/file.txt
293:             path = url.substring(i + 1);
322:         return new URL(protocol, username, password, host, port, path, parameters);
441:         return new URL(protocol, username, password, host, port, path, getParameters());
449:         return new URL(getProtocol(), username, password, host, port, path, getParameters());
457:         return new URL(getProtocol(), username, password, host, port, path, getParameters());
474:         return new URL(getProtocol(), username, password, host, port, path, getParameters());
497:         return new URL(getProtocol(), username, password, host, port, path, getParameters());
521:         return new URL(getProtocol(), username, password, host, port, path, getParameters());
553:         return path;
557:         return new URL(getProtocol(), username, password, host, port, path, getParameters());
561:         if (path != null && !path.startsWith("/")) {
562:             return "/" + path;
564:         return path;
1144:         return new URL(getProtocol(), username, password, host, port, path, map);
1158:         return new URL(getProtocol(), username, password, host, port, path, map);
1173:         return new URL(getProtocol(), username, password, host, port, path, map, methodMap);
1191:         return new URL(getProtocol(), username, password, host, port, path, map, methodMap);
1227:         return new URL(getProtocol(), username, password, host, port, path, map);
1236:         return new URL(getProtocol(), username, password, host, port, path, map);
1286:         return new URL(getProtocol(), username, password, host, port, path, map);
1290:         return new URL(getProtocol(), username, password, host, port, path, new HashMap<>());
1309:         if (PATH_KEY.equals(key)) {
1310:             return path;
1333:         if (path != null) {
1334:             map.put(PATH_KEY, path);
1440:         String path;
1442:             path = getServiceKey();
1444:             path = getPath();
1446:         if (StringUtils.isNotEmpty(path)) {
1448:             buf.append(path);
1512:      * The format of return value is '{group}/{path/interfaceName}:{version}'
1517:         String inf = StringUtils.isNotEmpty(path) ? path : getServiceInterface();
1524:     public static String buildKey(String path, String group, String version) {
1525:         return BaseServiceMetadata.buildServiceKey(path, group, version);
1550:         return getParameter(INTERFACE_KEY, path);
1660:         result = prime * result + ((path == null) ? 0 : path.hashCode());
1703:         if (!StringUtils.isEquals(path, other.path)) {
398: ...(36 bytes skipped)...w URL(url.getProtocol(), url.getUsername(), url.getPassword(), url.getHost(), url.getPort(), url.getPath())
399: ...(20 bytes skipped)...w URL(url.getProtocol(), url.getUsername(), url.getPassword(), url.getHost(), url.getPort(), url.getPath(), newMap);
github.com/apache/hadoop:hadoop-hdfs-project/hadoop-hdfs/src/main/java/org/apache/hadoop/hdfs/server/namenode/FSEditLogOp.java: [ trunk, ]
421:     String path;
861:     String path;
952:     private String path;
1065:     String path;
1159:     String path;
1508:     String path;
1606:     String path;
2404:     String path;
2511:     String path;
2971:     String path;
4824:     String path;
292:     String getPath();
468:     <T extends AddCloseOp> T setPath(String path) {
474:     public String getPath() {
874:     AppendOp setPath(String path) {
971:     AddBlockOp setPath(String path) {
976:     public String getPath() {
1082:     UpdateBlocksOp setPath(String path) {
1088:     public String getPath() {
1176:     SetReplicationOp setPath(String path) {
1526:     DeleteOp setPath(String path) {
1636:     MkdirOp setPath(String path) {
2424:     TimesOp setPath(String path) {
2541:     SymlinkOp setPath(String path) {
2858:     TruncateOp setPath(String src) {
2994:     ReassignLeaseOp setPath(String path) {
4841:     SetStoragePolicyOp setPath(String path) {
447:       path = null;
469:       this.path = path;
475:       return path;
561:       FSImageSerialization.writeString(path, out);
609:       this.path = FSImageSerialization.readString(in);
703:           .append(", path=")
704:           .append(path)
746:       XMLUtils.addSaxString(contentHandler, "PATH", path);
777:       this.path = st.getValue("PATH");
875:       this.path = path;
898:           .append("[path=").append(path)
907:       this.path = null;
915:       this.path = FSImageSerialization.readString(in);
924:       FSImageSerialization.writeString(path, out);
933:       XMLUtils.addSaxString(contentHandler, "PATH", path);
943:       this.path = st.getValue("PATH");
966:       path = null;
972:       this.path = path;
977:       return path;
1000:       FSImageSerialization.writeString(path, out);
1014:       path = FSImageSerialization.readString(in);
1026:       sb.append("AddBlockOp [path=")
1027:           .append(path)
1039:       XMLUtils.addSaxString(contentHandler, "PATH", path);
1049:       this.path = st.getValue("PATH");
1078:       path = null;
1083:       this.path = path;
1089:       return path;
1105:       FSImageSerialization.writeString(path, out);
1113:       path = FSImageSerialization.readString(in);
1127:       sb.append("UpdateBlocksOp [path=")
1128:         .append(path)
1138:       XMLUtils.addSaxString(contentHandler, "PATH", path);
1146:       this.path = st.getValue("PATH");
1172:       path = null;
1177:       this.path = path;
1189:       FSImageSerialization.writeString(path, out);
1196:       this.path = FSImageSerialization.readString(in);
1208:       builder.append("SetReplicationOp [path=")
1209:           .append(path)
1222:       XMLUtils.addSaxString(contentHandler, "PATH", path);
1228:       this.path = st.getValue("PATH");
1522:       path = null;
1527:       this.path = path;
1539:       FSImageSerialization.writeString(path, out);
1554:       this.path = FSImageSerialization.readString(in);
1570:           .append(", path=")
1571:           .append(path)
1587:       XMLUtils.addSaxString(contentHandler, "PATH", path);
1595:       this.path = st.getValue("PATH");
1624:       path = null;
1637:       this.path = path;
1665:       FSImageSerialization.writeString(path, out);
1694:       this.path = FSImageSerialization.readString(in);
1728:           .append(", path=")
1729:           .append(path)
1752:       XMLUtils.addSaxString(contentHandler, "PATH", path);
1767:       this.path = st.getValue("PATH");
2419:       path = null;
2425:       this.path = path;
2442:       FSImageSerialization.writeString(path, out);
2457:       this.path = FSImageSerialization.readString(in);
2474:           .append(", path=")
2475:           .append(path)
2492:       XMLUtils.addSaxString(contentHandler, "PATH", path);
2501:       this.path = st.getValue("PATH");
2529:       path = null;
2542:       this.path = path;
2569:       FSImageSerialization.writeString(path, out);
2595:       this.path = FSImageSerialization.readString(in);
2619:           .append(", path=")
2620:           .append(path)
2644:       XMLUtils.addSaxString(contentHandler, "PATH", path);
2658:       this.path = st.getValue("PATH");
2985:       path = null;
2995:       this.path = path;
3008:       FSImageSerialization.writeString(path, out);
3016:       this.path = FSImageSerialization.readString(in);
3025:           .append(", path=")
3026:           .append(path)
3040:       XMLUtils.addSaxString(contentHandler, "PATH", path);
3046:       this.path = st.getValue("PATH");
3464:     /* set the directory path where the snapshot is taken. */
3556:     /* set the directory path where the snapshot is taken. */
3902:           .append("path=" + directive.getPath().toUri().getPath() + ",")
3969:         builder.append(",").append("path=").append(directive.getPath());
4837:       path = null;
4842:       this.path = path;
4853:       FSImageSerialization.writeString(path, out);
4860:       this.path = FSImageSerialization.readString(in);
4867:       builder.append("SetStoragePolicyOp [path=")
4868:           .append(path)
4881:       XMLUtils.addSaxString(contentHandler, "PATH", path);
4888:       this.path = st.getValue("PATH");
3866:       assert(directive.getPath() != null);
3968:       if (directive.getPath() != null) {
github.com/bazelbuild/bazel:src/main/java/com/google/devtools/build/lib/buildeventstream/proto/build_event_stream.proto: [ master, ]
776:   string path = 1;
417:   repeated string path_prefix = 4;
412:   // A sequence of prefixes to apply to the file name to construct a full path.
456:   // (e.g., a file path).
460:   // (e.g., a file path).
632:   // Path to logs of passed runs.
635:   // Path to logs of failed runs;
758: // The message that contains what type of action to perform on a given path and
772:   // The path of the symlink to be created or deleted, absolute or relative to
781:   // If action is CREATE, this is the target path that the symlink should point
782:   // to. If the path points underneath the output base, it is relative to the
475:   // List of paths to log files
github.com/google/error-prone:check_api/src/main/java/com/google/errorprone/util/ASTHelpers.java: [ master, ]
1393:     public abstract TreePath path();
360:   public static <T> TreePath findPathFromEnclosingNodeToTopLevel(TreePath path, Class<T> klass) {
357:    * Given a TreePath, finds the first enclosing node of the given type and returns the path from
361:     if (path != null) {
363:         path = path.getParentPath();
364:       } while (path != null && !(klass.isInstance(path.getLeaf())));
366:     return path;
374:   public static <T> T findEnclosingNode(TreePath path, Class<T> klass) {
375:     path = findPathFromEnclosingNodeToTopLevel(path, klass);
376:     return (path == null) ? null : klass.cast(path.getLeaf());
1248:    * The return value is normalized to always use '/' to separate elements of the path and to always
1260:    * normalized to always use '/' to separate elements of the path and to always have a leading '/'.
1395:     static TargetType create(Type type, TreePath path) {
1396:       return new AutoValue_ASTHelpers_TargetType(type, path);
1453:    * Returns the target type of the tree at the given {@link VisitorState}'s path, or else {@code
1640:       for (TreePath path = parent; path != null; path = path.getParentPath()) {
1641:         Tree enclosing = path.getLeaf();
90: import com.sun.source.util.TreePath;
370:    * Given a TreePath, walks up the tree until it finds a node of the given type. Returns null if no
738:             /* @Inherited won't work if the annotation isn't on the classpath, but we can still
1009:     JCCompilationUnit compilationUnit = (JCCompilationUnit) state.getPath().getCompilationUnit();
1023:     TreePath pathToExpr = new TreePath(state.getPath(), expr);
1024:     return nullnessAnalysis.getNullness(pathToExpr, state.context);
1145:    * Returns true if the leaf node in the {@link TreePath} from {@code state} sits somewhere
1149:     for (Tree ancestor : state.getPath()) {
1164:    * Returns true if the leaf node in the {@link TreePath} from {@code state} sits somewhere
1168:     for (Tree ancestor : state.getPath()) {
1265:       return uri.getPath();
1270:       // It's possible (though it violates the zip file spec) for paths to zip file entries to use
1344:     return Streams.stream(state.getPath())
1461:     if (!canHaveTargetType(state.getPath().getLeaf())) {
1465:     TreePath parent = state.getPath();
1468:       parent = parent.getParentPath();
1519:     private final TreePath parent;
1522:     private TargetTypeVisitor(ExpressionTree current, VisitorState state, TreePath parent) {
1558:       SwitchTree switchTree = (SwitchTree) parent.getParentPath().getLeaf();
github.com/apache/zookeeper:zookeeper-server/src/main/java/org/apache/zookeeper/server/ZooKeeperServer.java: [ master, ]
913:         String path;
203:     final Map<String, ChangeRecord> outstandingChangesForPath = new HashMap<String, ChangeRecord>();
1972:     private String parentPath(String path) throws KeeperException.BadArgumentsException {
1980:     private String effectiveACLPath(Request request) throws KeeperException.BadArgumentsException, KeeperException.InvalidACLException ...(1 bytes skipped)...
182:     private final RequestPathMetricsCollector requestPathMetricsCollector;
389:     public RequestPathMetricsCollector getRequestPathMetricsCollector() {
273:      * When a request is completed or dropped, the relevant code path calls the
533:         File path = zkDb.snapLog.getDataDir();
534:         return getDirSize(path);
542:         File path = zkDb.snapLog.getSnapDir();
543:         return getDirSize(path);
903:         ChangeRecord(long zxid, String path, StatPersisted stat, int childCount, List<ACL> acl) {
905:             this.path = path;
926:             ChangeRecord changeRecord = new ChangeRecord(zxid, path, stat, childCount,
1751:                     if (outstandingChangesForPath.get(cr.path) == cr) {
1752:                         outstandingChangesForPath.remove(cr.path);
1914:      * @param path :    the ZNode path
1917:     public void checkACL(ServerCnxn cnxn, List<ACL> acl, int perm, List<Id> ids, String path, List<ACL> setAcls) throws KeeperException.NoAuthException {
1946:                                 new ServerAuthenticationProvider.MatchValues(path, authId.getId(), id.getId(), perm, setAcls))) {
1966:      * Trim a path to get the immediate predecessor.
1968:      * @param path
1973:         int lastSlash = path.lastIndexOf('/');
1974:         if (lastSlash == -1 || path.indexOf('\0') != -1 || getZKDatabase().isSpecialPath(path)) {
1975:             throw new KeeperException.BadArgumentsException(path);
1977:         return lastSlash == 0 ? "/" : path.substring(0, lastSlash);
1982:         String path = null;
1992:                 path = parentPath(req.getPath());
1999:                 path = parentPath(req.getPath());
2006:                 path = req.getPath();
2015:                 path = req.getPath();
2026:             PrepRequestProcessor.fixupACL(path, request.authInfo, acl);
2029:         return path;
2086:             LOG.debug("ACL check against illegal node path: {}", e.getMessage());
403:         pwriter.println(zkDb.snapLog.getSnapDir().getAbsolutePath());
407:         pwriter.println(zkDb.snapLog.getDataDir().getAbsolutePath());
428:             zkDb.snapLog.getSnapDir().getAbsolutePath(),
429:             zkDb.snapLog.getDataDir().getAbsolutePath(),
2064:         String pathToCheck;
2073:             pathToCheck = effectiveACLPath(request);
2074:             if (pathToCheck != null) {
2075:                 checkACL(request.cnxn, zkDb.getACL(pathToCheck, null), effectiveACLPerms(request), request.authInfo, pathToCheck, null);
81: import org.apache.zookeeper.server.util.RequestPathMetricsCollector;
300:         this.requestPathMetricsCollector = new RequestPathMetricsCollector();
338:         this.requestPathMetricsCollector = new RequestPathMetricsCollector();
390:         return requestPathMetricsCollector;
681:         requestPathMetricsCollector.start();
834:         requestPathMetricsCollector.shutdown();
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/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/apache/zookeeper:zookeeper-server/src/main/java/org/apache/zookeeper/KeeperException.java: [ master, ]
513:     private String path;
546:     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;
519:     KeeperException(Code code, String path) {
521:         this.path = path;
543:      * Read the path for this exception
544:      * @return the path associated with this error, null if none
547:         return path;
552:         if (path == null || path.isEmpty()) {
555:         return "KeeperErrorCode = " + getCodeMessage(code) + " for " + path;
607:         public BadArgumentsException(String path) {
608:             super(Code.BADARGUMENTS, path);
622:         public BadVersionException(String path) {
623:             super(Code.BADVERSION, path);
661:         public InvalidACLException(String path) {
662:             super(Code.INVALIDACL, path);
736:         public NoChildrenForEphemeralsException(String path) {
737:             super(Code.NOCHILDRENFOREPHEMERALS, path);
751:         public NodeExistsException(String path) {
752:             super(Code.NODEEXISTS, path);
766:         public NoNodeException(String path) {
767:             super(Code.NONODE, path);
781:         public NotEmptyException(String path) {
782:             super(Code.NOTEMPTY, path);
905:         public NoWatcherException(String path) {
906:             super(Code.NOWATCHER, path);
920:         public ReconfigDisabledException(String path) {
921:             super(Code.RECONFIGDISABLED, path);
934:         public SessionClosedRequireAuthException(String path) {
935:             super(Code.SESSIONCLOSEDREQUIRESASLAUTH, path);
github.com/apache/shiro:web/src/main/java/org/apache/shiro/web/servlet/SimpleCookie.java: [ master, ]
79:     private String path;
63:     protected static final String PATH_ATTRIBUTE_NAME = "Path";
146:     public String getPath() {
150:     public void setPath(String path) {
202:     private String calculatePath(HttpServletRequest request) {
299:     private void appendPath(StringBuilder sb, String path) {
368:     private boolean pathMatches(String cookiePath, String requestPath) {
103:         this.path = cookie.getPath();
147:         return path;
151:         this.path = path;
195:      * Returns the Cookie's calculated path setting.  If the {@link javax.servlet.http.Cookie#getPath() path} is {@code null}, then the
196:      * {@code request}'s {@link javax.servlet.http.HttpServletRequest#getContextPath() context path}
197:      * will be returned. If getContextPath() is the empty string or null then the ROOT_PATH constant is returned.
200:      * @return the path to be used as the path when the cookie is created or removed
203:         String path = StringUtils.clean(getPath());
204:         if (!StringUtils.hasText(path)) {
205:             path = StringUtils.clean(request.getContextPath());
209:         if (path == null) {
210:             path = ROOT_PATH;
212:         log.trace("calculated path: {}", path);
213:         return path;
222:         String path = calculatePath(request);
229:         addCookieHeader(response, name, value, comment, domain, path, maxAge, version, secure, httpOnly, sameSite);
233:                                  String domain, String path, int maxAge, int version,
236:         String headerValue = buildHeaderValue(name, value, comment, domain, path, maxAge, version, secure, httpOnly, sameSite);
252:                                       String domain, String path, int maxAge, int version,
255:         return buildHeaderValue(name, value, comment, domain, path, maxAge, version, secure, httpOnly, getSameSite());
259:                                       String domain, String path, int maxAge, int version,
274:         appendPath(sb, path);
300:         if (StringUtils.hasText(path)) {
302:             sb.append(PATH_ATTRIBUTE_NAME).append(NAME_VALUE_DELIMITER).append(path);
366:      * @see <a href="https://tools.ietf.org/html/rfc6265#section-5.1.4">RFC 6265, Section 5.1.4 "Paths and Path-Match"</a>
396:         String path = calculatePath(request);
403:         addCookieHeader(response, name, value, comment, domain, path, maxAge, version, secure, httpOnly, sameSite);
414:             String path = StringUtils.clean(getPath());
415:             if (path != null && !pathMatches(path, request.getRequestURI())) {
416:                 log.warn("Found '{}' cookie at path '{}', but should be only used for '{}'", 
417:                 		new Object[] { name, Encode.forHtml(request.getRequestURI()), path});
361:      * Check whether the given {@code cookiePath} matches the {@code requestPath}
363:      * @param cookiePath
364:      * @param requestPath
369:         if (!requestPath.startsWith(cookiePath)) {
373:         return requestPath.length() == cookiePath.length()
374:             || cookiePath.charAt(cookiePath.length() - 1) == '/'
375:             || 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/pdfbox:pdfbox/src/main/java/org/apache/pdfbox/cos/COSName.java: [ trunk, ]
440:     public static final COSName PATH = new COSName("Path");
github.com/apache/zeppelin:zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/Note.java: [ master, ]
123:   private String path;
159:   public String getPath() {
163:   public String getParentPath() {
239:   public void setPath(String path) {
76:   // serialize Paragraph#runtimeInfos and Note#path to frontend but not to note file
80:       return f.getName().equals("path");
120:   // The front end needs to judge TRASH_FOLDER according to the path,
138:   public Note(String path, String defaultInterpreterGroup, InterpreterFactory factory,
141:     setPath(path);
160:     return path;
164:     int pos = path.lastIndexOf("/");
168:       return path.substring(0, pos);
172:   private String getName(String path) {
173:     int pos = path.lastIndexOf("/");
174:     return path.substring(pos + 1);
240:     if (!path.startsWith("/")) {
241:       this.path = "/" + path;
243:       this.path = path;
245:     this.name = getName(path);
282:     // for the notes before 0.9, get path from name.
283:     if (this.path == null) {
285:         this.path = name;
287:         this.path = "/" + name;
290:       int pos = this.path.lastIndexOf("/");
291:       this.path = this.path.substring(0, pos + 1) + this.name;
322:           if (this.path.startsWith(folder)) {
877:     return this.path.startsWith("/" + NoteManager.TRASH_FOLDER);
1092:     if (this.path != null) {
1093:       return this.path;
1167:     //TODO(zjffdu) exclude path because FolderView.index use Note as key and consider different path
1169:     //    if (path != null ? !path.equals(note.path) : note.path != null) return false;
1187:     //    result = 31 * result + (path != null ? path.hashCode() : 0);
156:     setPath(noteInfo.getPath());
github.com/apache/tinkerpop:gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/GraphTraversal.java: [ master, ]
640:     public default GraphTraversal<S, Path> path() {
2983:         public static final String path = "path";
1888:     public default GraphTraversal<S, E> simplePath() {
1900:     public default GraphTraversal<S, E> cyclicPath() {
2570:     public default GraphTraversal<S, Path> shortestPath() {
3026:         public static final String simplePath = "simplePath";
3027:         public static final String cyclicPath = "cyclicPath";
3059:         public static final String shortestPath = "shortestPath";
30: import org.apache.tinkerpop.gremlin.process.traversal.Path;
475:      * Map the {@link Edge} to the incident vertex that was not just traversed from in the path history.
634:      * Map the {@link Traverser} to its {@link Path} history via {@link Traverser#path}.
637:      * @see <a href="http://tinkerpop.apache.org/docs/${project.version}/reference/#path-step" target="_blank">Reference Documentation - Path Step</a>
641:         this.asAdmin().getBytecode().addStep(Symbols.path);
714: ...(2 bytes skipped)...   * Map the {@link Traverser} to a {@link Map} projection of sideEffect values, map values, and/or path values.
716:      * @param pop             if there are multiple objects referenced in the path, the {@link Pop} to use.
735: ...(2 bytes skipped)...   * Map the {@link Traverser} to a {@link Map} projection of sideEffect values, map values, and/or path values.
1286:      * Filters the current object based on the object itself or the path history.
1302:      * Filters the current object based on the object itself or the path history.
1317:      * Filters the current object based on the object itself or the path history.
1882:      * Filter the <code>E</code> object if its {@link Traverser#path} is not {@link Path#isSimple}.
1894:      * Filter the <code>E</code> object if its {@link Traverser#path} is {@link Path#isSimple}.
2565:      * Executes a Shortest Path algorithm over the graph.
2578:         return (GraphTraversal<S, Path>) ((Traversal.Admin) this.asAdmin())
64: import org.apache.tinkerpop.gremlin.process.traversal.step.filter.PathFilterStep;
106: import org.apache.tinkerpop.gremlin.process.traversal.step.map.PathStep;
636:      * @return the traversal with an appended {@link PathStep}.
642:         return this.asAdmin().addStep(new PathStep<>(this.asAdmin()));
1016:      * Aggregates the emanating paths into a {@link Tree} data structure.
1884:      * @return the traversal with an appended {@link PathFilterStep}.
1885:      * @see <a href="http://tinkerpop.apache.org/docs/${project.version}/reference/#simplepath-step" target="_blank">Reference Documentation - SimplePath Step</a>
1889:         this.asAdmin().getBytecode().addStep(Symbols.simplePath);
1890:         return this.asAdmin().addStep(new PathFilterStep<E>(this.asAdmin(), true));
1896:      * @return the traversal with an appended {@link PathFilterStep}.
1897:      * @see <a href="http://tinkerpop.apache.org/docs/${project.version}/reference/#cyclicpath-step" target="_blank">Reference Documentation - CyclicPath Step</a>
1901:         this.asAdmin().getBytecode().addStep(Symbols.cyclicPath);
1902:         return this.asAdmin().addStep(new PathFilterStep<E>(this.asAdmin(), false));
2063:      * Aggregates the emanating paths into a {@link Tree} data structure.
2568:      * @see <a href="http://tinkerpop.apache.org/docs/${project.version}/reference/#shortestpath-step" target="_blank">Reference Documentation - ShortestPath Step</a>
2577:         this.asAdmin().getBytecode().addStep(Symbols.shortestPath);
27: import org.apache.tinkerpop.gremlin.process.computer.traversal.step.map.ShortestPathVertexProgramStep;
2567:      * @return the traversal with the appended {@link ShortestPathVertexProgramStep}
2579:                 .addStep(new ShortestPathVertexProgramStep(this.asAdmin()));
github.com/apache/tinkerpop:gremlin-javascript/src/main/javascript/gremlin-javascript/lib/process/graph-traversal.js: [ master, ]
890:   path(...args) {
1327:   path: (...args) => callOnEmptyTraversal('path', args),
112:   withPath(...args) {
430:   cyclicPath(...args) {
1030:   shortestPath(...args) {
1050:   simplePath(...args) {
1284:   cyclicPath: (...args) => callOnEmptyTraversal('cyclicPath', args),
1338:   simplePath: (...args) => callOnEmptyTraversal('simplePath', args),
886:    * Graph traversal path method.
891:     this.bytecode.addStep('path', args);
108:    * Graph Traversal Source withPath method.
113:     const b = new Bytecode(this.bytecode).addSource('withPath', args);
426:    * Graph traversal cyclicPath method.
431:     this.bytecode.addStep('cyclicPath', args);
1026:    * Graph traversal shortestPath method.
1031:     this.bytecode.addStep('shortestPath', args);
1046:    * Graph traversal simplePath method.
1051:     this.bytecode.addStep('simplePath', args);
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/google/caja:third_party/java/htmlparser/src/nu/validator/htmlparser/impl/AttributeName.java: [ master, ]
722:     public static final AttributeName PATH = new AttributeName(ALL_NO_NS, SAME_LOCAL("path"), ALL_NO_PREFIX, ALL_NCNAME, false);
934:     public static final AttributeName CLIP_PATH = new AttributeName(ALL_NO_NS, SAME_LOCAL("clip-path"), ALL_NO_PREFIX, ALL_NCNAME, false);
1005:     public static final AttributeName PATHLENGTH = new AttributeName(ALL_NO_NS, SVG_DIFFERENT("pathlength", "pathLength"), ALL_NO_PREFIX, ALL_NCNAME, false);
1120:     public static final AttributeName CLIPPATHUNITS = new AttributeName(ALL_NO_NS, SVG_DIFFERENT("clippathunits", "clipPathUnits"), ALL_NO_PREFIX, ALL_NCNAME, false);
1304:     PATH,
1516:     CLIP_PATH,
1587:     PATHLENGTH,
1702:     CLIPPATHUNITS,
github.com/apache/jena:jena-arq/src/main/java/org/apache/jena/sparql/lang/arq/ARQParser.java: [ master, ]
3481:   final public Path Path() throws ParseException {Path p ;
3283:   final public void TriplesSameSubjectPath(TripleCollector acc) throws ParseException {Node s ;
3328:   final public void PropertyListPath(Node s, TripleCollector acc) throws ParseException {
3437:   final public Path VerbPath() throws ParseException {Node p ; Path path ;
3449:   final public void ObjectListPath(Node s, Node p, Path path, TripleCollector acc) throws ParseException {Node o ;
3467:   final public void ObjectPath(Node s, Node p, Path path, TripleCollector acc) throws ParseException {Node o ;
3473:   final public Path PathUnit() throws ParseException {Path p ;
3487:   final public Path PathAlternative() throws ParseException {Path p1 , p2 ;
3508:   final public Path PathSequence() throws ParseException {Path p1 , p2 ;
3545:   final public Path PathElt() throws ParseException {String str ; Node n ; Path p ;
3563:   final public Path PathEltOrInverse() throws ParseException {String str ; Node n ; Path p ;
3592:   final public Path PathMod(Path p) throws ParseException {long i1 ; long i2 ;
3682:   final public Path PathPrimary() throws ParseException {String str ; Path p ; Node n ;
3740:   final public Path PathNegatedPropertySet() throws ParseException {P_Path0 p ; P_NegPropSet pNegSet ;
3795:   final public P_Path0 PathOneInPropertySet() throws ParseException {String str ; Node n ;
3874:   final public Node TriplesNodePath(TripleCollectorMark acc) throws ParseException {Node n ;
3894:   final public Node BlankNodePropertyListPath(TripleCollector acc) throws ParseException {Token t ;
3959:   final public Node CollectionPath(TripleCollectorMark acc) throws ParseException {Node listHead = nRDFnil ; Node lastCell = null ; in...(27 bytes skipped)...
4059:   final public Node GraphNodePath(TripleCollectorMark acc) throws ParseException {Node n ;
3351:   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) ;
3363:       path = VerbPath();
3376:     ObjectListPath(s, p, path, acc);
3389: path = null ; p = null ;
3414:           path = VerbPath();
3427:         ObjectListPath(s, p, path, acc);
3438:     path = Path();
3439: {if ("" != null) return path ;}
3450:     ObjectPath(s, p, path, acc);
3463:       ObjectPath(s, p, path, acc);
3470: insert(tempAcc, mark, s, p, path, o) ; insert(acc, tempAcc) ;
3475:     p = Path();
3703:       p = Path();
3710:       p = Path();
3718:       p = Path();
3726:       p = Path();
2450:     TriplesSameSubjectPath(acc);
3316:       s = TriplesNodePath(tempAcc);
3317:       PropertyListPath(s, tempAcc);
3469:     o = GraphNodePath(tempAcc);
3482:     p = PathAlternative();
3488:     p1 = PathSequence();
3501:       p2 = PathSequence();
3502: p1 = PathFactory.pathAlt(p1, p2) ;
3509:     p1 = PathEltOrInverse();
3525:         p2 = PathEltOrInverse();
3526: p1 = PathFactory.pathSeq(p1, p2) ;
3531:         p2 = PathElt();
3532: p1 = PathFactory.pathSeq(p1, new P_Inverse(p2)) ;
3546:     p = PathPrimary();
3552:       p = PathMod(p);
3574:       p = PathElt();
3579:       p = PathElt();
3580: p = PathFactory.pathInverse(p) ;
3596: {if ("" != null) return PathFactory.pathZeroOrOne(p) ;}
3601: {if ("" != null) return PathFactory.pathZeroOrMore1(p) ;}
3606: {if ("" != null) return PathFactory.pathOneOrMore1(p) ;}
3615: {if ("" != null) return PathFactory.pathZeroOrMoreN(p) ;}
3621: {if ("" != null) return PathFactory.pathOneOrMoreN(p) ;}
3632: {if ("" != null) return PathFactory.pathMod(p, i1, PathFactory.UNSET) ;}
3638: {if ("" != null) return PathFactory.pathMod(p, i1, i2) ;}
3650: {if ("" != null) return PathFactory.pathFixedLength(p, i1) ;}
3664: {if ("" != null) return PathFactory.pathMod(p, PathFactory.UNSET, i2) ;}
3688: n = createNode(str) ; p = PathFactory.pathLink(n) ;
3693: p = PathFactory.pathLink(nRDFtype) ;
3698:       p = PathNegatedPropertySet();
3711: p = PathFactory.pathDistinct(p) ;
3719: p = PathFactory.pathShortest(p) ;
3727: p = PathFactory.pathMulti(p) ;
3748:       p = PathOneInPropertySet();
3760:         p = PathOneInPropertySet();
3774:           p = PathOneInPropertySet();
3877:       n = CollectionPath(acc);
3882:       n = BlankNodePropertyListPath(acc);
3970:       n = GraphNodePath(acc);
4091:       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() ;
3310:       PropertyListPathNotEmpty(s, acc);
3315: ElementPathBlock tempAcc = new ElementPathBlock() ;
3342:       PropertyListPathNotEmpty(s, acc);
3468: ElementPathBlock tempAcc = new ElementPathBlock() ; int mark = tempAcc.mark() ;
3897:     PropertyListPathNotEmpty(n, acc);
github.com/apache/cloudstack:api/src/main/java/org/apache/cloudstack/api/ApiConstants.java: [ master, ]
275:     public static final String PATH = "path";
66:     public static final String DATASTORE_PATH = "datastorepath";
136:     public static final String DOMAIN_PATH = "domainpath";
191:     public static final String IMAGE_PATH = "imagepath";
712:     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, ]
1618:         private File path = new File("");
1888:         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;
889:         public String getDiskPath() {
905:         public void setDiskPath(String volPath) {
1140:         private String _scriptPath;
1149:         private String _dpdkSourcePath;
1311:         public String getDpdkOvsPath() {
1315:         public void setDpdkOvsPath(String path) {
1396:         private final String _ttyPath;
1658:         public File getPath() {
1812:         private final String _sourcePath;
1813:         private final String _targetPath;
1929:         public String getPath() {
1316:             _dpdkSourcePath = path;
1336:                 netBuilder.append("<source type='unix' path='"+ _dpdkSourcePath + _dpdkSourcePort +
1355:                 netBuilder.append("<script path='" + _scriptPath + "'/>\n");
1401:         public ConsoleDef(String type, String path, String source, short port) {
1403:             _ttyPath = path;
1418:                 consoleBuilder.append("<source path='" + _source + "'/>\n");
1556:                 serialBuidler.append("<source path='" + _source + "'/>\n");
1627:         public ChannelDef(String name, ChannelType type, File path) {
1629:             this.path = path;
1639:         public ChannelDef(String name, ChannelType type, ChannelState state, File path) {
1641:             this.path = path;
1659:             return path;
1666:             if (path == null) {
1669:                 virtioSerialBuilder.append("<source mode='bind' path='" + path.toString() + "'/>\n");
1894:         public RngDef(String path) {
1895:             this.path = path;
1898:         public RngDef(String path, int rngRateBytes, int rngRatePeriod) {
1899:             this.path = path;
1912:         public RngDef(String path, RngBackendModel rngBackendModel) {
1913:             this.path = path;
1917:         public RngDef(String path, RngBackendModel rngBackendModel, int rngRateBytes, int rngRatePeriod) {
1918:             this.path = path;
1924:         public RngDef(String path, RngModel rngModel) {
1925:             this.path = path;
1930:            return path;
1954:             rngBuilder.append("<backend model='" + rngBackendModel + "'>" + path + "</backend>");
697:         public void defFileBasedDisk(String filePath, String diskLabel, DiskBus bus, DiskFmtType diskFmtType) {
701:             _sourcePath = filePath;
748:         public void defFileBasedDisk(String filePath, int devId, DiskBus bus, DiskFmtType diskFmtType) {
753:             _sourcePath = filePath;
760:         public void defFileBasedDisk(String filePath, int devId, DiskFmtType diskFmtType,boolean isWindowsOS) {
765:             _sourcePath = filePath;
777:         public void defISODisk(String volPath) {
780:             _sourcePath = volPath;
787:         public void defISODisk(String volPath, Integer devId) {
789:                 defISODisk(volPath);
793:                 _sourcePath = volPath;
801:         public void defISODisk(String volPath, Integer devId,boolean isSecure, boolean isWindowOs) {
803:                 defISODisk(volPath, devId);
807:                 _sourcePath = volPath;
826:             _sourcePath = diskName;
836:             _sourcePath = diskName;
847:             _sourcePath = diskName;
863:             _sourcePath = diskName;
890:             return _sourcePath;
906:             _sourcePath = volPath;
1009:                 if (_sourcePath != null) {
1010:                     diskBuilder.append("file='" + _sourcePath + "'");
1017:                 if (_sourcePath != null) {
1018:                     diskBuilder.append(" dev='" + _sourcePath + "'");
1024:                 diskBuilder.append(" name='" + _sourcePath + "'");
1167:         public void defDpdkNet(String dpdkSourcePath, String dpdkPort, String macAddress, NicModel model,
1170:             _dpdkSourcePath = dpdkSourcePath;
1206:         public void defEthernet(String targetName, String macAddr, NicModel model, String scriptPath) {
1207:             defEthernet(targetName, macAddr, model, scriptPath, 0);
1210:         public void defEthernet(String targetName, String macAddr, NicModel model, String scriptPath, Integer networkRateKBps) {
1216:             _scriptPath = scriptPath;
1312:             return _dpdkSourcePath;
1354:             if (_scriptPath != null) {
1413:             if (_ttyPath != null) {
1414:                 consoleBuilder.append("tty='" + _ttyPath + "'");
1815:         public FilesystemDef(String sourcePath, String targetPath) {
1816:             _sourcePath = sourcePath;
1817:             _targetPath = targetPath;
1824:             fsBuilder.append("  <source dir='" + _sourcePath + "'/>\n");
1825:             fsBuilder.append("  <target dir='" + _targetPath + "'/>\n");
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/google/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,
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/libcore:benchmarks/src/benchmarks/regression/R.java: [ master, ] Duplicate result
android.googlesource.com/platform/superproject:libcore/benchmarks/src/benchmarks/regression/R.java: [ master, ] Duplicate result
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/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/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.
7583:                 Slog.w(TAG, "Failed to remove code path", e);
7671:         for (String path : pkg.getAllCodePathsExcludingResourceOnly()) {
7673:                 path = PackageManagerServiceUtils.realpath(new File(path));
7676:                 Slog.w(TAG, "Failed to get canonical path", e);
7680:             final String useMarker = path.replace('/', '@');
7698:                     // to the package. Reconstructing the path of these dex files is messy
7767:         if (file.path != null) {
7768:             usesLibraryFiles.add(file.path);
8100:             // scanned APK is both already known and at the path previously established
8276:                 // Check all shared libraries and map to their actual file path.
8399:         final String path = scanFile.getPath();
8418:                 // use that and derive the native library path based on the new codepath.
8423:             // Set native library paths again. For moves, the path will be updated based on the
8424:             // ABIs we've determined above. For non-moves, the path will be updated based on the
8425:             // ABIs we determined during compilation, but the path will depend on the final
8426:             // package path (after the rename away from the stage path).
8464:         // Push the derived path down into PackageSettings so we know what to
8480:             // code and package path correct.
9001:             Slog.w(TAG, "Failed to get canonical path.", e);
9007:         // that the last component of the path (i.e, the name) doesn't need canonicalization
9349:             // Unrecognized code path; take its top real segment as the apk root:
9360:                 Slog.w(TAG, "Unrecognized code path "
9363:                 // Can't canonicalize the code path -- shenanigans?
9364:                 Slog.w(TAG, "Can't canonicalize code path " + codePath);
9396:                 // This is a bundled system app so choose the path based on the ABI.
9398:                 // is just the default path.
12667:         for (File path : paths) {
12668:             result += mcs.calculateDirectorySize(path.getAbsolutePath());
12674:         for (File path : paths) {
12676:                 mcs.clearDirectory(path.getAbsolutePath());
13294:         // if we move dex files under the common app path.
13615:      * Extract the MountService "container ID" from the full code path of an
13652:             // Hackily pretend we're still looking at a full code path
13769:                 Slog.w(TAG, "Failed to get cache path for  " + newCacheId);
13774:                     " at new path: " + newMountPath);
14089:     // Utility method that returns the relative package path with respect
14319:                         for (String path : pkg.splitCodePaths) {
14320:                             updateDigest(digest, new File(path));
14704:         // Remove the lib path for the parent package
14707:             // Remove the lib path for the child packages
14943:         if (DEBUG_INSTALL) Slog.d(TAG, "installPackageLI: path=" + tmpPackageFile);
15034:         // Get rid of all references to package scan path via parser.
15952:     static boolean locationIsPrivileged(File path) {
15956:             return path.getCanonicalPath().startsWith(privilegedAppDir);
15958:             Slog.e(TAG, "Unable to access code path " + path);
18623:                     if (ent.path != null) {
18626:                             pw.print(ent.path);
18629:                             pw.print(ent.path);
19151:                     // The package status is changed only if the code path
19157:                                     + " at code path: " + ps.codePathString);
19252:                 // Check code path here.
19561:         // Try very hard to release any references to this path so we don't risk
587:     // Tracks available target package names -> overlay package paths.
676:     // Mapping from provider base names (first directory in content URI codePath)
1692:                 mProcessLoggingHandler.invalidateProcessLoggingBaseApkHash(res.pkg.baseCodePath);
2134:             mAsecInternalPath = new File(dataDir, "app-asec").getPath();
2169:                 if (!isExternal(ps) && (ps.codePath == null || !ps.codePath.exists())
2194:             // Set flag to monitor and not change apk file paths when
2196:             final int scanFlags = SCAN_NO_PATHS | SCAN_DEFER_DEX | SCAN_BOOTING | SCAN_INITIAL;
2198:             final String bootClassPath = System.getenv("BOOTCLASSPATH");
2199:             final String systemServerClassPath = System.getenv("SYSTEMSERVERCLASSPATH");
2201:             if (bootClassPath == null) {
2202:                 Slog.w(TAG, "No BOOTCLASSPATH found!");
2205:             if (systemServerClassPath == null) {
2206:                 Slog.w(TAG, "No SYSTEMSERVERCLASSPATH found!");
2356:                                     + ps.name + "; removing system app.  Last known codePath="
2361:                             mExpectingBetter.put(ps.name, ps.codePath);
2375:                         if (disabledPs.codePath == null || !disabledPs.codePath.exists()) {
2521:             // the correct library paths.
5428:                 ephemeralInstaller.filter.addDataPath(
5429:                         intent.getData().getPath(), PatternMatcher.PATTERN_LITERAL);
6598:             Slog.w(TAG, "Skipping target and overlay pair " + pkg.baseCodePath + " and " +
6599:                     opkg.baseCodePath + ": overlay not trusted");
6604:             Slog.e(TAG, "was about to create idmap for " + pkg.baseCodePath + " and " +
6605:                     opkg.baseCodePath + " but target package has no known overlays");
6611:             mInstaller.idmap(pkg.baseCodePath, opkg.baseCodePath, sharedGid);
6613:             Slog.e(TAG, "Failed to generate idmap for " + pkg.baseCodePath + " and "
6614:                     + opkg.baseCodePath);
6629:             pkg.applicationInfo.resourceDirs[i++] = p.baseCodePath;
6710:             final File baseFile = new File(pkg.baseCodePath);
6728:                 ? new File(pkg.codePath).lastModified() : getLastModifiedTime(pkg, srcFile);
6730:                 && ps.codePath.equals(srcFile)
6917:             if (ps != null && !ps.codePath.equals(scanFile)) {
6928:                     if (!updatedPkg.codePath.equals(scanFile)) {
6932:                         updatedPkg.codePath = scanFile;
6934:                         updatedPkg.resourcePath = scanFile;
7057:             if (ps != null && !ps.codePath.equals(ps.resourcePath)) {
7063:         String resourcePath = null;
7064:         String baseResourcePath = null;
7067:                 resourcePath = ps.resourcePathString;
7068:                 baseResourcePath = ps.resourcePathString;
7074:             resourcePath = pkg.codePath;
7075:             baseResourcePath = pkg.baseCodePath;
7080:         pkg.setApplicationInfoCodePath(pkg.codePath);
7081:         pkg.setApplicationInfoBaseCodePath(pkg.baseCodePath);
7083:         pkg.setApplicationInfoResourcePath(resourcePath);
7084:         pkg.setApplicationInfoBaseResourcePath(baseResourcePath);
7579:         if (codePath.isDirectory()) {
7581:                 mInstaller.rmPackageDir(codePath.getAbsolutePath());
7586:             codePath.delete();
7931:                 // DELETE_DATA_ON_FAILURES is only used by frozen paths
7970:         if (shouldHaveCode && !apkHasCode(pkg.baseCodePath)) {
7972:                     "Package " + pkg.baseCodePath + " code is missing");
7990:         final File scanFile = new File(pkg.codePath);
7991:         if (pkg.applicationInfo.getCodePath() == null ||
7992:                 pkg.applicationInfo.getResourcePath() == null) {
7993:             // Bail out. The resource and code paths haven't been set.
7995:                     "Code and resource paths haven't been set correctly");
8104:             // a new system package, we allow the codepath to change from a system location
8115:                             Log.d(TAG, "Examining " + pkg.codePath
8116:                                     + " and requiring known paths " + known.codePathString
8119:                         if (!pkg.applicationInfo.getCodePath().equals(known.codePathString)
8120:                                 || !pkg.applicationInfo.getResourcePath().equals(
8124:                                             + " found at " + pkg.applicationInfo.getCodePath()
8134:         File destCodeFile = new File(pkg.applicationInfo.getCodePath());
8135:         File destResourceFile = new File(pkg.applicationInfo.getResourcePath());
8280:                 // library paths after the scan is done.
8395:             // Get all of our default paths setup
8611:                 // Note that |user| might be null during the initial boot scan. If a codePath
8989:         final File oldCodePath = new File(existing.applicationInfo.getCodePath());
8990:         final File newCodePath = new File(update.applicationInfo.getCodePath());
8992:         // The codePath hasn't changed, so there's nothing for us to do.
8993:         if (Objects.equals(oldCodePath, newCodePath)) {
8997:         File canonicalNewCodePath;
8999:             canonicalNewCodePath = new File(PackageManagerServiceUtils.realpath(newCodePath));
9005:         // This is a bit of a hack. The oldCodePath doesn't exist at this point (because
9006:         // we've already renamed / deleted it) so we cannot call realpath on it. Here we assume
9010:         final File canonicalOldCodePath = new File(canonicalNewCodePath.getParentFile(),
9011:                 oldCodePath.getName());
9013:         // Calculate the prefixes of the markers. These are just the paths with "/" replaced
9015:         String oldMarkerPrefix = canonicalOldCodePath.getAbsolutePath().replace('/', '@');
9019:         String newMarkerPrefix = canonicalNewCodePath.getAbsolutePath().replace('/', '@');
9026:         for (String updatedPath : updatedPaths) {
9027:             String updatedPathName = new File(updatedPath).getName();
9039:                         Os.rename(oldForeignUseMark.getAbsolutePath(),
9040:                                 newForeignUseMark.getAbsolutePath());
9065:         // Give ourselves some initial paths; we'll come back for another
9192:         // we will go ahead and populate the nativeLibraryPath.
9340:         final File codePath = new File(codePathString);
9342:         if (FileUtils.contains(Environment.getRootDirectory(), codePath)) {
9344:         } else if (FileUtils.contains(Environment.getOemDirectory(), codePath)) {
9346:         } else if (FileUtils.contains(Environment.getVendorDirectory(), codePath)) {
9352:                 File f = codePath.getCanonicalFile();
9353:                 File parent = f.getParentFile();    // non-null because codePath is a file
9361:                         + codePath + " - using " + codeRoot);
9365:                 return Environment.getRootDirectory().getPath();
9368:         return codeRoot.getPath();
9377:         final String codePath = pkg.codePath;
9378:         final File codeFile = new File(codePath);
9399:                 final String apkName = deriveCodePathName(codePath);
9401:                 info.nativeLibraryRootDir = Environment.buildPath(new File(apkRoot), libDir,
9402:                         apkName).getAbsolutePath();
9406:                     info.secondaryNativeLibraryDir = Environment.buildPath(new File(apkRoot),
9407:                             secondaryLibDir, apkName).getAbsolutePath();
9411:                         .getAbsolutePath();
9413:                 final String apkName = deriveCodePathName(codePath);
9415:                         .getAbsolutePath();
9422:             info.nativeLibraryRootDir = new File(codeFile, LIB_DIR_NAME).getAbsolutePath();
9426:                     getPrimaryInstructionSet(info)).getAbsolutePath();
9430:                         VMRuntime.getInstructionSet(info.secondaryCpuAbi)).getAbsolutePath();
9444:         final String apkName = deriveCodePathName(pkg.applicationInfo.getCodePath());
9471:         final File codeFile = new File(pkg.codePath);
9477:             has64BitLibs = (new File(apkRoot, new File(LIB64_DIR_NAME, apkName).getPath())).exists();
9478:             has32BitLibs = (new File(apkRoot, new File(LIB_DIR_NAME, apkName).getPath())).exists();
11540:     public void installPackageAsUser(String originPath, IPackageInstallObserver2 observer,
11585:         final File originFile = new File(originPath);
12664:     private static long calculateDirectorySize(IMediaContainerService mcs, File[] paths)
12673:     private static void clearDirectory(IMediaContainerService mcs, File[] paths) {
12734:                 resolvedPath = PackageHelper.getSdDir(cid);
12735:                 resolvedFile = new File(resolvedPath);
12737:                 resolvedPath = file.getAbsolutePath();
12740:                 resolvedPath = null;
12959:                 pkgLite = mContainerService.getMinimalPackageInfo(origin.resolvedPath, installFlags,
12978:                             origin.resolvedPath, isForwardLocked(), packageAbiOverride);
12982:                         pkgLite = mContainerService.getMinimalPackageInfo(origin.resolvedPath,
13068:                     verification.setDataAndType(Uri.fromFile(new File(origin.resolvedPath)),
13248:     private InstallArgs createInstallArgsForExisting(int installFlags, String codePath,
13249:             String resourcePath, String[] instructionSets) {
13255:                 && !codePath.startsWith(mDrmAppPrivateInstallDir.getAbsolutePath())) {
13266:             return new AsecInstallArgs(codePath, instructionSets,
13269:             return new FileInstallArgs(codePath, resourcePath, instructionSets);
13321:          * Rename package into final resting place. All paths on the given
13324:         abstract boolean doRename(int status, PackageParser.Package pkg, String oldCodePath);
13377:             for (String codePath : allCodePaths) {
13380:                         mInstaller.rmdex(codePath, dexCodeInstructionSet);
13416:         FileInstallArgs(String codePath, String resourcePath, String[] instructionSets) {
13419:             this.codeFile = (codePath != null) ? new File(codePath) : null;
13420:             this.resourceFile = (resourcePath != null) ? new File(resourcePath) : null;
13459:                         final FileDescriptor fd = Os.open(file.getAbsolutePath(),
13461:                         Os.chmod(file.getAbsolutePath(), 0644);
13470:             ret = imcs.copyPackage(origin.file.getAbsolutePath(), target);
13499:         boolean doRename(int status, PackageParser.Package pkg, String oldCodePath) {
13507:             final File afterCodeFile = getNextCodePath(targetDir, pkg.packageName);
13511:                 Os.rename(beforeCodeFile.getAbsolutePath(), afterCodeFile.getAbsolutePath());
13527:             pkg.setCodePath(afterCodeFile.getAbsolutePath());
13528:             pkg.setBaseCodePath(FileUtils.rewriteAfterRename(beforeCodeFile,
13529:                     afterCodeFile, pkg.baseCodePath));
13535:             pkg.setApplicationInfoCodePath(pkg.codePath);
13536:             pkg.setApplicationInfoBaseCodePath(pkg.baseCodePath);
13538:             pkg.setApplicationInfoResourcePath(pkg.codePath);
13539:             pkg.setApplicationInfoBaseResourcePath(pkg.baseCodePath);
13554:             return (codeFile != null) ? codeFile.getAbsolutePath() : null;
13559:             return (resourceFile != null) ? resourceFile.getAbsolutePath() : null;
13577:             // Try enumerating all code paths before deleting
13600:         final String asecPath = PackageHelper.getSdFilesystem(cid);
13601:         return !asecPath.startsWith(mAsecInternalPath);
13619:         int eidx = fullCodePath.lastIndexOf("/");
13620:         String subStr1 = fullCodePath.substring(0, eidx);
13647:         AsecInstallArgs(String fullCodePath, String[] instructionSets,
13653:             if (!fullCodePath.endsWith(RES_FILE_NAME)) {
13654:                 fullCodePath = new File(fullCodePath, RES_FILE_NAME).getAbsolutePath();
13657:             // Extract cid from fullCodePath
13658:             int eidx = fullCodePath.lastIndexOf("/");
13659:             String subStr1 = fullCodePath.substring(0, eidx);
13662:             setMountPath(subStr1);
13670:             setMountPath(PackageHelper.getSdDir(cid));
13681:                 setMountPath(PackageHelper.getSdDir(cid));
13695:             final String newMountPath = imcs.copyPackageToContainer(
13696:                     origin.file.getAbsolutePath(), cid, getEncryptKey(), isExternalAsec(),
13699:             if (newMountPath != null) {
13700:                 setMountPath(newMountPath);
13709:             return packagePath;
13714:             return resourcePath;
13724:                     String newMountPath = PackageHelper.mountSdDir(cid, getEncryptKey(),
13726:                     if (newMountPath != null) {
13727:                         setMountPath(newMountPath);
13736:         boolean doRename(int status, PackageParser.Package pkg, String oldCodePath) {
13737:             String newCacheId = getNextCodePath(oldCodePath, pkg.packageName, "/" + RES_FILE_NAME);
13738:             String newMountPath = null;
13763:                 newMountPath = PackageHelper.mountSdDir(newCacheId,
13766:                 newMountPath = PackageHelper.getSdDir(newCacheId);
13768:             if (newMountPath == null) {
13777:             final File beforeCodeFile = new File(packagePath);
13778:             setMountPath(newMountPath);
13779:             final File afterCodeFile = new File(packagePath);
13782:             pkg.setCodePath(afterCodeFile.getAbsolutePath());
13783:             pkg.setBaseCodePath(FileUtils.rewriteAfterRename(beforeCodeFile,
13784:                     afterCodeFile, pkg.baseCodePath));
13790:             pkg.setApplicationInfoCodePath(pkg.codePath);
13791:             pkg.setApplicationInfoBaseCodePath(pkg.baseCodePath);
13793:             pkg.setApplicationInfoResourcePath(pkg.codePath);
13794:             pkg.setApplicationInfoBaseResourcePath(pkg.baseCodePath);
13801:             final File mountFile = new File(mountPath);
13805:                 packagePath = monolithicFile.getAbsolutePath();
13807:                     resourcePath = new File(mountFile, PUBLIC_RES_FILE_NAME).getAbsolutePath();
13809:                     resourcePath = packagePath;
13812:                 packagePath = mountFile.getAbsolutePath();
13813:                 resourcePath = packagePath;
13854:             final File codeFile = new File(getCodePath());
13867:             // Enumerate all code paths before deleting
13967:         boolean doRename(int status, PackageParser.Package pkg, String oldCodePath) {
13975:             pkg.setApplicationInfoCodePath(pkg.codePath);
13976:             pkg.setApplicationInfoBaseCodePath(pkg.baseCodePath);
13978:             pkg.setApplicationInfoResourcePath(pkg.codePath);
13979:             pkg.setApplicationInfoBaseResourcePath(pkg.baseCodePath);
13996:             return (codeFile != null) ? codeFile.getAbsolutePath() : null;
14001:             return (resourceFile != null) ? resourceFile.getAbsolutePath() : null;
14042:     // Utility method used to create code paths based on package name and available index.
14047:         // part of oldCodePath
14048:         if (oldCodePath != null) {
14049:             String subStr = oldCodePath;
14054:             // If oldCodePath already contains prefix find out the
14093:         if (codePath == null) {
14096:         final File codeFile = new File(codePath);
14104:             Slog.w(TAG, "Odd, " + codePath + " doesn't look like an APK");
14209:             res.setError("Package couldn't be installed in " + pkg.codePath, e);
14317:                     updateDigest(digest, new File(pkg.baseCodePath));
14465:                 // Update the in-memory copy of the previous code paths.
14471:                     Collections.addAll(ps.oldCodePaths, deletedPackage.baseCodePath);
14488:                 res.setError("Package couldn't be installed in " + pkg.codePath, e);
14504:                 File restoreFile = new File(deletedPackage.codePath);
14576:                     deletedPackage.applicationInfo.getCodePath(),
14577:                     deletedPackage.applicationInfo.getResourcePath(),
14637:             res.setError("Package couldn't be installed in " + pkg.codePath, e);
14851:         if (DEBUG_INSTALL) Slog.d(TAG, "New package installed in " + newPackage.codePath);
14924:         final File tmpPackageFile = new File(args.getCodePath());
15036:         String oldCodePath = null;
15118:                 oldCodePath = mSettings.mPackages.get(pkgName).codePathString;
15206:                 derivePackageAbi(pkg, new File(pkg.codePath), abiOverride,
15239:         if (!args.doRename(res.returnCode, pkg, oldCodePath)) {
15955:                     .getCanonicalPath();
16051:         if (locationIsPrivileged(disabledPs.codePath)) {
16057:             newPkg = scanPackageTracedLI(disabledPs.codePath, parseFlags, SCAN_NO_PATHS, 0, null);
16973:                     "paths, or types; and at most one scheme.");
19154:                             && ps.codePathString.startsWith(args.getCodePath())) {
19167:                         Slog.i(TAG, "Found stale container " + cid + ": expected codePath="
19241:             String codePath = processCids.get(args);
19253:                 if (codePath == null || !codePath.startsWith(args.getCodePath())) {
19254:                     Slog.e(TAG, "Container " + args.cid + " cachepath " + args.getCodePath()
19255:                             + " does not match one in settings " + codePath);
19271:                         pkg = scanPackageTracedLI(new File(codePath), parseFlags,
19274:                         Slog.w(TAG, "Failed to scan " + codePath + ": " + e.getMessage());
19292:                         Slog.i(TAG, "Failed to install pkg from  " + codePath + " from sdcard");
19448:                     pkg = scanPackageTracedLI(ps.codePath, parseFlags, SCAN_INITIAL, 0, null);
19452:                     Slog.w(TAG, "Failed to scan " + ps.codePath + ": " + e.getMessage());
19544:                         Slog.w(TAG, "Failed to unload " + ps.codePath);
19563:         ResourcesManager.getInstance().invalidatePath(vol.getPath().getAbsolutePath());
20025:                 final String nativeLibPath = app.nativeLibraryDir;
20028:                             nativeLibPath, userId);
20248:                 final File probe = new File(pkg.codePath);
20270:             codeFile = new File(pkg.codePath);
20288:         final File measurePath;
20293:             measurePath = Environment.getDataAppDirectory(volumeUuid);
20297:             measurePath = storage.getPrimaryPhysicalVolume().getPath();
20311:             measurePath = Environment.getDataAppDirectory(volumeUuid);
20328:         final long startFreeBytes = measurePath.getFreeSpace();
20336:         if (sizeBytes > storage.getStorageBytesUntilLow(measurePath)) {
20392:                         final long deltaFreeBytes = startFreeBytes - measurePath.getFreeSpace();
2357:                                     + ps.codePathString + ", installStatus=" + ps.installStatus
6672:                     removeCodePathLI(file);
6712:             if (pkg.splitCodePaths != null) {
6713:                 for (int i = pkg.splitCodePaths.length - 1; i >=0; --i) {
6714:                     final File splitFile = new File(pkg.splitCodePaths[i]);
6930:                                 + ps.name + " changing from " + updatedPkg.codePathString
6933:                         updatedPkg.codePathString = scanFile.toString();
6935:                         updatedPkg.resourcePathString = scanFile.toString();
6970:                             + " reverting from " + ps.codePathString
6975:                             ps.codePathString, ps.resourcePathString, getAppDexInstructionSets(ps));
7041:                             + " reverting from " + ps.codePathString + ": new version "
7044:                             ps.codePathString, ps.resourcePathString, getAppDexInstructionSets(ps));
7066:             if (ps != null && ps.resourcePathString != null) {
7082:         pkg.setApplicationInfoSplitCodePaths(pkg.splitCodePaths);
7085:         pkg.setApplicationInfoSplitResourcePaths(pkg.splitCodePaths);
7524:                 List<String> allCodePaths = pkg.getAllCodePathsExcludingResourceOnly();
7526:                 String codePaths = TextUtils.join(";", allCodePaths);
7527:                 mInstaller.dumpProfiles(gid, packageName, codePaths);
7782:             usesLibraryFiles.addAll(p.getAllCodePaths());
7975:         if (!ArrayUtils.isEmpty(pkg.splitCodePaths)) {
7976:             for (int i = 0; i < pkg.splitCodePaths.length; i++) {
7979:                 if (splitShouldHaveCode && !apkHasCode(pkg.splitCodePaths[i])) {
7981:                             "Package " + pkg.splitCodePaths[i] + " code is missing");
8117:                                     + " & " + known.resourcePathString);
8121:                                 known.resourcePathString)) {
8125:                                             + " but expected at " + known.codePathString
8411:                 setNativeLibraryPaths(pkg);
8427:             setNativeLibraryPaths(pkg);
8466:         pkgSetting.legacyNativeLibraryPathString = pkg.applicationInfo.nativeLibraryRootDir;
9024:         List<String> updatedPaths = update.getAllCodePathsExcludingResourceOnly();
9025:         List<String> markerSuffixes = new ArrayList<String>(updatedPaths.size());
9028:             markerSuffixes.add(updatedPathName.replace('/', '@'));
9067:         setNativeLibraryPaths(pkg);
9193:         setNativeLibraryPaths(pkg);
9279:                             mInstaller.rmdex(ps.codePathString,
9339:     private static String calculateBundledApkRoot(final String codePathString) {
13327:         /** @see PackageSettingBase#codePathString */
13329:         /** @see PackageSettingBase#resourcePathString */
13371:     private void removeDexFiles(List<String> allCodePaths, String[] instructionSets) {
13372:         if (!allCodePaths.isEmpty()) {
13530:             pkg.setSplitCodePaths(FileUtils.rewriteAfterRename(beforeCodeFile,
13531:                     afterCodeFile, pkg.splitCodePaths));
13537:             pkg.setApplicationInfoSplitCodePaths(pkg.splitCodePaths);
13540:             pkg.setApplicationInfoSplitResourcePaths(pkg.splitCodePaths);
13567:             removeCodePathLI(codeFile);
13578:             List<String> allCodePaths = Collections.EMPTY_LIST;
13582:                     allCodePaths = pkg.getAllCodePaths();
13589:             removeDexFiles(allCodePaths, instructionSets);
13785:             pkg.setSplitCodePaths(FileUtils.rewriteAfterRename(beforeCodeFile,
13786:                     afterCodeFile, pkg.splitCodePaths));
13792:             pkg.setApplicationInfoSplitCodePaths(pkg.splitCodePaths);
13795:             pkg.setApplicationInfoSplitResourcePaths(pkg.splitCodePaths);
13858:                     return pkg.getAllCodePaths();
13868:             cleanUpResourcesLI(getAllCodePaths());
13871:         private void cleanUpResourcesLI(List<String> allCodePaths) {
13873:             removeDexFiles(allCodePaths, instructionSets);
13882:             final List<String> allCodePaths = getAllCodePaths();
13891:                 cleanUpResourcesLI(allCodePaths);
13977:             pkg.setApplicationInfoSplitCodePaths(pkg.splitCodePaths);
13980:             pkg.setApplicationInfoSplitResourcePaths(pkg.splitCodePaths);
14020:                 removeCodePathLI(codeFile);
14318:                     if (!ArrayUtils.isEmpty(pkg.splitCodePaths)) {
14412:         if (ps != null && ps.oldCodePaths != null) {
14413:             result.addAll(ps.oldCodePaths);
14468:                     if (ps.oldCodePaths == null) {
14469:                         ps.oldCodePaths = new ArraySet<>();
14472:                     if (deletedPackage.splitCodePaths != null) {
14473:                         Collections.addAll(ps.oldCodePaths, deletedPackage.splitCodePaths);
14476:                     ps.oldCodePaths = null;
14482:                         childPs.oldCodePaths = ps.oldCodePaths;
14706:             NativeLibraryHelper.removeNativeBinariesLI(ps.legacyNativeLibraryPathString);
14716:                             .legacyNativeLibraryPathString);
16162:                         ps.codePathString, ps.resourcePathString, getAppDexInstructionSets(ps));
16863:                     ps.getCeDataInode(userId), ps.codePathString, stats);
16968:                 || filter.countDataPaths() != 0
19153:                     if (ps.codePathString != null
19161:                         processCids.put(args, ps.codePathString);
19168:                                 + ps.codePathString);
19777:                     removeCodePathLI(file);
github.com/apache/sqoop:src/java/org/apache/sqoop/io/LobFile.java: [ trunk, ]
1030:     private Path path;
1530:     private Path path;
179:     public abstract Path getPath();
242:     public abstract Path getPath();
1229:     public Path getPath() {
1641:     public Path getPath() {
52: import org.apache.hadoop.fs.Path;
100:       open(Path p, Configuration conf) throws IOException {
121:    * @param p the path to create.
128:             create(Path p, Configuration conf, boolean isCharData,
136:    * @param p the path to create.
142:             create(Path p, Configuration conf, boolean isCharData,
150:    * @param p the path to create.
155:             create(Path p, Configuration conf, boolean isCharData)
162:    * @param p the path to create.
166:             create(Path p, Configuration conf) throws IOException {
176:      * the file path it is writing to. Otherwise it returns null.
177:      * @return the fully-qualified path being written to by this writer.
239:      * the file path it is reading from. Otherwise it returns null.
240:      * @return the fully-qualified path being read by this reader.
1029:     // The path being opened.
1033:     V0Reader(Path path, Configuration conf, LobFileHeader header,
1036:       this.path = LobReaderCache.qualify(path, conf);
1044:       LOG.debug("Opening LobFile path: " + path);
1230:       return this.path;