Found 119704 results in 11824 files, showing top 50 files (show more).
github.com/bazelbuild/rules_closure:java/io/bazel/rules/closure/Webpath.java: [ master, ] java
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, ] java
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, ] java
15: public class Path {
github.com/apache/sling-org-apache-sling-jcr-contentloader:src/main/java/org/apache/sling/jcr/contentloader/internal/PathEntry.java: [ master, ] java
85:     private final String path;
57:     public static final String PATH_DIRECTIVE = "path";
33: public class PathEntry extends ImportOptions {
138:     public PathEntry(ManifestHeader.Entry entry, long bundleLastModified) {
215:     public String getPath() {
116:     public static Iterator<PathEntry> getContentPaths(final Bundle bundle) {
31:  * A path entry from the manifest for initial content.
54:      * The path directive specifying the target node where initial content will
84:     /** The path for the initial content. */
106:      * Target path where initial content will be loaded. If it´s null then
139:         this.path = entry.getValue();
168:         // path directive
169:         final String pathValue = entry.getDirectiveValue(PATH_DIRECTIVE);
216:         return this.path;
117:         final List<PathEntry> entries = new ArrayList<PathEntry>();
128:                 entries.add(new PathEntry(entry, bundleLastModified ));
170:         if (pathValue != null) {
171:             this.target = pathValue;
204:         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, ] java
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, ] java
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/GoogleCloudPlatform/datanucleus-appengine:testing/selenium-core/xpath/javascript-xpath-0.1.8.js: [ master, ] javascript
645: UnionExpr.prototype.path = function(path) {
74: var PathExpr;
673: PathExpr = function(filter) {
2755:     win.XPathExpression = function(expr) {
2773:     win.XPathResult = function (value, type) {
614:     union.path(expr);
619:             throw Error('missing next union location path');
621:         union.path(PathExpr.parse(lexer));
646:     this.paths.push(path);
648:     if (path.needContextPosition) {
651:     if (path.needContextNode) {
686:     var op, expr, path, token;
698:         path = new PathExpr(FilterExpr.root()); // RootExpr
704:         path.step(op, expr);
710:             path = new PathExpr(FilterExpr.context());
711:             path.step('/', expr);
716:             path = new PathExpr(expr);
725:         path.step(op, Step.parse(lexer));
728:     return path;
806:     t += indent + 'path:' + '\n';
1: /*  JavaScript-XPath 0.1.8
4:  *  JavaScript-XPath is freely distributable under the terms of an MIT-style license.
5:  *  For details, see the JavaScript-XPath web site: http://coderepos.org/share/wiki/JavaScript-XPath
24: if (window.jsxpath) {
25:     config = window.jsxpath;
57:                         && document.implementation.hasFeature("XPath", null));
600:     this.paths = [];
609:     expr = PathExpr.parse(lexer);
635:     var paths = this.paths;
637:     for (var i = 0, l = paths.length; i < l; i ++) {
638:         var exrs = paths[i].evaluate(ctx);
639:         if (!exrs.isNodeSet) throw Error('PathExpr must be nodeset');
660:     for (var i = 0; i < this.paths.length; i ++) {
661:         t += this.paths[i].show(indent);
668:  * class: PathExpr
670: if (!window.PathExpr && window.defaultConfig)
671:     window.PathExpr = null;
683: PathExpr.ops = { '//': 1, '/': 1 };
685: PathExpr.parse = function(lexer) {
731: PathExpr.prototype = new BaseExpr();
733: PathExpr.prototype.evaluate = function(ctx) {
786: PathExpr.prototype.step = function(op, step) {
803: PathExpr.prototype.show = function(indent) {
1013:             // fix for "xpath href with spaces" (http://jira.openqa.org/browse/SEL-347)   
2273:         return node.__jsxpath_id__ || (node.__jsxpath_id__ = this.uuid++);
2769:     win.XPathExpression.prototype.evaluate = function(node, type) {
2770:         return new win.XPathResult(this.expr.evaluate(new Ctx(node)), type);
2807:     win.XPathResult.prototype.iterateNext = function() { return this.nodes[this.index++] };
2808:     win.XPathResult.prototype.snapshotItem = function(i) { return this.nodes[i] };
2810:     win.XPathResult.ANY_TYPE = 0;
2811:     win.XPathResult.NUMBER_TYPE = 1;
2812:     win.XPathResult.STRING_TYPE = 2;
2813:     win.XPathResult.BOOLEAN_TYPE = 3;
2814:     win.XPathResult.UNORDERED_NODE_ITERATOR_TYPE = 4;
2815:     win.XPathResult.ORDERED_NODE_ITERATOR_TYPE = 5;
2816:     win.XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE = 6;
2817:     win.XPathResult.ORDERED_NODE_SNAPSHOT_TYPE = 7;
2818:     win.XPathResult.ANY_UNORDERED_NODE_TYPE = 8;
2819:     win.XPathResult.FIRST_ORDERED_NODE_TYPE = 9;
2823:         return new win.XPathExpression(expr, null);
android.googlesource.com/platform/external/mp4parser:isoparser/src/main/java/com/googlecode/mp4parser/util/Path.java: [ master, ] java
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, ] java
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/incubator-dubbo:dubbo-common/src/main/java/org/apache/dubbo/common/URL.java: [ master, ] java
87:     private final String path;
407:     public String getPath() {
411:     public URL setPath(String path) {
415:     public String getAbsolutePath() {
53:  * for this case, url protocol = null, url host = 192.168.1.3, port = 20880, url path = null
55:  * for this case, url protocol = file, url host = null, url path = home/user1/router.js
57:  * for this case, url protocol = file, url host = home, url path = user1/router.js
59:  * for this case, url protocol = file, url host = null, url path = D:/1/router.js
63:  * for this case, url protocol = null, url host = null, url path = home/user1/router.js
65:  * for this case, url protocol = null, url host = home, url path = user1/router.js
113:         this.path = null;
121: ...(16 bytes skipped)...tring protocol, String host, int port, String[] pairs) { // varargs ... conflict with the following path argument, use array instead.
129:     public URL(String protocol, String host, int port, String path) {
130:         this(protocol, null, null, host, port, path, (Map<String, String>) null);
133:     public URL(String protocol, String host, int port, String path, String... pairs) {
134:         this(protocol, null, null, host, port, path, CollectionUtils.toStringMap(pairs));
137:     public URL(String protocol, String host, int port, String path, Map<String, String> parameters) {
138:         this(protocol, null, null, host, port, path, parameters);
141:     public URL(String protocol, String username, String password, String host, int port, String path) {
142:         this(protocol, username, password, host, port, path, (Map<String, String>) null);
145:     public URL(String protocol, String username, String password, String host, int port, String path, String... pairs) {
146:         this(protocol, username, password, host, port, path, CollectionUtils.toStringMap(pairs));
149:     public URL(String protocol, String username, String password, String host, int port, String path, Map<String, String> parameters) {
160:         while (path != null && path.startsWith("/")) {
161:             path = path.substring(1);
163:         this.path = path;
188:         String path = null;
215:             // case: file:/path/to/file.txt
228:             path = url.substring(i + 1);
256:         return new URL(protocol, username, password, host, port, path, parameters);
286:         return new URL(protocol, username, password, host, port, path, getParameters());
294:         return new URL(protocol, username, password, host, port, path, getParameters());
302:         return new URL(protocol, username, password, host, port, path, getParameters());
319:         return new URL(protocol, username, password, host, port, path, getParameters());
342:         return new URL(protocol, username, password, host, port, path, getParameters());
363:         return new URL(protocol, username, password, host, port, path, getParameters());
408:         return path;
412:         return new URL(protocol, username, password, host, port, path, getParameters());
416:         if (path != null && !path.startsWith("/")) {
417:             return "/" + path;
419:         return path;
956:         return new URL(protocol, username, password, host, port, path, map);
969:         return new URL(protocol, username, password, host, port, path, map);
1005:         return new URL(protocol, username, password, host, port, path, map);
1014:         return new URL(protocol, username, password, host, port, path, map);
1064:         return new URL(protocol, username, password, host, port, path, map);
1068:         return new URL(protocol, username, password, host, port, path, new HashMap<String, String>());
1087:         if ("path".equals(key)) {
1088:             return path;
1110:         if (path != null) {
1111:             map.put("path", path);
1217:         String path;
1219:             path = getServiceKey();
1221:             path = getPath();
1223:         if (path != null && path.length() > 0) {
1225:             buf.append(path);
1277:         return getParameter(Constants.INTERFACE_KEY, path);
1381:         result = prime * result + ((path == null) ? 0 : path.hashCode());
1421:         if (path == null) {
1422:             if (other.path != null) {
1425:         } else if (!path.equals(other.path)) {
github.com/apache/incubator-weex:android/sdk/src/main/java/com/taobao/weex/common/Constants.java: [ master, ] java
371:     String PATH = "codeCachePath";
373:     String SAVE_PATH = "v8";
github.com/apache/zookeeper:zookeeper-server/src/main/java/org/apache/zookeeper/KeeperException.java: [ master, ] java
494:     private String path;
527:     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;
500:     KeeperException(Code code, String path) {
502:         this.path = path;
524:      * Read the path for this exception
525:      * @return the path associated with this error, null if none
528:         return path;
533:         if (path == null || path.isEmpty()) {
536:         return "KeeperErrorCode = " + getCodeMessage(code) + " for " + path;
583:         public BadArgumentsException(String path) {
584:             super(Code.BADARGUMENTS, path);
596:         public BadVersionException(String path) {
597:             super(Code.BADVERSION, path);
629:         public InvalidACLException(String path) {
630:             super(Code.INVALIDACL, path);
692:         public NoChildrenForEphemeralsException(String path) {
693:             super(Code.NOCHILDRENFOREPHEMERALS, path);
705:         public NodeExistsException(String path) {
706:             super(Code.NODEEXISTS, path);
718:         public NoNodeException(String path) {
719:             super(Code.NONODE, path);
731:         public NotEmptyException(String path) {
732:             super(Code.NOTEMPTY, path);
835:         public NoWatcherException(String path) {
836:             super(Code.NOWATCHER, path);
846:         public ReconfigDisabledException(String path) {
847:             super(Code.RECONFIGDISABLED, path);
github.com/google/google-authenticator:mobile/blackberry/src/com/google/authenticator/blackberry/Uri.java: [ master, ] java
496:         private PathPart path;
1025:         private final PathPart path;
1183:         private PathPart path;
1247:         Builder path(PathPart path) {
1263:         public Builder path(String path) {
248:     public abstract String getPath();
256:     public abstract String getEncodedPath();
504:         public String getPath() {
508:         public String getEncodedPath() {
516:         private String parsePath() {
647:         static String parsePath(String uriString, int ssi) {
778:         public String getPath() {
782:         public String getEncodedPath() {
857:     static class PathSegments {
864:         PathSegments(String[] segments, int size) {
885:     static class PathSegmentsBuilder {
1099:         public String getEncodedPath() {
1103:         public String getPath() {
1274:         public Builder encodedPath(String path) {
1281:         public Builder appendPath(String newSegment) {
1288:         public Builder appendEncodedPath(String newSegment) {
1897:     static class PathPart extends AbstractPart {
1905:         private PathPart(String encoded, String decoded) {
1920:         private PathSegments pathSegments;
2074:     public static Uri withAppendedPath(Uri baseUri, String pathSegment) {
297:     public abstract String[] getPathSegments();
304:     public abstract String getLastPathSegment();
498:         private PathPart getPathPart() {
512:         public String[] getPathSegments() {
802:         public String[] getPathSegments() {
806:         public String getLastPathSegment() {
921:         public String getLastPathSegment() {
1123:         public String[] getPathSegments() {
1928:         PathSegments getPathSegments() {
90:        and a path component that begins with two slash characters.  The
96:     <scheme>://<authority><path>?<query>
243:      * Gets the decoded path.
245:      * @return the decoded path, or null if this is not a hierarchical URI
251:      * Gets the encoded path.
253:      * @return the encoded path, or null if this is not a hierarchical URI
293:      * Gets the decoded path segments.
295:      * @return decoded path segments, each without a leading or trailing '/'
300:      * Gets the decoded last segment in the path.
302:      * @return the decoded last segment or null if the path is empty
499:             return path == null
500:                     ? path = PathPart.fromEncoded(parsePath())
501:                     : path;
619:                 // Look for the start of the path, query, or fragment, or the
624:                         case '/': // Start of path
640:          * Parses a path out of this given URI string.
645:          * @return the path
650:             // Find start of path.
655:                 // Skip over authority to path.
661:                             return ""; // Empty path.
662:                         case '/': // Start of path!
668:                 // Path starts immediately after scheme separator.
672:             // Find end of path.
691:                         .path(getPathPart())
855:      * Wrapper for path segment array.
1029:         private HierarchicalUri(String scheme, Part authority, PathPart path,
1033:             this.path = path == null ? PathPart.NULL : path;
1081:             String encodedPath = path.getEncoded();
1100:             return this.path.getEncoded();
1104:             return this.path.getDecoded();
1124:             return this.path.getPathSegments().segments;
1158:                     .path(path)
1169:      * {@code &lt;scheme&gt;://&lt;authority&gt;&lt;absolute path&gt;?&lt;query&gt;#&lt;fragment&gt;}
1172:      * of two patterns: {@code &lt;relative or absolute path&gt;?&lt;query&gt;#&lt;fragment&gt;}
1173:      * or {@code //&lt;authority&gt;&lt;absolute path&gt;?&lt;query&gt;#&lt;fragment&gt;}
1251:             this.path = path;
1256:          * Sets the path. Leaves '/' characters intact but encodes others as
1259:          * <p>If the path is not null and doesn't start with a '/', and if
1261:          * given path with a '/'.
1264:             return path(PathPart.fromDecoded(path));
1268:          * Sets the previously encoded path.
1270:          * <p>If the path is not null and doesn't start with a '/', and if
1272:          * given path with a '/'.
1275:             return path(PathPart.fromEncoded(path));
1279:          * Encodes the given segment and appends it to the path.
1282:             return path(PathPart.appendDecodedSegment(path, newSegment));
1286:          * Appends the given segment to the path.
1289:             return path(PathPart.appendEncodedSegment(path, newSegment));
1378:                 PathPart path = this.path;
1379:                 if (path == null || path == PathPart.NULL) {
1380:                     path = PathPart.EMPTY;
1382:                     // If we have a scheme and/or authority, the path must
1385:                         path = PathPart.makeAbsolute(path);
1390:                         scheme, authority, path, query, fragment);
1894:      * Immutable wrapper of encoded and decoded versions of a path part. Lazily
1917:          * Cached path segments. This doesn't need to be volatile--we don't
1923:          * Gets the individual path segments. Parses them if necessary.
1925:          * @return parsed path segments or null if this isn't a hierarchical
1933:             String path = getEncoded();
1934:             if (path == null) {
1942:             while ((current = path.indexOf('/', previous)) > -1) {
1943:                 // This check keeps us from adding a segment if the path starts
1947:                             = decode(path.substring(previous, current));
1953:             // Add in the final path segment.
1954:             if (previous < path.length()) {
1955:                 segmentBuilder.add(decode(path.substring(previous)));
1963:             // If there is no old path, should we make the new path relative
1967:                 // No old path.
1980:                 // No old path.
1999:          * Creates a path from the encoded string.
2008:          * Creates a path from the decoded string.
2017:          * Creates a path from the encoded and decoded strings.
2035:          * Prepends path values with "/" if they're present, not empty, and
2065:      * Creates a new Uri by appending an already-encoded path segment to a
2068:      * @param baseUri Uri to append path segment to
2069:      * @param pathSegment encoded path segment to append
2071:      *  the path
115:             PathPart.EMPTY, Part.NULL, Part.NULL);
309:      * equal. Case counts. Paths are not normalized. If one Uri specifies a
538:             return parsePath(uriString, ssi);
651:             int pathStart;
656:                 pathStart = ssi + 3;
657:                 LOOP: while (pathStart < length) {
658:                     switch (uriString.charAt(pathStart)) {
665:                     pathStart++;
669:                 pathStart = ssi + 1;
673:             int pathEnd = pathStart;
674:             LOOP: while (pathEnd < length) {
675:                 switch (uriString.charAt(pathEnd)) {
680:                 pathEnd++;
683:             return uriString.substring(pathStart, pathEnd);
859:         static final PathSegments EMPTY = new PathSegments(null, 0);
883:      * Builds PathSegments.
902:         PathSegments build() {
904:                 return PathSegments.EMPTY;
908:                 return new PathSegments(segments, size);
1082:             if (encodedPath != null) {
1083:                 builder.append(encodedPath);
1377:                 // Hierarchical URIs should not return null for getPath().
1900:         static final PathPart NULL = new PathPart(null, null);
1903:         static final PathPart EMPTY = new PathPart("", "");
1929:             if (pathSegments != null) {
1930:                 return pathSegments;
1935:                 return pathSegments = PathSegments.EMPTY;
1938:             PathSegmentsBuilder segmentBuilder = new PathSegmentsBuilder();
1958:             return pathSegments = segmentBuilder.build();
1961:         static PathPart appendEncodedSegment(PathPart oldPart,
1971:             String oldPath = oldPart.getEncoded();
1973:             if (oldPath == null) {
1974:                 oldPath = "";
1977:             int oldPathLength = oldPath.length();
1978:             String newPath;
1981:                 newPath = "/" + newSegment;
1982:             } else if (oldPath.charAt(oldPathLength - 1) == '/') {
1983:                 newPath = oldPath + newSegment;
1985:                 newPath = oldPath + "/" + newSegment;
1988:             return fromEncoded(newPath);
1991:         static PathPart appendDecodedSegment(PathPart oldPart, String decoded) {
1994:             // TODO: Should we reuse old PathSegments? Probably not.
2003:         static PathPart fromEncoded(String encoded) {
2012:         static PathPart fromDecoded(String decoded) {
2022:         static PathPart from(String encoded, String decoded) {
2031:             return new PathPart(encoded, decoded);
2038:         static PathPart makeAbsolute(PathPart oldPart) {
2043:             String oldPath = encodedCached ? oldPart.encoded : oldPart.decoded;
2045:             if (oldPath == null || oldPath.length() == 0
2046:                     || oldPath.startsWith("/")) {
2060:             return new PathPart(newEncoded, newDecoded);
2076:         builder = builder.appendEncodedPath(pathSegment);
505:             return getPathPart().getDecoded();
509:             return getPathPart().getEncoded();
513:             return getPathPart().getPathSegments().segments;
925:             String[] segments = getPathSegments();
1979:             if (oldPathLength == 0) {
github.com/apache/zookeeper:zookeeper-server/src/main/java/org/apache/zookeeper/ClientCnxn.java: [ master, ] java
1626:         private final String path;
166:     final String chrootPath;
258:         String clientPath;
260:         String serverPath;
257:         /** Client's view of the path (may differ due to chroot) **/
259:         /** Servers's view of the path (may differ due to chroot) **/
477:         public void queueCallback(AsyncCallback cb, int rc, String path,
479:             waitingEvents.add(new LocalCallback(cb, rc, path, ctx));
539:                         ((StatCallback) lcb.cb).processResult(lcb.rc, lcb.path,
542:                         ((DataCallback) lcb.cb).processResult(lcb.rc, lcb.path,
545:                         ((ACLCallback) lcb.cb).processResult(lcb.rc, lcb.path,
549:                                 lcb.path, lcb.ctx, null);
552:                                 lcb.path, lcb.ctx, null, null);
555:                                 lcb.path, lcb.ctx, null);
557:                         ((VoidCallback) lcb.cb).processResult(lcb.rc, lcb.path,
733:     void queueCallback(AsyncCallback cb, int rc, String path, Object ctx) {
734:         eventThread.queueCallback(cb, rc, path, ctx);
848:                 // convert from a server path to a client path
856:                     	LOG.warn("Got server path " + event.getPath()
857:                     			+ " which is too short for chroot path "
1629:         public LocalCallback(AsyncCallback cb, int rc, String path, Object ctx) {
1632:             this.path = path;
322:             sb.append("clientPath:" + clientPath);
323:             sb.append(" serverPath:" + serverPath);
341:      * @param chrootPath - the chroot of this client. Should be removed from this Class in ZOOKEEPER-838
356:     public ClientCnxn(String chrootPath, HostProvider hostProvider, int sessionTimeout, ZooKeeper zooKeeper,
359:         this(chrootPath, hostProvider, sessionTimeout, zooKeeper, watcher,
368:      * @param chrootPath - the chroot of this client. Should be removed from this Class in ZOOKEEPER-838
385:     public ClientCnxn(String chrootPath, HostProvider hostProvider, int sessionTimeout, ZooKeeper zooKeeper,
394:         this.chrootPath = chrootPath;
467:                         event.getType(), event.getPath());
563:                   String clientPath = p.clientPath;
575:                               cb.processResult(rc, clientPath, p.ctx,
579:                               cb.processResult(rc, clientPath, p.ctx,
583:                               cb.processResult(rc, clientPath, p.ctx,
588:                           cb.processResult(rc, clientPath, p.ctx, null);
594:                           cb.processResult(rc, clientPath, p.ctx, rsp
597:                           cb.processResult(rc, clientPath, p.ctx, null,
604:                           cb.processResult(rc, clientPath, p.ctx, rsp
607:                           cb.processResult(rc, clientPath, p.ctx, null,
614:                           cb.processResult(rc, clientPath, p.ctx, rsp
617:                           cb.processResult(rc, clientPath, p.ctx, null);
623:                           cb.processResult(rc, clientPath, p.ctx, rsp
626:                           cb.processResult(rc, clientPath, p.ctx, null, null);
632:                           cb.processResult(rc, clientPath, p.ctx,
633:                                   (chrootPath == null
634:                                           ? rsp.getPath()
635:                                           : rsp.getPath()
636:                                     .substring(chrootPath.length())));
638:                           cb.processResult(rc, clientPath, p.ctx, null);
644:                           cb.processResult(rc, clientPath, p.ctx,
645:                                   (chrootPath == null
646:                                           ? rsp.getPath()
647:                                           : rsp.getPath()
648:                                     .substring(chrootPath.length())), rsp.getStat());
650:                           cb.processResult(rc, clientPath, p.ctx, null, null);
665:                 		  cb.processResult(newRc, clientPath, p.ctx, results);
667:                 		  cb.processResult(rc, clientPath, p.ctx, null);
671:                       cb.processResult(rc, clientPath, p.ctx);
696:                         queueEvent(p.watchDeregistration.getClientPath(), err,
721:     void queueEvent(String clientPath, int err,
729:                 clientPath);
849:                 if (chrootPath != null) {
850:                     String serverPath = event.getPath();
851:                     if(serverPath.compareTo(chrootPath)==0)
852:                         event.setPath("/");
853:                     else if (serverPath.length() > chrootPath.length())
854:                         event.setPath(serverPath.substring(chrootPath.length()));
858:                     			+ chrootPath);
1028:         private List<String> prependChroot(List<String> paths) {
1029:             if (chrootPath != null && !paths.isEmpty()) {
1030:                 for (int i = 0; i < paths.size(); ++i) {
1031:                     String clientPath = paths.get(i);
1032:                     String serverPath;
1033:                     // handle clientPath = "/"
1034:                     if (clientPath.length() == 1) {
1035:                         serverPath = chrootPath;
1037:                         serverPath = chrootPath + clientPath;
1039:                     paths.set(i, serverPath);
1042:             return paths;
1568:             Record response, AsyncCallback cb, String clientPath,
1569:             String serverPath, Object ctx, WatchRegistration watchRegistration) {
1570:         return queuePacket(h, r, request, response, cb, clientPath, serverPath,
1575:             Record response, AsyncCallback cb, String clientPath,
1576:             String serverPath, Object ctx, WatchRegistration watchRegistration,
1586:         packet.clientPath = clientPath;
1587:         packet.serverPath = serverPath;
github.com/google/error-prone:check_api/src/main/java/com/google/errorprone/util/ASTHelpers.java: [ master, ] java
1203:     public abstract TreePath path();
333:   public static <T> TreePath findPathFromEnclosingNodeToTopLevel(TreePath path, Class<T> klass) {
330:    * Given a TreePath, finds the first enclosing node of the given type and returns the path from
334:     if (path != null) {
336:         path = path.getParentPath();
337:       } while (path != null && !(klass.isInstance(path.getLeaf())));
339:     return path;
347:   public static <T> T findEnclosingNode(TreePath path, Class<T> klass) {
348:     path = findPathFromEnclosingNodeToTopLevel(path, klass);
349:     return (path == null) ? null : klass.cast(path.getLeaf());
1064:    * The return value is normalized to always use '/' to separate elements of the path and to always
1076:    * normalized to always use '/' to separate elements of the path and to always have a leading '/'.
1205:     static TargetType create(Type type, TreePath path) {
1206:       return new AutoValue_ASTHelpers_TargetType(type, path);
1263:    * Returns the target type of the tree at the given {@link VisitorState}'s path, or else {@code
1364:       for (TreePath path = parent; path != null; path = path.getParentPath()) {
1365:         Tree enclosing = path.getLeaf();
69: import com.sun.source.util.TreePath;
343:    * Given a TreePath, walks up the tree until it finds a node of the given type. Returns null if no
677:       // @Inherited won't work if the annotation isn't on the classpath, but we can still check
859:     JCCompilationUnit compilationUnit = (JCCompilationUnit) state.getPath().getCompilationUnit();
873:     TreePath pathToExpr = new TreePath(state.getPath(), expr);
874:     return nullnessAnalysis.getNullness(pathToExpr, state.context);
991:    * Returns true if the leaf node in the {@link TreePath} from {@code state} sits somewhere
995:     for (Tree ancestor : state.getPath()) {
1081:       return uri.getPath();
1086:       // It's possible (though it violates the zip file spec) for paths to zip file entries to use
1271:     if (!(state.getPath().getLeaf() instanceof ExpressionTree)) {
1274:     TreePath parent = state.getPath();
1278:       parent = parent.getParentPath();
1295:     private final TreePath parent;
1298:     private TargetTypeVisitor(ExpressionTree current, VisitorState state, TreePath parent) {
github.com/apache/shiro:web/src/main/java/org/apache/shiro/web/servlet/SimpleCookie.java: [ master, ] java
77:     private String path;
62:     protected static final String PATH_ATTRIBUTE_NAME = "Path";
141:     public String getPath() {
145:     public void setPath(String path) {
189:     private String calculatePath(HttpServletRequest request) {
277:     private void appendPath(StringBuilder sb, String path) {
339:     private boolean pathMatches(String cookiePath, String requestPath) {
99:         this.path = cookie.getPath();
142:         return path;
146:         this.path = path;
182:      * Returns the Cookie's calculated path setting.  If the {@link javax.servlet.http.Cookie#getPath() path} is {@code null}, then the
183:      * {@code request}'s {@link javax.servlet.http.HttpServletRequest#getContextPath() context path}
184:      * will be returned. If getContextPath() is the empty string or null then the ROOT_PATH constant is returned.
187:      * @return the path to be used as the path when the cookie is created or removed
190:         String path = StringUtils.clean(getPath());
191:         if (!StringUtils.hasText(path)) {
192:             path = StringUtils.clean(request.getContextPath());
196:         if (path == null) {
197:             path = ROOT_PATH;
199:         log.trace("calculated path: {}", path);
200:         return path;
209:         String path = calculatePath(request);
215:         addCookieHeader(response, name, value, comment, domain, path, maxAge, version, secure, httpOnly);
219:                                  String domain, String path, int maxAge, int version,
222:         String headerValue = buildHeaderValue(name, value, comment, domain, path, maxAge, version, secure, httpOnly);
238:                                       String domain, String path, int maxAge, int version,
253:         appendPath(sb, path);
278:         if (StringUtils.hasText(path)) {
280:             sb.append(PATH_ATTRIBUTE_NAME).append(NAME_VALUE_DELIMITER).append(path);
337:      * @see <a href="https://tools.ietf.org/html/rfc6265#section-5.1.4">RFC 6265, Section 5.1.4 "Paths and Path-Match"</a>
367:         String path = calculatePath(request);
373:         addCookieHeader(response, name, value, comment, domain, path, maxAge, version, secure, httpOnly);
384:             String path = StringUtils.clean(getPath());
385:             if (path != null && !pathMatches(path, request.getRequestURI())) {
386:                 log.warn("Found '{}' cookie at path '{}', but should be only used for '{}'", new Object[] { name, request.getRequestURI(), path});
332:      * Check whether the given {@code cookiePath} matches the {@code requestPath}
334:      * @param cookiePath
335:      * @param requestPath
340:         if (!requestPath.startsWith(cookiePath)) {
344:         return requestPath.length() == cookiePath.length()
345:             || cookiePath.charAt(cookiePath.length() - 1) == '/'
346:             || requestPath.charAt(cookiePath.length()) == '/';
github.com/git/git-scm.com:vendor/assets/javascripts/session.min.js: [ master, ] javascript
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/nifi:nifi-nar-bundles/nifi-hive-bundle/nifi-hive-processors/src/main/java/org/apache/hadoop/hive/ql/io/orc/OrcFlowFileWriter.java: [ master, ] java
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/pulsar:pulsar-client-tools/src/main/java/org/apache/pulsar/admin/cli/CmdFunctions.java: [ master, ] java
816:         protected String path;
851:         protected String path;
554:         protected String DEPRECATED_tlsTrustCertFilePath;
556:         protected String tlsTrustCertFilePath;
184:         @Parameter(names = "--jar", description = "Path to the jar file for the function (if the function is written in Java). It also supports url-path [http/https/file (file protocol assumes that file already exists on worker host)] from which worker...(67 bytes skipped)...
188:                 description = "Path to the main Python file/Python Wheel file for the function (if the function is written in Python)",...(0 bytes skipped)...
224:         @Parameter(names = "--functionConfigFile", description = "The path to a YAML config file specifying the function's configuration", hidden = true)
226:         @Parameter(names = "--function-config-file", description = "The path to a YAML config file specifying the function's configuration")
553:         @Parameter(names = "--tls_trust_cert_path", description = "tls trust cert file path", hidden = true)
555:         @Parameter(names = "--tls-trust-cert-path", description = "tls trust cert file path")
775:         @Parameter(names = "--triggerFile", description = "The path to the file that contains the data with which you'd like to trigger the function", hidden = true)
777:         @Parameter(names = "--trigger-file", description = "The path to the file that contains the data with which you'd like to trigger the function")
813:                 names = "--path",
814:                 description = "Path where the contents need to be stored",
829:             admin.functions().uploadFunction(sourceFile, path);
848:                 names = "--path",
849:                 description = "Path where the contents are to be stored",
864:             admin.functions().downloadFunction(destinationFile, path);
571:             if (!StringUtils.isBlank(DEPRECATED_tlsTrustCertFilePath)) tlsTrustCertFilePath = DEPRECATED_tlsTrustCertFilePath;
792:                 throw new ParameterException("Either a trigger value or a trigger filepath needs to be specified");
github.com/apache/incubator-pulsar:pulsar-client-tools/src/main/java/org/apache/pulsar/admin/cli/CmdFunctions.java: [ master, ] java Duplicate result
github.com/apache/curator:curator-recipes/src/main/java/org/apache/curator/framework/recipes/cache/TreeCache.java: [ master, ] java
85:         private final String path;
231:         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
94:         private Builder(CuratorFramework client, String path)
97:             this.path = validatePath(path);
110:             return new TreeCache(client, path, cacheData, dataIsCompressed, maxDepth, executor, createParentNodes, disableZkWatches, selector);
161:          * By default, TreeCache does not auto-create parent nodes for the cached path. Change
174: ...(6 bytes skipped)...   * By default, TreeCache creates {@link org.apache.zookeeper.ZooKeeper} watches for every created path.
199:      * Create a TreeCache builder for the given client and path to configure advanced options.
202:      * the namespace, including all published events.  The given path is the root at which the
203:      * TreeCache will watch and explore.  If no node exists at the given path, the TreeCache will
207:      * @param path   the path to the root node to watch/explore; this path need not actually exist on
211:     public static Builder newBuilder(CuratorFramework client, String path)
213:         return new Builder(client, path);
235:         TreeNode(String path, TreeNode parent)
237:             this.path = path;
244:             if ((depth < maxDepth) && selector.traverseChildren(path))
256:             if ((depth < maxDepth) && selector.traverseChildren(path))
273:                 maybeWatch(client.getChildren()).forPath(path);
283:                     maybeWatch(client.getData().decompressed()).forPath(path);
287:                     maybeWatch(client.getData()).forPath(path);
350:                 maybeWatch(client.checkExists()).forPath(path);
358:                     parentChildMap.remove(ZKPaths.getNodeFromPath(path), this);
439:                         if ( !childMap.containsKey(child) && selector.acceptChild(ZKPaths.makePath(path, child)) )
448:                         String fullPath = ZKPaths.makePath(path, child);
550:      * Create a TreeCache for the given client and path with default options.
553:      * the namespace, including all published events.  The given path is the root at which the
554:      * TreeCache will watch and explore.  If no node exists at the given path, the TreeCache will
558:      * @param path   the path to the root node to watch/explore; this path need not actually exist on
562:     public TreeCache(CuratorFramework client, String path)
564:         this(client, path, true, false, Integer.MAX_VALUE, Executors.newSingleThreadExecutor(defaultThreadFactory), false, fa...(37 bytes skipped)...
569:      * @param path             path to watch
571:      * @param dataIsCompressed if true, data in the path is compressed
577:     TreeCache(CuratorFramework client, String path, boolean cacheData, boolean dataIsCompressed, int maxDepth, final ExecutorService executorService, ...(80 bytes skipped)...
581:         this.root = new TreeNode(validatePath(path), null);
602:             client.createContainers(root.path);
660:         LinkedList<String> rootElements = new LinkedList<String>(ZKPaths.split(root.path));
664:                 // Target path shorter than root path
670:                 // Initial root path does not match
693:      * Return the current set of children at the given path, mapped by child name. There are no
695:      * node at this path, {@code null} is returned.
697:      * @param fullPath full path to the node to check
733:      * Return the current data for the given path. There are no guarantees of accuracy. This is
734:      * merely the most recent view of the data. If there is no node at the given path,
737:      * @param fullPath full path to the node to check
32: import org.apache.curator.framework.api.Pathable;
39: import org.apache.curator.utils.PathUtils;
64: import static org.apache.curator.utils.PathUtils.validatePath;
151:          * root node and its immediate children (kind of like {@link PathChildrenCache}.
292:         private <T, P extends Watchable<BackgroundPathable<T>> & BackgroundPathable<T>> Pathable<T> maybeWatch(
417: ...(5 bytes skipped)...                   childDataUpdater.compareAndSet(this, oldChildData, new ChildData(oldChildData.getPath(), newStat, oldChildData.getData()));
449:                         TreeNode node = new TreeNode(fullPath, this);
464:                     String eventPath = event.getPath();
465:                     ChildData toPublish = new ChildData(eventPath, newStat, event.getData());
466:                     ChildData toUpdate = cacheData ? toPublish : new ChildData(eventPath, newStat, null);
657:     private TreeNode find(String findPath)
659:         PathUtils.validatePath(findPath);
661:         LinkedList<String> findElements = new LinkedList<String>(ZKPaths.split(findPath));
700:     public Map<String, ChildData> getCurrentChildren(String fullPath)
702:         TreeNode node = find(fullPath);
740:     public ChildData getCurrentData(String fullPath)
742:         TreeNode node = find(fullPath);
30: import org.apache.curator.framework.api.BackgroundPathable;
41: import org.apache.curator.utils.ZKPaths;
github.com/apache/cloudstack:api/src/main/java/org/apache/cloudstack/api/ApiConstants.java: [ master, ] java
224:     public static final String PATH = "path";
637:     public static final String HEALTHCHECK_PINGPATH = "pingpath";
github.com/apache/pdfbox:pdfbox/src/main/java/org/apache/pdfbox/cos/COSName.java: [ trunk, ] java
430:     public static final COSName PATH = new COSName("Path");
github.com/apache/cloudstack:plugins/storage/volume/cloudbyte/src/main/java/org/apache/cloudstack/storage/datastore/util/ElastistorUtil.java: [ master, ] java
1708:         private String path;
1044:         private String restpath = "/client/api";
1761:         public String getPath() {
1707:         @SerializedName("path")
1762:             return path;
1150: ...(18 bytes skipped)...bResource webResource = client.resource(UriBuilder.fromUri(restprotocol + elastiCenterAddress + restpath).build());
github.com/apache/jmeter:src/protocol/http/org/apache/jmeter/protocol/http/sampler/HTTPSamplerBase.java: [ trunk, ] java
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.
1015:         String path = this.getPath();
1017:         if (path.startsWith(HTTP_PREFIX)
1018:                 || path.startsWith(HTTPS_PREFIX)) {
1019:             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())) {
1014:         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());
2109:         String value = getPath();
2116:                 setPath(replacedText);
github.com/apache/incubator-netbeans:enterprise/javaee.wildfly/src/org/netbeans/modules/javaee/wildfly/ide/commands/Constants.java: [ master, ] java
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/tinkerpop:gremlin-javascript/src/main/javascript/gremlin-javascript/lib/process/graph-traversal.js: [ master, ] javascript
850:   path(...args) {
1286:   path: (...args) => callOnEmptyTraversal('path', args),
90:   withPath(...args) {
400:   cyclicPath(...args) {
990:   shortestPath(...args) {
1010:   simplePath(...args) {
1244:   cyclicPath: (...args) => callOnEmptyTraversal('cyclicPath', args),
1297:   simplePath: (...args) => callOnEmptyTraversal('simplePath', args),
846:    * Graph traversal path method.
851:     this.bytecode.addStep('path', args);
86:    * Graph Traversal Source withPath method.
91:     const b = new Bytecode(this.bytecode).addSource('withPath', args);
396:    * Graph traversal cyclicPath method.
401:     this.bytecode.addStep('cyclicPath', args);
986:    * Graph traversal shortestPath method.
991:     this.bytecode.addStep('shortestPath', args);
1006:    * Graph traversal simplePath method.
1011:     this.bytecode.addStep('simplePath', args);
github.com/google/ion:third_party/icu/android_icu4j/src/main/java/android/icu/impl/number/Parse.java: [ master, ] java
247:     String path;
34:  * the grouping separator. Since the second option has a longer parse path (consumes more of the
194:    * Holds a snapshot in time of a single parse path. This includes the digits seen so far, the
195:    * current state name, and other properties like the grouping separator used on this parse path,
245:     // Identification for path tracing:
297:       // Identification for path tracing:
299:       path = "";
360:         path = other.path + other.id;
487:       sb.append(path);
2057:    *   // Add parse path going to firstOffsetOrTag
2060:    *   // Add parse path leaving the string
31:  * <p>The parser may traverse multiple parse paths in the same strings if there is ambiguity. For
84:      *   <li>Instead of traversing multiple possible parse paths, a "greedy" parsing strategy is
202:     // The "score" is used to help rank two otherwise equivalent parse paths. Currently, the only
931:    * string or when there are no possible parse paths remaining in the string.
1246:         // No parse paths continue past this point. We have found the longest parsable string
2050:    * paths.
2053:    * nextOffsetOrTag. These two arguments should add parse paths according to the following rules:
2064:    * <p>Note that there may be multiple parse paths added by these lines. This is important in order
github.com/google/ion:third_party/icu/icu4j/main/classes/core/src/com/ibm/icu/impl/number/Parse.java: [ master, ] java
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/bundletool:src/main/java/com/android/tools/build/bundletool/utils/flags/Flag.java: [ master, ] java
98:   public static Flag<Path> path(String name) {
103:   public static Flag<ImmutableList<Path>> pathList(String name) {
337:   static class PathFlag extends SingleValueFlag<Path> {
339:     public PathFlag(String name) {
367:   static class ZipPathFlag extends SingleValueFlag<ZipPath> {
369:     public ZipPathFlag(String name) {
38: import java.nio.file.Path;
54:  * @param <T> the type that the flag should be parsed as (e.g. string, file path etc).
97:   /** Path flag holding a single value. */
102:   /** Path flag holding a list of comma-delimited values. */
344:     protected Path parse(String value) {
458:     } else if (clazz.equals(Path.class)) {
497:         Path passwordFile = Paths.get(flagValue.substring("file:".length()));
515:     private static String readPasswordFromFile(Path passwordFile) {
27: import com.android.tools.build.bundletool.model.ZipPath;
39: import java.nio.file.Paths;
99:     return new PathFlag(name);
104:     return new ListFlag<>(new PathFlag(name));
351:       return Paths.get(value);
374:     protected ZipPath parse(String value) {
375:       return ZipPath.create(value);
459:       return (SingleValueFlag<T>) new PathFlag(name);
462:     } else if (clazz.equals(ZipPath.class)) {
463:       return (SingleValueFlag<T>) new ZipPathFlag(name);
github.com/apache/tinkerpop:gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/__.java: [ master, ] java
304:     public static <A> GraphTraversal<A, Path> path() {
831:     public static <A> GraphTraversal<A, A> simplePath() {
838:     public static <A> GraphTraversal<A, A> cyclicPath() {
22: import org.apache.tinkerpop.gremlin.process.traversal.Path;
302:      * @see GraphTraversal#path()
305:         return __.<A>start().path();
829:      * @see GraphTraversal#simplePath()
832:         return __.<A>start().simplePath();
836:      * @see GraphTraversal#cyclicPath()
839:         return __.<A>start().cyclicPath();
github.com/firebase/firebase-android-sdk:firebase-database/src/main/java/com/google/firebase/database/connection/PersistentConnectionImpl.java: [ master, ] java
41:     private final List<String> path;
148:     private final List<String> path;
189:   private static final String REQUEST_PATH = "p";
221:   private static final String SERVER_DATA_UPDATE_PATH = "p";
223:   private static final String SERVER_DATA_START_PATH = "s";
224:   private static final String SERVER_DATA_END_PATH = "e";
164:     public List<String> getPath() {
196:   private static final String REQUEST_COMPOUND_HASH_PATHS = "ps";
44:     public ListenQuerySpec(List<String> path, Map<String, Object> queryParams) {
45:       this.path = path;
58:       if (!path.equals(that.path)) {
66:       int result = path.hashCode();
73:       return ConnectionUtils.pathToString(this.path) + " (params: " + queryParams + ")";
153:         String action, List<String> path, Object data, RequestResultCallback onComplete) {
155:       this.path = path;
165:       return path;
326:       List<String> path,
331:     ListenQuerySpec query = new ListenQuerySpec(path, queryParams);
358:   public void put(List<String> path, Object data, RequestResultCallback onComplete) {
359:     putInternal(REQUEST_ACTION_PUT, path, data, /*hash=*/ null, onComplete);
364:       List<String> path, Object data, String hash, RequestResultCallback onComplete) {
365:     putInternal(REQUEST_ACTION_PUT, path, data, hash, onComplete);
369:   public void merge(List<String> path, Map<String, Object> data, RequestResultCallback onComplete) {
370:     putInternal(REQUEST_ACTION_MERGE, path, data, /*hash=*/ null, onComplete);
458:   public void unlisten(List<String> path, Map<String, Object> queryParams) {
459:     ListenQuerySpec query = new ListenQuerySpec(path, queryParams);
478:   public void onDisconnectPut(List<String> path, Object data, RequestResultCallback onComplete) {
481:       sendOnDisconnect(REQUEST_ACTION_ONDISCONNECT_PUT, path, data, onComplete);
484:           new OutstandingDisconnect(REQUEST_ACTION_ONDISCONNECT_PUT, path, data, onComplete));
495:       List<String> path, Map<String, Object> updates, final RequestResultCallback onComplete) {
498:       sendOnDisconnect(REQUEST_ACTION_ONDISCONNECT_MERGE, path, updates, onComplete);
501:           new OutstandingDisconnect(REQUEST_ACTION_ONDISCONNECT_MERGE, path, updates, onComplete));
507:   public void onDisconnectCancel(List<String> path, RequestResultCallback onComplete) {
512:       sendOnDisconnect(REQUEST_ACTION_ONDISCONNECT_CANCEL, path, null, onComplete);
515:           new OutstandingDisconnect(REQUEST_ACTION_ONDISCONNECT_CANCEL, path, null, onComplete));
675:       String action, List<String> path, Object data, final RequestResultCallback onComplete) {
677:     request.put(REQUEST_PATH, ConnectionUtils.pathToString(path));
723:     request.put(REQUEST_PATH, ConnectionUtils.pathToString(listen.query.path));
749:   private Collection<OutstandingListen> removeListens(List<String> path) {
750:     if (logger.logsDebug()) logger.debug("removing all listens at path " + path);
755:       if (query.path.equals(path)) {
774:       String pathString = (String) body.get(SERVER_DATA_UPDATE_PATH);
779:         if (logger.logsDebug()) logger.debug("ignoring empty merge for path " + pathString);
781:         List<String> path = ConnectionUtils.stringToPath(pathString);
782:         delegate.onDataUpdate(path, payloadData, isMerge, tagNumber);
785:       String pathString = (String) body.get(SERVER_DATA_UPDATE_PATH);
786:       List<String> path = ConnectionUtils.stringToPath(pathString);
793:         String startString = (String) range.get(SERVER_DATA_START_PATH);
794:         String endString = (String) range.get(SERVER_DATA_END_PATH);
801:         if (logger.logsDebug()) logger.debug("Ignoring empty range merge for path " + pathString);
803:         this.delegate.onRangeMergeUpdate(path, rangeMerges, tag);
806:       String pathString = (String) body.get(SERVER_DATA_UPDATE_PATH);
807:       List<String> path = ConnectionUtils.stringToPath(pathString);
808:       onListenRevoked(path);
820:   private void onListenRevoked(List<String> path) {
823:     Collection<OutstandingListen> listens = removeListens(path);
983:   private Map<String, Object> getPutObject(List<String> path, Object data, String hash) {
985:     request.put(REQUEST_PATH, ConnectionUtils.pathToString(path));
995:       List<String> path,
999:     Map<String, Object> request = getPutObject(path, data, hash);
1053:     request.put(REQUEST_PATH, ConnectionUtils.pathToString(listen.getQuery().path));
1068:       for (List<String> path : compoundHash.getPosts()) {
1069:         posts.add(ConnectionUtils.pathToString(path));
1146:               + ConnectionUtils.pathToString(query.path)
795:         List<String> start = startString != null ? ConnectionUtils.stringToPath(startString) : null;
796:         List<String> end = endString != null ? ConnectionUtils.stringToPath(endString) : null;
968:           disconnect.getPath(),
1073:       hash.put(REQUEST_COMPOUND_HASH_PATHS, posts);
github.com/google/caja:third_party/java/htmlparser/src/nu/validator/htmlparser/impl/AttributeName.java: [ master, ] java
722:     public static final AttributeName PATH = new AttributeName(ALL_NO_NS, SAME_LOCAL("path"), ALL_NO_PREFIX, ALL_NCNAME, false);
934:     public static final AttributeName CLIP_PATH = new AttributeName(ALL_NO_NS, SAME_LOCAL("clip-path"), ALL_NO_PREFIX, ALL_NCNAME, false);
1005:     public static final AttributeName PATHLENGTH = new AttributeName(ALL_NO_NS, SVG_DIFFERENT("pathlength", "pathLength"), ALL_NO_PREFIX, ALL_NCNAME, false);
1120:     public static final AttributeName CLIPPATHUNITS = new AttributeName(ALL_NO_NS, SVG_DIFFERENT("clippathunits", "clipPathUnits"), ALL_NO_PREFIX, ALL_NCNAME, false);
1304:     PATH,
1516:     CLIP_PATH,
1587:     PATHLENGTH,
1702:     CLIPPATHUNITS,
github.com/google/google-authenticator-android:AuthenticatorApp/src/main/java/com/google/android/apps/authenticator/AccountDb.java: [ master, ] java
62:   static final String PATH = "databases";
125:         return context.openOrCreateDatabase(PATH, Context.MODE_PRIVATE, null);
139:     String databaseDirPathname = context.getDatabasePath(PATH).getParent();
140:     String databasePathname = context.getDatabasePath(PATH).getAbsolutePath();
141:     String[] dirsToStat = new String[] {dataPackageDir, databaseDirPathname, databasePathname};
chromium.googlesource.com/chromium/codesearch:src:codesearch-gitlink-overlay/third_party/android_tools/sdk/sources/android-25/benchmarks/regression/R.java: [ master, ] java
1967:     public static final int path = 0;
709:     public final int mpath = 0;
909:     public final int msearchSuggestPath = 0;
1968:     public static final int pathData = 0;
1969:     public static final int pathPattern = 0;
1970:     public static final int pathPrefix = 0;
2167:     public static final int searchSuggestPath = 0;
710:     public final int mpathData = 0;
711:     public final int mpathPattern = 0;
712:     public final int mpathPrefix = 0;
713:     public final int mpatternPathData = 0;
1171:     public final int mtrimPathEnd = 0;
1172:     public final int mtrimPathOffset = 0;
1173:     public final int mtrimPathStart = 0;
1971:     public static final int patternPathData = 0;
2429:     public static final int trimPathEnd = 0;
2430:     public static final int trimPathOffset = 0;
2431:     public static final int trimPathStart = 0;
android.googlesource.com/platform/external/universal-tween-engine:java/api/src/aurelienribon/tweenengine/Tween.java: [ master, ] java
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/libcore:benchmarks/src/benchmarks/regression/R.java: [ master, ] java Duplicate result
android.googlesource.com/platform/superproject:libcore/benchmarks/src/benchmarks/regression/R.java: [ master, ] java Duplicate result
chromium.googlesource.com/chromium/src/codesearch:third_party/android_tools/sdk/sources/android-25/benchmarks/regression/R.java: [ master, ] java Duplicate result
chromium.googlesource.com/android_tools:sdk/sources/android-25/benchmarks/regression/R.java: [ master, ] java Duplicate result
android.googlesource.com/platform/superproject:tools/idea/platform/platform-api/src/com/intellij/ui/tabs/impl/JBTabsImpl.java: [ master, ] java
1878:     public ShapeTransform path;
1879:     public ShapeTransform fillPath;
1880:     public ShapeTransform labelPath;
1776:       g2d.draw(shapeInfo.path.getShape());
1793:     shape.path = getEffectiveLayout().createShapeTransform(getSize());
1794:     shape.insets = shape.path.transformInsets(getLayoutInsets());
1795:     shape.labelPath = shape.path.createTransform(getSelectedLabel().getBounds());
1814:       shape.path.moveTo(shape.insets.left, shape.labelTopY + shape.labelPath.deltaY(getEdgeArcSize()));
1815:       shape.path.quadTo(shape.labelLeftX, shape.labelTopY, shape.labelLeftX + shape.labelPath.deltaX(getEdgeArcSize()), shape.labelTopY);
1816:       shape.path.lineTo(shape.labelRightX - shape.labelPath.deltaX(getArcSize()), shape.labelTopY);
1819:       shape.path.moveTo(shape.insets.left, shape.labelBottomY);
1820:       shape.path.lineTo(shape.labelLeftX, shape.labelBottomY);
1821:       shape.path.lineTo(shape.labelLeftX, shape.labelTopY + shape.labelPath.deltaY(getArcSize()));
1822:       shape.path.quadTo(shape.labelLeftX, shape.labelTopY, shape.labelLeftX + shape.labelPath.deltaX(getArcSize()), shape.labelTopY);
1825:     int lastX = shape.path.getWidth() - shape.path.deltaX(shape.insets.right + 1);
1828:       shape.path.lineTo(lastX - shape.path.deltaX(getArcSize()), shape.labelTopY);
1829:       shape.path.quadTo(lastX, shape.labelTopY, lastX, shape.labelTopY + shape.path.deltaY(getArcSize()));
1830:       shape.path.lineTo(lastX, shape.labelBottomY);
1834:         shape.path.lineTo(shape.labelRightX + 1 - shape.path.deltaX(getArcSize()), shape.labelTopY);
1835:         shape.path.quadTo(shape.labelRightX + 1, shape.labelTopY, shape.labelRightX + 1, shape.labelTopY + shape.path.deltaY(getArcSize()));
1838:         shape.path.lineTo(shape.labelRightX - shape.path.deltaX(getArcSize()), shape.labelTopY);
1839:         shape.path.quadTo(shape.labelRightX, shape.labelTopY, shape.labelRightX, shape.labelTopY + shape.path.deltaY(getArcSize()));
1842:         shape.path.lineTo(shape.labelRightX, shape.labelBottomY - shape.path.deltaY(getArcSize()));
1843:         shape.path.quadTo(shape.labelRightX, shape.labelBottomY, shape.labelRightX + shape.path.deltaX(getArcSize()), shape.labelBottomY);
1847:           shape.path.lineTo(shape.labelRightX + 1, shape.labelBottomY);
1850:           shape.path.lineTo(shape.labelRightX, shape.labelBottomY);
1856:       shape.path.lineTo(lastX, shape.labelBottomY);
1860:       shape.path.closePath();
1863:     shape.fillPath = shape.path.copy();
1892:     final ShapeTransform path = getEffectiveLayout().createShapeTransform(mySingleRowLayout.myLastSingRowLayout.firstGhost);
1894:     int topX = path.getX() + path.deltaX(getCurveArc());
1895:     int topY = path.getY() + path.deltaY(getSelectionTabVShift());
1896:     int bottomX = path.getMaxX() + path.deltaX(1);
1897:     int bottomY = path.getMaxY() + path.deltaY(1);
1899:     path.moveTo(topX, topY);
1904:       path.lineTo(bottomX, topY);
1907:       path.lineTo(bottomX - getArcSize(), topY);
1908:       path.quadTo(bottomX, topY, bottomX, topY + path.deltaY(getArcSize()));
1911:     path.lineTo(bottomX, bottomY);
1912:     path.lineTo(topX, bottomY);
1914:     path.quadTo(topX - path.deltaX(getCurveArc() * 2 - 1), bottomY - path.deltaY(Math.abs(bottomY - topY) / 4), topX,
1915:                 bottomY - path.deltaY(Math.abs(bottomY - topY) / 2));
1917:     path.quadTo(topX + path.deltaX(getCurveArc() - 1), topY + path.deltaY(Math.abs(bottomY - topY) / 4), topX, topY);
1919:     path.closePath();
1922:     g2d.fill(path.getShape());
1925:     g2d.draw(path.getShape());
1928:     g2d.drawLine(topX + path.deltaX(1), topY + path.deltaY(1), bottomX - path.deltaX(getArcSize()), topY + path.deltaY(1));
1931:     g2d.drawLine(bottomX - path.deltaX(1), topY + path.deltaY(getArcSize()), bottomX - path.deltaX(1), bottomY - path.deltaY(1));
1935:     final ShapeTransform path = getEffectiveLayout().createShapeTransform(mySingleRowLayout.myLastSingRowLayout.lastGhost);
1937:     int topX = path.getX() - path.deltaX(getArcSize());
1938:     int topY = path.getY() + path.deltaY(getSelectionTabVShift());
1939:     int bottomX = path.getMaxX() - path.deltaX(getCurveArc());
1940:     int bottomY = path.getMaxY() + path.deltaY(1);
1942:     path.moveTo(topX, topY);
1943:     path.lineTo(bottomX, topY);
1944:     path.quadTo(bottomX - getCurveArc(), topY + (bottomY - topY) / 4, bottomX, topY + (bottomY - topY) / 2);...(0 bytes skipped)...
1945:     path.quadTo(bottomX + getCurveArc(), bottomY - (bottomY - topY) / 4, bottomX, bottomY);
1946:     path.lineTo(topX, bottomY);
1948:     path.closePath();
1951:     g2d.fill(path.getShape());
1954:     g2d.draw(path.getShape());
1957:     g2d.drawLine(topX, topY + path.deltaY(1), bottomX - path.deltaX(getCurveArc()), topY + path.deltaY(1));
2188:     final ShapeTransform shaper = shape.path.copy().reset();
2190:     final Insets paintBorder = shape.path.transformInsets(myBorder.getEffectiveBorder());
2198:     final int boundsX = shape.path.getX() + shape.path.deltaX(shape.insets.left);
2201:       isHideTabs() ? shape.path.getY() + shape.path.deltaY(shape.insets.top) : shape.labelPath.getMaxY() + shape.path.deltaY(1);
2203:     final int boundsHeight = Math.abs(shape.path.getMaxY() - boundsY) - shape.insets.bottom - paintBorder.bottom;
2204:     final int boundsWidth = Math.abs(shape.path.getMaxX() - (shape.insets.left + shape.insets.right));
2216:           tabFillColor = shape.path.transformY1(shape.to, shape.from);
2220:         g2d.fill(shaper.reset().doRect(boundsX, topY + shape.path.deltaY(1), boundsWidth, paintBorder.top - 1).getShape());
2224:           final Line2D.Float line = shape.path.transformLine(boundsX, topY, boundsX + shape.path.deltaX(boundsWidth - 1), topY);
2236:           final int topLine = topY + shape.path.deltaY(paintBorder.top - 1);
2245:     g2d.fill(shaper.reset().doRect(boundsX, Math.abs(shape.path.getMaxY() - shape.insets.bottom - paintBorder.bottom), boundsWidth,
2253:                .doRect(shape.path.getMaxX() - shape.insets.right - paintBorder.right, boundsY, paintBorder.right, boundsHeight).getSh...(7 bytes skipped)...
1710:       g2d.fill(shapeInfo.fillPath.getShape());
1727:         paintBottomY = shapeInfo.labelTopY + shapeInfo.labelPath.deltaY(getArcSize() - 2);
1758:         g2d.fill(shapeInfo.fillPath.getShape());
1762:         shapeInfo.fillPath.transformLine(shapeInfo.fillPath.getX(), paintTopY, shapeInfo.fillPath.getX(), paintBottomY);
1766:                                      shapeInfo.fillPath.transformY1(shapeInfo.from, shapeInfo.to), (float)gradientLine.getX2(),
1767:                                      (float)gradientLine.getY2(), shapeInfo.fillPath.transformY1(shapeInfo.to, shapeInfo.from)));
1768:       g2d.fill(shapeInfo.fillPath.getShape());
1797:     shape.labelBottomY = shape.labelPath.getMaxY() + shape.labelPath.deltaY(1);
1798:     shape.labelTopY = shape.labelPath.getY();
1799:     shape.labelLeftX = shape.labelPath.getX();
1800:     shape.labelRightX = shape.labelPath.getX() + shape.labelPath.deltaX(shape.labelPath.getWidth());
1865:       shape.fillPath.lineTo(lastX, shape.labelBottomY + shape.fillPath.deltaY(1));
1866:       shape.fillPath.lineTo(shape.labelLeftX, shape.labelBottomY + shape.fillPath.deltaY(1));
1867:       shape.fillPath.closePath();
2192:     int topY = shape.labelPath.getMaxY() + shape.labelPath.deltaY(1);
github.com/firebase/firebase-android-sdk:firebase-database/src/main/java/com/google/firebase/database/core/Repo.java: [ master, ] java
731:     private Path path;
303:     Path path = new Path(pathSegments);
305:       operationLogger.debug("onDataUpdate: " + path);
308:       operationLogger.debug("onDataUpdate: " + path + " " + message);
317:           Map<Path, Node> taggedChildren = new HashMap<Path, Node>();
321:             taggedChildren.put(new Path(entry.getKey()), newChildNode);
323:           events = this.serverSyncTree.applyTaggedQueryMerge(path, taggedChildren, tag);
326:           events = this.serverSyncTree.applyTaggedQueryOverwrite(path, taggedSnap, tag);
329:         Map<Path, Node> changedChildren = new HashMap<Path, Node>();
333:           changedChildren.put(new Path(entry.getKey()), newChildNode);
335:         events = this.serverSyncTree.applyServerMerge(path, changedChildren);
338:         events = this.serverSyncTree.applyServerOverwrite(path, snap);
343:         this.rerunTransactions(path);
357:     Path path = new Path(pathSegments);
359:       operationLogger.debug("onRangeMergeUpdate: " + path);
362:       operationLogger.debug("onRangeMergeUpdate: " + path + " " + merges);
373:       events = this.serverSyncTree.applyTaggedRangeMerges(path, parsedMerges, new Tag(tagNumber));
375:       events = this.serverSyncTree.applyServerRangeMerges(path, parsedMerges);
380:       this.rerunTransactions(path);
389:       final Path path) {
392:       ChildKey last = path.getBack();
394:         ref = InternalHelpers.createReference(this, path.getParent());
396:         ref = InternalHelpers.createReference(this, path);
408:   private void ackWriteAndRerunTransactions(long writeId, Path path, DatabaseError error) {
416:         rerunTransactions(path);
423:       final Path path,
427:       operationLogger.debug("set: " + path);
430:       dataLogger.debug("set: " + path + " " + newValueUnresolved);
439:             path, newValueUnresolved, newValue, writeId, /*visible=*/ true, /*persist=*/ true);
443:         path.asList(),
449:             warnIfWriteFailed("setValue", path, error);
450:             ackWriteAndRerunTransactions(writeId, path, error);
451:             callOnComplete(onComplete, error, path);
455:     Path affectedPath = abortTransactions(path, DatabaseError.OVERRIDDEN_BY_SET);
460:       final Path path,
465:       operationLogger.debug("update: " + path);
468:       dataLogger.debug("update: " + path + " " + unParsedUpdates);
475:       callOnComplete(onComplete, null, path);
485:         this.serverSyncTree.applyUserMerge(path, updates, resolved, writeId, /*persist=*/ true);
491:         path.asList(),
497:             warnIfWriteFailed("updateChildren", path, error);
498:             ackWriteAndRerunTransactions(writeId, path, error);
499:             callOnComplete(onComplete, error, path);
503:     for (Entry<Path, Node> update : updates) {
504:       Path pathFromRoot = path.child(update.getKey());
505:       Path affectedPath = abortTransactions(pathFromRoot, DatabaseError.OVERRIDDEN_BY_SET);
517:     abortTransactions(Path.getEmptyPath(), DatabaseError.WRITE_CANCELED);
535:       final Path path, final Node newValue, final DatabaseReference.CompletionListener onComplete) {
537:         path.asList(),
543:             warnIfWriteFailed("onDisconnect().setValue", path, error);
545:               onDisconnect.remember(path, newValue);
547:             callOnComplete(onComplete, error, path);
553:       final Path path,
554:       final Map<Path, Node> newChildren,
558:         path.asList(),
564:             warnIfWriteFailed("onDisconnect().updateChildren", path, error);
566:               for (Map.Entry<Path, Node> entry : newChildren.entrySet()) {
567:                 onDisconnect.remember(path.child(entry.getKey()), entry.getValue());
570:             callOnComplete(listener, error, path);
576:       final Path path, final DatabaseReference.CompletionListener onComplete) {
578:         path.asList(),
584:               onDisconnect.forget(path);
586:             callOnComplete(onComplete, error, path);
652:     Path path = new Path(Constants.DOT_INFO, childKey);
655:       infoData.update(path, node);
656:       List<? extends Event> events = this.infoSyncTree.applyServerOverwrite(path, node);
674:         Path.getEmptyPath(),
677:           public void visitTree(Path prefixPath, Node node) {
679:             Path affectedPath = abortTransactions(prefixPath, DatabaseError.OVERRIDDEN_BY_SET);
687:   private void warnIfWriteFailed(String writeType, Path path, DatabaseError error) {
692:       operationLogger.warn(writeType + " at " + path.toString() + " failed: " + error.toString());
745:         Path path,
751:       this.path = path;
776:   public void startTransaction(Path path, final Transaction.Handler handler, boolean applyLocally) {
778:       operationLogger.debug("transaction: " + path);
781:       operationLogger.debug("transaction: " + path);
797:     DatabaseReference watchRef = InternalHelpers.createReference(this, path);
814:             path,
822:     Node currentState = this.getLatestState(path);
857:       Tree<List<TransactionData>> queueNode = transactionQueueTree.subTree(path);
875:               path,
886:   private Node getLatestState(Path path) {
887:     return this.getLatestState(path, new ArrayList<Long>());
890:   private Node getLatestState(Path path, List<Long> excudeSets) {
891:     Node state = this.serverSyncTree.calcCompleteEventCache(path, excudeSets);
937:   private void sendTransactionQueue(final List<TransactionData> queue, final Path path) {
944:     Node latestState = this.getLatestState(path, setsToIgnore);
956:       Path relativePath = Path.getRelative(path, txn.path);
967:         path.asList(),
974:             warnIfWriteFailed("Transaction", path, error);
990:                         InternalHelpers.createReference(repo, txn.path), IndexedNode.from(node));
1004:                         QuerySpec.defaultQueryAtPath(txn.path)));
1008:               pruneCompletedTransactions(transactionQueueTree.subTree(path));
1038:               rerunTransactions(path);
1076:   private Path rerunTransactions(Path changedPath) {
1078:     Path path = rootMostTransactionNode.getPath();
1081:     rerunTransactionQueue(queue, path);
1083:     return path;
1086:   private void rerunTransactionQueue(List<TransactionData> queue, Path path) {
1104:       Path relativePath = Path.getRelative(path, transaction.path);
1128:           Node currentNode = this.getLatestState(transaction.path, setsToIgnore);
1156:                     transaction.path,
1182:         final DatabaseReference ref = InternalHelpers.createReference(this, transaction.path);
1200:                         QuerySpec.defaultQueryAtPath(transaction.path)));
1227:   private Tree<List<TransactionData>> getAncestorTransactionNode(Path path) {
1229:     while (!path.isEmpty() && transactionNode.getValue() == null) {
1230:       transactionNode = transactionNode.subTree(new Path(path.getFront()));
1231:       path = path.popFront();
1262:   private Path abortTransactions(Path path, final int reason) {
1263:     Path affectedPath = getAncestorTransactionNode(path).getPath();
1267:           "Aborting transactions for path: " + path + ". Affected: " + affectedPath);
1270:     Tree<List<TransactionData>> transactionNode = transactionQueueTree.subTree(path);
1327:                   QuerySpec.defaultQueryAtPath(transaction.path)));
154:                         final Node node = infoData.getNode(query.getPath());
157:                               infoSyncTree.applyServerOverwrite(query.getPath(), node);
181:                     query.getPath().asList(),
198:                     query.getPath().asList(), query.getParams().getWireProtocolParams());
219:               warnIfWriteFailed("Persisted write", write.getPath(), error);
220:               ackWriteAndRerunTransactions(write.getWriteId(), write.getPath(), error);
232:         connection.put(write.getPath().asList(), write.getOverwrite().getValue(true), onComplete);
236:             write.getPath(),
246:         connection.merge(write.getPath().asList(), write.getMerge().getValue(true), onComplete);
250:             write.getPath(), write.getMerge(), resolved, write.getWriteId(), /*persist=*/ false);
302:       List<String> pathSegments, Object message, boolean isMerge, Long optTag) {
354:       List<String> pathSegments,
456:     this.rerunTransactions(affectedPath);
506:       rerunTransactions(affectedPath);
526:     if (Constants.DOT_INFO.equals(eventRegistration.getQuerySpec().getPath().getFront())) {
628:     ChildKey front = eventRegistration.getQuerySpec().getPath().getFront();
638:     assert query.getPath().isEmpty() || !query.getPath().getFront().equals(Constants.DOT_INFO);
678:             events.addAll(serverSyncTree.applyServerOverwrite(prefixPath, node));
680:             rerunTransactions(affectedPath);
924:         sendTransactionQueue(queue, node.getPath());
958:       snapToSend = snapToSend.updateChild(relativePath, txn.currentOutputSnapshotRaw);
1077:     Tree<List<TransactionData>> rootMostTransactionNode = getAncestorTransactionNode(changedPath);
1109:       assert relativePath != null; // rerunTransactionQueue: relativePath should not be null.
1290:     return affectedPath;
android.googlesource.com/platform/tools/idea:platform/platform-api/src/com/intellij/ui/tabs/impl/JBTabsImpl.java: [ master, ] java Duplicate result
android.googlesource.com/platform/external/cldr:tools/java/org/unicode/cldr/icu/LDMLConstants.java: [ master, ] java
37:     public static final String PATH = "path";
github.com/apache/sqoop:src/java/org/apache/sqoop/io/LobFile.java: [ trunk, ] java
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;
1573:      * @param p the path to create.
1579:     V0Writer(Path p, Configuration conf, boolean isCharData,
1582:       this.path = LobReaderCache.qualify(p, conf);
1605:       FileSystem fs = this.path.getFileSystem(conf);
1606:       FSDataOutputStream fsOut = fs.create(this.path);
1642:       return this.path;
868:         // Use the normal codepath; move the serialization buffer
github.com/google/caja:third_party/java/htmlparser/src/nu/validator/htmlparser/impl/ElementName.java: [ master, ] java
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,
android.googlesource.com/platform/superproject:build/soong/java/java.go: [ master, ] go
401: 	path   android.Path
703: 	classpath          classpath
704: 	bootClasspath      classpath
705: 	processorPath      classpath
1628: func (j *Binary) HostToolPath() android.OptionalPath {
377: 	bootClasspathTag      = dependencyTag{name: "bootclasspath"}
651: func shardPaths(paths android.Paths, shardSize int) []android.Paths {
1735: 	combinedClasspathFile android.Path
23: 	"path/filepath"
264: 	headerJarFile android.Path
268: 	implementationJarFile android.Path
271: 	resourceJar android.Path
275: 	implementationAndResourcesJar android.Path
278: 	dexJarFile android.Path
281: 	maybeStrippedDexJarFile android.Path
284: 	jacocoReportClassesFile android.Path
287: 	proguardDictionary android.Path
290: 	outputFile android.Path
297: 	installFile android.Path
323: func (j *Module) DexJarFile() android.Path {
396: 	aidl android.Path
538: 			jars:     android.Paths{jarPath.Path(), lambdaStubsPath},
539: 			aidl:     aidlPath.Path(),
712: 	systemModules      android.Path
1040: func (j *Module) compile(ctx android.ModuleContext, extraSrcJars ...android.Path) {
1337: 	// Save the output file with no relative path so that it doesn't end up in a subdirectory when used as a resource
1360: 					"Bad flag: `%s`, kotlin home already set to default (path to kotlinc in the repo).", flag)
1367: 	deps deps, flags javaBuilderFlags, jarName string, extraJars android.Paths) android.Path {
1384: 	var headerJar android.Path
1409: 	classesJar android.Path, jarName string) android.ModuleOutPath {
1557: 	testConfig android.Path
1624: 	wrapperFile android.Path
81: 	// don't build against the default libraries (bootclasspath, legacy-test, core-junit,
95: 	// list of of java libraries that will be in the classpath
126: 	// Add host jdk tools.jar to bootclasspath
263: 	// inserting into the bootclasspath/classpath of another compile
292: 	exportAidlIncludeDirs android.Paths
294: 	logtagsSrcs android.Paths
300: 	compiledJavaSrcs android.Paths
301: 	compiledSrcJars  android.Paths
304: 	extraProguardFlagFiles android.Paths
307: 	overrideManifest android.OptionalPath
319: func (j *Module) Srcs() android.Paths {
320: 	return android.Paths{j.outputFile}
330: 	HeaderJars() android.Paths
331: 	ImplementationJars() android.Paths
332: 	ResourceJars() android.Paths
333: 	ImplementationAndResourcesJars() android.Paths
334: 	AidlIncludeDirs() android.Paths
339: 	HeaderJars(linkType linkType) android.Paths
340: 	ImplementationJars(linkType linkType) android.Paths
344: 	CompiledSrcs() android.Paths
345: 	CompiledSrcJars() android.Paths
348: func (j *Module) CompiledSrcs() android.Paths {
352: func (j *Module) CompiledSrcJars() android.Paths {
395: 	jars android.Paths
509: 		dir := filepath.Join("prebuilts", "sdk", v, api)
510: 		jar := filepath.Join(dir, "android.jar")
513: 		public_dir := filepath.Join("prebuilts", "sdk", v, "public")
514: 		aidl := filepath.Join(public_dir, "framework.aidl")
515: 		jarPath := android.ExistentPathForSource(ctx, jar)
516: 		aidlPath := android.ExistentPathForSource(ctx, aidl)
517: 		lambdaStubsPath := android.PathForSource(ctx, config.SdkLambdaStubsPath)
519: 		if (!jarPath.Valid() || !aidlPath.Valid()) && ctx.Config().AllowMissingDependencies() {
526: 		if !jarPath.Valid() {
531: 		if !aidlPath.Valid() {
643: 		if filepath.Ext(src) == ext {
652: 	ret := make([]android.Paths, 0, (len(paths)+shardSize-1)/shardSize)
653: 	for len(paths) > shardSize {
654: 		ret = append(ret, paths[0:shardSize])
655: 		paths = paths[shardSize:]
657: 	if len(paths) > 0 {
658: 		ret = append(ret, paths)
667: func (j *Module) aidlFlags(ctx android.ModuleContext, aidlPreprocess android.OptionalPath,
668: 	aidlIncludeDirs android.Paths) []string {
670: 	aidlIncludes := android.PathsForModuleSrc(ctx, j.deviceProperties.Aidl.Local_include_dirs)
672: 		android.PathsForModuleSrc(ctx, j.deviceProperties.Aidl.Export_include_dirs)...)
674: 		android.PathsForSource(ctx, j.deviceProperties.Aidl.Include_dirs)...)
686: 	flags = append(flags, "-I"+android.PathForModuleSrc(ctx).String())
706: 	staticJars         android.Paths
707: 	staticHeaderJars   android.Paths
708: 	staticResourceJars android.Paths
709: 	aidlIncludeDirs    android.Paths
710: 	srcs               android.Paths
711: 	srcJars            android.Paths
713: 	aidlPreprocess     android.OptionalPath
714: 	kotlinStdlib       android.Paths
812: 			deps.classpath = append(deps.classpath, sdkDep.jars...)
840: 				deps.bootClasspath = append(deps.bootClasspath, dep.HeaderJars()...)
842: 				deps.classpath = append(deps.classpath, dep.HeaderJars()...)
846: 				deps.classpath = append(deps.classpath, dep.HeaderJars()...)
853: 				deps.processorPath = append(deps.processorPath, dep.ImplementationAndResourcesJars()...)
881: 				deps.classpath = append(deps.classpath, dep.HeaderJars(linkType)...)
891: 				deps.classpath = append(deps.classpath, dep.Srcs()...)
894: 				deps.classpath = append(deps.classpath, dep.Srcs()...)
967: 		if config.ErrorProneClasspath == nil {
979: 		flags.errorProneProcessorPath = classpath(android.PathsForSource(ctx, config.ErrorProneClasspath))
982: 	// classpath
983: 	flags.bootClasspath = append(flags.bootClasspath, deps.bootClasspath...)
984: 	flags.classpath = append(flags.classpath, deps.classpath...)
985: 	flags.processorPath = append(flags.processorPath, deps.processorPath...)
987: 	if len(flags.bootClasspath) == 0 && ctx.Host() && flags.javaVersion != "1.9" &&
998: 		// putting them on the bootclasspath means that:
1004: 		flags.bootClasspath = append(flags.bootClasspath,
1005: 			android.PathForSource(ctx, java8Home, "jre/lib/jce.jar"),
1006: 			android.PathForSource(ctx, java8Home, "jre/lib/rt.jar"))
1008: 			flags.bootClasspath = append(flags.bootClasspath,
1009: 				android.PathForSource(ctx, java8Home, "lib/tools.jar"))
1014: 		patchClasspath := ".:" + flags.classpath.FormJavaClassPath("")
1015: ...(0 bytes skipped)...		javacFlags = append(javacFlags, "--patch-module="+String(j.properties.Patch_module)+"="+patchClasspath)
1042: 	j.exportAidlIncludeDirs = android.PathsForModuleSrc(ctx, j.deviceProperties.Aidl.Export_include_dirs)
1068: 	var uniqueSrcFiles android.Paths
1077: 	var kotlinJars android.Paths
1097: 		var kotlinSrcFiles android.Paths
1101: 		flags.kotlincClasspath = append(flags.kotlincClasspath, deps.bootClasspath...)
1102: 		flags.kotlincClasspath = append(flags.kotlincClasspath, deps.kotlinStdlib...)
1103: 		flags.kotlincClasspath = append(flags.kotlincClasspath, deps.classpath...)
1105: 		kotlinJar := android.PathForModuleOut(ctx, "kotlin", jarName)
1112: 		flags.classpath = append(flags.classpath, deps.kotlinStdlib...)
1113: 		flags.classpath = append(flags.classpath, kotlinJar)
1120: 	jars := append(android.Paths(nil), kotlinJars...)
1143: 		var extraJarDeps android.Paths
1150: 			errorprone := android.PathForModuleOut(ctx, "errorprone", jarName)
1156: 			flags.classpath = append(flags.classpath, j.headerJarFile)
1158: 			var shardSrcs []android.Paths
1162: 					classes := android.PathForModuleOut(ctx, "javac", jarName+strconv.Itoa(idx))
1168: 				classes := android.PathForModuleOut(ctx, "javac", jarName+strconv.Itoa(len(shardSrcs)))
1173: 			classes := android.PathForModuleOut(ctx, "javac", jarName)
1187: 	var resDeps android.Paths
1202: 		resourceJar := android.PathForModuleOut(ctx, "res", jarName)
1211: 		var jars android.Paths
1217: 		combinedJar := android.PathForModuleOut(ctx, "res-combined", jarName)
1218: 		TransformJarsToJar(ctx, combinedJar, "for resources", jars, android.OptionalPath{},
1228: 		manifest = android.OptionalPathForPath(ctx.ExpandSource(*j.properties.Manifest, "manifest"))
1233: 	var outputFile android.ModuleOutPath
1236: 		if moduleOutPath, ok := jars[0].(android.ModuleOutPath); ok {
1241: 			outputFile = moduleOutPath
1243: 			combinedJar := android.PathForModuleOut(ctx, "combined", jarName)
1252: 		combinedJar := android.PathForModuleOut(ctx, "combined", jarName)
1260: 		jarjar_rules := android.PathForModuleSrc(ctx, *j.properties.Jarjar_rules)
1262: 		jarjarFile := android.PathForModuleOut(ctx, "jarjar", jarName)
1268: 			resourceJarJarFile := android.PathForModuleOut(ctx, "res-jarjar", jarName)
1295: 		jars := android.Paths{implementationAndResourcesJar, j.resourceJar}
1296: 		combinedJar := android.PathForModuleOut(ctx, "withres", jarName)
1297: 		TransformJarsToJar(ctx, combinedJar, "for resources", jars, android.OptionalPath{},
1305: 		var dexOutputFile android.ModuleOutPath
1313: 			jars := android.Paths{dexOutputFile, j.resourceJar}
1314: 			combinedJar := android.PathForModuleOut(ctx, "dex-withres", jarName)
1315: 			TransformJarsToJar(ctx, combinedJar, "for dex resources", jars, android.OptionalPath{},
1366: func (j *Module) compileJavaHeader(ctx android.ModuleContext, srcFiles, srcJars android.Paths,
1369: 	var jars android.Paths
1372: 		turbineJar := android.PathForModuleOut(ctx, "turbine", jarName)
1389: 	combinedJar := android.PathForModuleOut(ctx, "turbine-combined", jarName)
1390: 	TransformJarsToJar(ctx, combinedJar, "for turbine", jars, android.OptionalPath{},
1395: 		jarjar_rules := android.PathForModuleSrc(ctx, *j.properties.Jarjar_rules)
1397: 		jarjarFile := android.PathForModuleOut(ctx, "turbine-jarjar", jarName)
1413: 	jacocoReportClassesFile := android.PathForModuleOut(ctx, "jacoco-report-classes", jarName)
1414: 	instrumentedJar := android.PathForModuleOut(ctx, "jacoco", jarName)
1425: func (j *Module) HeaderJars() android.Paths {
1426: 	return android.Paths{j.headerJarFile}
1429: func (j *Module) ImplementationJars() android.Paths {
1430: 	return android.Paths{j.implementationJarFile}
1433: func (j *Module) ResourceJars() android.Paths {
1437: 	return android.Paths{j.resourceJar}
1440: func (j *Module) ImplementationAndResourcesJars() android.Paths {
1441: 	return android.Paths{j.implementationAndResourcesJar}
1444: func (j *Module) AidlIncludeDirs() android.Paths {
1454: func (j *Module) logtags() android.Paths {
1484: 	j.dexpreopter.installPath = android.PathForModuleInstall(ctx, "framework", ctx.ModuleName()+".jar")
1490: 			alignedOutputFile := android.PathForModuleOut(ctx, "aligned", ctx.ModuleName()+".jar")
1495: 		j.installFile = ctx.InstallFile(android.PathForModuleInstall(ctx, "framework"),
1558: 	data       android.Paths
1625: 	binaryFile  android.OutputPath
1629: 	return android.OptionalPathForPath(j.binaryFile)
1639: 			manifestFile := android.PathForModuleOut(ctx, "manifest.txt")
1641: 			j.overrideManifest = android.OptionalPathForPath(manifestFile)
1652: 			j.wrapperFile = android.PathForSource(ctx, "build/soong/scripts/jar-wrapper.sh")
1659: 		j.binaryFile = ctx.InstallExecutable(android.PathForModuleInstall(ctx, "bin"),
1768: 	outputFile := android.PathForModuleOut(ctx, "combined", jarName)
1769: 	TransformJarsToJar(ctx, outputFile, "for prebuilts", jars, android.OptionalPath{},
1773: 		outputFile = android.PathForModuleOut(ctx, "jetifier", jarName)
1800: 		ctx.InstallFile(android.PathForModuleInstall(ctx, "framework"),
1807: func (j *Import) HeaderJars() android.Paths {
1808: 	return android.Paths{j.combinedClasspathFile}
1811: func (j *Import) ImplementationJars() android.Paths {
1812: 	return android.Paths{j.combinedClasspathFile}
1815: func (j *Import) ResourceJars() android.Paths {
1819: func (j *Import) ImplementationAndResourcesJars() android.Paths {
1820: 	return android.Paths{j.combinedClasspathFile}
1823: func (j *Import) AidlIncludeDirs() android.Paths {
586: 				ctx.AddVariationDependencies(nil, bootClasspathTag, config.DefaultBootclasspathLibraries...)
593: 				ctx.AddVariationDependencies(nil, bootClasspathTag, sdkDep.modules...)
595: 					ctx.AddVariationDependencies(nil, proguardRaiseTag, config.DefaultBootclasspathLibraries...)
687: 	if src := android.ExistentPathForSource(ctx, ctx.ModuleDir(), "src"); src.Valid() {
832: 			case bootClasspathTag, libTag, staticLibTag:
839: 			case bootClasspathTag:
1160: 				shardSrcs = shardPaths(uniqueSrcFiles, shardSize)
1776: 	j.combinedClasspathFile = outputFile
gerrit.googlesource.com/gerrit:java/com/google/gerrit/server/query/change/ChangeQueryBuilder.java: [ master, ] java
728:   public Predicate<ChangeData> path(String path) {
159:   public static final String FIELD_PATH = "path";
729:     if (path.startsWith("^")) {
730:       return new RegexPathPredicate(path);
732:     return new EqualsPathPredicate(FIELD_PATH, path);
722:       return new RegexPathPredicate(file);
chromium.googlesource.com/arc/arc:third_party/android/frameworks/base/core/java/android/net/Uri.java: [ master, ] java
588:         private PathPart path;
1140:         private final PathPart path;
1322:         private PathPart path;
1386:         Builder path(PathPart path) {
1402:         public Builder path(String path) {
264:     public abstract String getPath();
272:     public abstract String getEncodedPath();
596:         public String getPath() {
600:         public String getEncodedPath() {
608:         private String parsePath() {
739:         static String parsePath(String uriString, int ssi) {
889:         public String getPath() {
893:         public String getEncodedPath() {
969:     static class PathSegments extends AbstractList<String>
977:         PathSegments(String[] segments, int size) {
998:     static class PathSegmentsBuilder {
1237:         public String getEncodedPath() {
1241:         public String getPath() {
1413:         public Builder encodedPath(String path) {
1420:         public Builder appendPath(String newSegment) {
1427:         public Builder appendEncodedPath(String newSegment) {
2098:     static class PathPart extends AbstractPart {
2106:         private PathPart(String encoded, String decoded) {
2122:         private PathSegments pathSegments;
2292:     public static Uri withAppendedPath(Uri baseUri, String pathSegment) {
313:     public abstract List<String> getPathSegments();
320:     public abstract String getLastPathSegment();
590:         private PathPart getPathPart() {
604:         public List<String> getPathSegments() {
913:         public List<String> getPathSegments() {
917:         public String getLastPathSegment() {
1034:         public String getLastPathSegment() {
1261:         public List<String> getPathSegments() {
2130:         PathSegments getPathSegments() {
2351:     public boolean isPathPrefixMatch(Uri prefix) {
102:        and a path component that begins with two slash characters.  The
108:     <scheme>://<authority><path>?<query>
259:      * Gets the decoded path.
261:      * @return the decoded path, or null if this is not a hierarchical URI
267:      * Gets the encoded path.
269:      * @return the encoded path, or null if this is not a hierarchical URI
309:      * Gets the decoded path segments.
311:      * @return decoded path segments, each without a leading or trailing '/'
316:      * Gets the decoded last segment in the path.
318:      * @return the decoded last segment or null if the path is empty
437:      * "file://<absolute path>". Encodes path characters with the exception of
450:         PathPart path = PathPart.fromDecoded(file.getAbsolutePath());
452:                 "file", Part.EMPTY, path, Part.NULL, Part.NULL);
591:             return path == null
592:                     ? path = PathPart.fromEncoded(parsePath())
593:                     : path;
711:                 // Look for the start of the path, query, or fragment, or the
716:                         case '/': // Start of path
732:          * Parses a path out of this given URI string.
737:          * @return the path
742:             // Find start of path.
747:                 // Skip over authority to path.
753:                             return ""; // Empty path.
754:                         case '/': // Start of path!
760:                 // Path starts immediately after scheme separator.
764:             // Find end of path.
783:                         .path(getPathPart())
967:      * Wrapper for path segment array.
1144:         private HierarchicalUri(String scheme, Part authority, PathPart path,
1148:             this.path = path == null ? PathPart.NULL : path;
1171:             path.writeTo(parcel);
1219:             String encodedPath = path.getEncoded();
1238:             return this.path.getEncoded();
1242:             return this.path.getDecoded();
1262:             return this.path.getPathSegments();
1295:                     .path(path)
1306:      * {@code <scheme>://<authority><absolute path>?<query>#<fragment>}
1309:      * of two patterns: {@code <relative or absolute path>?<query>#<fragment>}
1310:      * or {@code //<authority><absolute path>?<query>#<fragment>}
1390:             this.path = path;
1395:          * Sets the path. Leaves '/' characters intact but encodes others as
1398:          * <p>If the path is not null and doesn't start with a '/', and if
1400:          * given path with a '/'.
1403:             return path(PathPart.fromDecoded(path));
1407:          * Sets the previously encoded path.
1409:          * <p>If the path is not null and doesn't start with a '/', and if
1411:          * given path with a '/'.
1414:             return path(PathPart.fromEncoded(path));
1418:          * Encodes the given segment and appends it to the path.
1421:             return path(PathPart.appendDecodedSegment(path, newSegment));
1425:          * Appends the given segment to the path.
1428:             return path(PathPart.appendEncodedSegment(path, newSegment));
1524:                 PathPart path = this.path;
1525:                 if (path == null || path == PathPart.NULL) {
1526:                     path = PathPart.EMPTY;
1528:                     // If we have a scheme and/or authority, the path must
1531:                         path = PathPart.makeAbsolute(path);
1536:                         scheme, authority, path, query, fragment);
2095:      * Immutable wrapper of encoded and decoded versions of a path part. Lazily
2119:          * Cached path segments. This doesn't need to be volatile--we don't
2125:          * Gets the individual path segments. Parses them if necessary.
2127:          * @return parsed path segments or null if this isn't a hierarchical
2135:             String path = getEncoded();
2136:             if (path == null) {
2144:             while ((current = path.indexOf('/', previous)) > -1) {
2145:                 // This check keeps us from adding a segment if the path starts
2149:                             = decode(path.substring(previous, current));
2155:             // Add in the final path segment.
2156:             if (previous < path.length()) {
2157:                 segmentBuilder.add(decode(path.substring(previous)));
2165:             // If there is no old path, should we make the new path relative
2169:                 // No old path.
2182:                 // No old path.
2215:          * Creates a path from the encoded string.
2224:          * Creates a path from the decoded string.
2233:          * Creates a path from the encoded and decoded strings.
2251:          * Prepends path values with "/" if they're present, not empty, and
2283:      * Creates a new Uri by appending an already-encoded path segment to a
2286:      * @param baseUri Uri to append path segment to
2287:      * @param pathSegment encoded path segment to append
2289:      *  the path
2300:      * canonical path. Also fixes legacy emulated storage paths so they are
2319:                 // Splice in user-specific path when legacy path is found
2346:      * Test if this is a path prefix match against the given Uri. Verifies that
2347:      * scheme, authority, and atomic path segments match.
131:             PathPart.EMPTY, Part.NULL, Part.NULL);
325:      * equal. Case counts. Paths are not normalized. If one Uri specifies a
630:             return parsePath(uriString, ssi);
743:             int pathStart;
748:                 pathStart = ssi + 3;
749:                 LOOP: while (pathStart < length) {
750:                     switch (uriString.charAt(pathStart)) {
757:                     pathStart++;
761:                 pathStart = ssi + 1;
765:             int pathEnd = pathStart;
766:             LOOP: while (pathEnd < length) {
767:                 switch (uriString.charAt(pathEnd)) {
772:                 pathEnd++;
775:             return uriString.substring(pathStart, pathEnd);
972:         static final PathSegments EMPTY = new PathSegments(null, 0);
996:      * Builds PathSegments.
1015:         PathSegments build() {
1017:                 return PathSegments.EMPTY;
1021:                 return new PathSegments(segments, size);
1157:                 PathPart.readFrom(parcel),
1220:             if (encodedPath != null) {
1221:                 builder.append(encodedPath);
1523:                 // Hierarchical URIs should not return null for getPath().
2101:         static final PathPart NULL = new PathPart(null, null);
2104:         static final PathPart EMPTY = new PathPart("", "");
2131:             if (pathSegments != null) {
2132:                 return pathSegments;
2137:                 return pathSegments = PathSegments.EMPTY;
2140:             PathSegmentsBuilder segmentBuilder = new PathSegmentsBuilder();
2160:             return pathSegments = segmentBuilder.build();
2163:         static PathPart appendEncodedSegment(PathPart oldPart,
2173:             String oldPath = oldPart.getEncoded();
2175:             if (oldPath == null) {
2176:                 oldPath = "";
2179:             int oldPathLength = oldPath.length();
2180:             String newPath;
2183:                 newPath = "/" + newSegment;
2184:             } else if (oldPath.charAt(oldPathLength - 1) == '/') {
2185:                 newPath = oldPath + newSegment;
2187:                 newPath = oldPath + "/" + newSegment;
2190:             return fromEncoded(newPath);
2193:         static PathPart appendDecodedSegment(PathPart oldPart, String decoded) {
2196:             // TODO: Should we reuse old PathSegments? Probably not.
2200:         static PathPart readFrom(Parcel parcel) {
2219:         static PathPart fromEncoded(String encoded) {
2228:         static PathPart fromDecoded(String decoded) {
2238:         static PathPart from(String encoded, String decoded) {
2247:             return new PathPart(encoded, decoded);
2254:         static PathPart makeAbsolute(PathPart oldPart) {
2260:             String oldPath = encodedCached ? oldPart.encoded : oldPart.decoded;
2262:             if (oldPath == null || oldPath.length() == 0
2263:                     || oldPath.startsWith("/")) {
2278:             return new PathPart(newEncoded, newDecoded);
2294:         builder = builder.appendEncodedPath(pathSegment);
2308:             final String canonicalPath;
2310:                 canonicalPath = new File(getPath()).getCanonicalPath();
2316:                 final String legacyPath = Environment.getLegacyExternalStorageDirectory()
2320:                 if (canonicalPath.startsWith(legacyPath)) {
2323:                             canonicalPath.substring(legacyPath.length() + 1)));
2327:             return Uri.fromFile(new File(canonicalPath));
597:             return getPathPart().getDecoded();
601:             return getPathPart().getEncoded();
605:             return getPathPart().getPathSegments();
1038:             List<String> segments = getPathSegments();
2181:             if (oldPathLength == 0) {
2355:         List<String> seg = getPathSegments();
2356:         List<String> prefixSeg = prefix.getPathSegments();
github.com/google/copybara:java/com/google/copybara/git/GitRepository.java: [ master, ] java
1136:     private final String path;
1187:     private final String path;
1168:     public String getPath() {
1203:     public String getPath() {
1386:     private final ImmutableCollection<String> paths;
1453:     LogCmd withPaths(ImmutableCollection<String> paths) {
63: import java.nio.file.Path;
109:               "ambiguous argument '(.+)': unknown revision or path not in the working tree"));
147:   private final Path gitDir;
150:   private final Path workTree;
161:       Path gitDir, @Nullable Path workTree, boolean verbose, GitEnvironment gitEnv,
171:   public static GitRepository newRepo(boolean verbose, Path path, GitEnvironment gitEnv,
173:     return new GitRepository(path.resolve(".git"), path, verbose, gitEnv, fetchTimeout);
177:   public static GitRepository newBareRepo(Path gitDir, GitEnvironment gitEnv, boolean verbose,
208:   static void validateRefSpec(GitEnvironment gitEnv, Path cwd, String refspec)
230:    * <p>Note that this method doesn't support fetching refspecs that contain local ref path
238:           + " contain local ref path locations or wildcards is not supported. Invalid ref: " + ref);
329:    * Runs a git ls-remote from the current directory for a repository url. Assumes the path to the
462:   public GitRepository withWorkTree(Path newWorkTree) {
471:   public Path getWorkTree() {
475:   public Path getGitDir() {
672:     Path descriptionFile = null;
754:       String path = getSubmoduleField(submoduleName, "path");
756:       if (path == null) {
757:         throw new RepoException("Path is required for submodule " + submoduleName);
769:       FileUtil.checkNormalizedRelative(path);
777:         result.add(new Submodule(validateUrl(url), submoduleName, branch, path));
800:       String path = matcher.group(4)
804:       result.add(new TreeElement(objectType, sha1, path));
825:   private Path getCwd() {
940:   public CommandOutput git(Path cwd, String... params) throws RepoException {
951:    * <p>See also {@link #git(Path, String[])}.
956:   private CommandOutput git(Path cwd, Iterable<String> params) throws RepoException {
1020:       Path cwd, Iterable<String> params, GitEnvironment gitEnv, boolean verbose)
1026:       Path cwd, Iterable<String> params, GitEnvironment gitEnv, boolean verbose, int maxLogLines)
1138:     private Submodule(String url, String name, String branch, String path) {
1142:       this.path = path;
1167:     /** Relative path for the checkout of the submodule */
1169:       return path;
1178:           .add("path", path)
1189:     private TreeElement(GitObjectType type, String ref, String path) {
1192:       this.path = checkNotNull(path);
1204:       return path;
1212:           .add("file", path)
64: import java.nio.file.Paths;
107:           Pattern.compile("pathspec '(.+)' did not match any file"),
192:                   Paths.get(StandardSystemProperty.USER_DIR.value()),
354:       output = executeGit(FileSystems.getDefault().getPath("."), args, gitEnv, false, maxLogLines);
395:     if (Files.isDirectory(Paths.get(url))) {
677:         params.add("-F", descriptionFile.toAbsolutePath().toString());
1401:     LogCmd(GitRepository repo, String refExpr, int limit, ImmutableCollection<String> paths,
1405:       this.paths = paths;
1435:       return new LogCmd(repo, refExpr, limit, paths, firstParent, includeStat, includeBody,
1445:       return new LogCmd(repo, refExpr, limit, paths, firstParent, includeStat, includeBody,
1450:      * Only query for changes in {@code paths} paths.
1454:       Preconditions.checkArgument(paths.stream().noneMatch(s -> s.trim().equals("")));
1455:       return new LogCmd(repo, refExpr, limit, paths, firstParent, includeStat, includeBody,
1464:       return new LogCmd(repo, refExpr, limit, paths, firstParent, includeStat, includeBody,
1473:       return new LogCmd(repo, refExpr, limit, paths, firstParent, includeStat, includeBody,
1482:       return new LogCmd(repo, refExpr, limit, paths, firstParent, includeStat, includeBody,
1491:       return new LogCmd(repo, refExpr, limit, paths, firstParent, includeStat, includeBody,
1500:       return new LogCmd(repo, refExpr, limit, paths, firstParent, includeStat, includeBody,
1539:       if (!paths.isEmpty()) {
1541:         cmd.addAll(paths);