Found 105398 results in 10328 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-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;
394:     public String getPath() {
398:     public URL setPath(String path) {
402:     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: ...(17 bytes skipped)...ring protocol, String host, int port, String[] pairs) { // varargs ... confilict 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;
213:             // case: file:/path/to/file.txt
224:             path = url.substring(i + 1);
243:         return new URL(protocol, username, password, host, port, path, parameters);
273:         return new URL(protocol, username, password, host, port, path, getParameters());
281:         return new URL(protocol, username, password, host, port, path, getParameters());
289:         return new URL(protocol, username, password, host, port, path, getParameters());
306:         return new URL(protocol, username, password, host, port, path, getParameters());
329:         return new URL(protocol, username, password, host, port, path, getParameters());
350:         return new URL(protocol, username, password, host, port, path, getParameters());
395:         return path;
399:         return new URL(protocol, username, password, host, port, path, getParameters());
403:         if (path != null && !path.startsWith("/")) {
404:             return "/" + path;
406:         return path;
937:         return new URL(protocol, username, password, host, port, path, map);
950:         return new URL(protocol, username, password, host, port, path, map);
984:         return new URL(protocol, username, password, host, port, path, map);
993:         return new URL(protocol, username, password, host, port, path, map);
1043:         return new URL(protocol, username, password, host, port, path, map);
1047:         return new URL(protocol, username, password, host, port, path, new HashMap<String, String>());
1061:         if ("path".equals(key))
1062:             return path;
1078:         if (path != null)
1079:             map.put("path", path);
1184:         String path;
1186:             path = getServiceKey();
1188:             path = getPath();
1190:         if (path != null && path.length() > 0) {
1192:             buf.append(path);
1242:         return getParameter(Constants.INTERFACE_KEY, path);
1346:         result = prime * result + ((path == null) ? 0 : path.hashCode());
1377:         if (path == null) {
1378:             if (other.path != null)
1380:         } else if (!path.equals(other.path))
github.com/apache/incubator-weex:android/sdk/src/main/java/com/taobao/weex/common/Constants.java: [ master, ] java
366:     String PATH = "codeCachePath";
368:     String SAVE_PATH = "v8";
github.com/apache/zookeeper:src/java/main/org/apache/zookeeper/KeeperException.java: [ master, ] java
490:     private String path;
523:     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;
496:     KeeperException(Code code, String path) {
498:         this.path = path;
520:      * Read the path for this exception
521:      * @return the path associated with this error, null if none
524:         return path;
529:         if (path == null || path.isEmpty()) {
532:         return "KeeperErrorCode = " + getCodeMessage(code) + " for " + path;
579:         public BadArgumentsException(String path) {
580:             super(Code.BADARGUMENTS, path);
592:         public BadVersionException(String path) {
593:             super(Code.BADVERSION, path);
625:         public InvalidACLException(String path) {
626:             super(Code.INVALIDACL, path);
688:         public NoChildrenForEphemeralsException(String path) {
689:             super(Code.NOCHILDRENFOREPHEMERALS, path);
701:         public NodeExistsException(String path) {
702:             super(Code.NODEEXISTS, path);
714:         public NoNodeException(String path) {
715:             super(Code.NONODE, path);
727:         public NotEmptyException(String path) {
728:             super(Code.NOTEMPTY, path);
831:         public NoWatcherException(String path) {
832:             super(Code.NOWATCHER, path);
842:         public ReconfigDisabledException(String path) {
843:             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:src/java/main/org/apache/zookeeper/ClientCnxn.java: [ master, ] java
1592:         private final String path;
166:     final String chrootPath;
253:         String clientPath;
255:         String serverPath;
252:         /** Client's view of the path (may differ due to chroot) **/
254:         /** Servers's view of the path (may differ due to chroot) **/
471:         public void queueCallback(AsyncCallback cb, int rc, String path,
473:             waitingEvents.add(new LocalCallback(cb, rc, path, ctx));
533:                         ((StatCallback) lcb.cb).processResult(lcb.rc, lcb.path,
536:                         ((DataCallback) lcb.cb).processResult(lcb.rc, lcb.path,
539:                         ((ACLCallback) lcb.cb).processResult(lcb.rc, lcb.path,
543:                                 lcb.path, lcb.ctx, null);
546:                                 lcb.path, lcb.ctx, null, null);
549:                                 lcb.path, lcb.ctx, null);
551:                         ((VoidCallback) lcb.cb).processResult(lcb.rc, lcb.path,
726:     void queueCallback(AsyncCallback cb, int rc, String path, Object ctx) {
727:         eventThread.queueCallback(cb, rc, path, ctx);
840:                 // convert from a server path to a client path
848:                     	LOG.warn("Got server path " + event.getPath()
849:                     			+ " which is too short for chroot path "
1595:         public LocalCallback(AsyncCallback cb, int rc, String path, Object ctx) {
1598:             this.path = path;
317:             sb.append("clientPath:" + clientPath);
318:             sb.append(" serverPath:" + serverPath);
336:      * @param chrootPath - the chroot of this client. Should be removed from this Class in ZOOKEEPER-838
351:     public ClientCnxn(String chrootPath, HostProvider hostProvider, int sessionTimeout, ZooKeeper zooKeeper,
354:         this(chrootPath, hostProvider, sessionTimeout, zooKeeper, watcher,
363:      * @param chrootPath - the chroot of this client. Should be removed from this Class in ZOOKEEPER-838
380:     public ClientCnxn(String chrootPath, HostProvider hostProvider, int sessionTimeout, ZooKeeper zooKeeper,
389:         this.chrootPath = chrootPath;
461:                         event.getType(), event.getPath());
557:                   String clientPath = p.clientPath;
569:                               cb.processResult(rc, clientPath, p.ctx,
573:                               cb.processResult(rc, clientPath, p.ctx,
577:                               cb.processResult(rc, clientPath, p.ctx,
582:                           cb.processResult(rc, clientPath, p.ctx, null);
588:                           cb.processResult(rc, clientPath, p.ctx, rsp
591:                           cb.processResult(rc, clientPath, p.ctx, null,
598:                           cb.processResult(rc, clientPath, p.ctx, rsp
601:                           cb.processResult(rc, clientPath, p.ctx, null,
608:                           cb.processResult(rc, clientPath, p.ctx, rsp
611:                           cb.processResult(rc, clientPath, p.ctx, null);
617:                           cb.processResult(rc, clientPath, p.ctx, rsp
620:                           cb.processResult(rc, clientPath, p.ctx, null, null);
626:                           cb.processResult(rc, clientPath, p.ctx,
627:                                   (chrootPath == null
628:                                           ? rsp.getPath()
629:                                           : rsp.getPath()
630:                                     .substring(chrootPath.length())));
632:                           cb.processResult(rc, clientPath, p.ctx, null);
638:                           cb.processResult(rc, clientPath, p.ctx,
639:                                   (chrootPath == null
640:                                           ? rsp.getPath()
641:                                           : rsp.getPath()
642:                                     .substring(chrootPath.length())), rsp.getStat());
644:                           cb.processResult(rc, clientPath, p.ctx, null, null);
659:                 		  cb.processResult(newRc, clientPath, p.ctx, results);
661:                 		  cb.processResult(rc, clientPath, p.ctx, null);
665:                       cb.processResult(rc, clientPath, p.ctx);
689:                         queueEvent(p.watchDeregistration.getClientPath(), err,
714:     void queueEvent(String clientPath, int err,
722:                 clientPath);
841:                 if (chrootPath != null) {
842:                     String serverPath = event.getPath();
843:                     if(serverPath.compareTo(chrootPath)==0)
844:                         event.setPath("/");
845:                     else if (serverPath.length() > chrootPath.length())
846:                         event.setPath(serverPath.substring(chrootPath.length()));
850:                     			+ chrootPath);
1020:         private List<String> prependChroot(List<String> paths) {
1021:             if (chrootPath != null && !paths.isEmpty()) {
1022:                 for (int i = 0; i < paths.size(); ++i) {
1023:                     String clientPath = paths.get(i);
1024:                     String serverPath;
1025:                     // handle clientPath = "/"
1026:                     if (clientPath.length() == 1) {
1027:                         serverPath = chrootPath;
1029:                         serverPath = chrootPath + clientPath;
1031:                     paths.set(i, serverPath);
1034:             return paths;
1534:             Record response, AsyncCallback cb, String clientPath,
1535:             String serverPath, Object ctx, WatchRegistration watchRegistration) {
1536:         return queuePacket(h, r, request, response, cb, clientPath, serverPath,
1541:             Record response, AsyncCallback cb, String clientPath,
1542:             String serverPath, Object ctx, WatchRegistration watchRegistration,
1552:         packet.clientPath = clientPath;
1553:         packet.serverPath = serverPath;
github.com/google/error-prone:check_api/src/main/java/com/google/errorprone/util/ASTHelpers.java: [ master, ] java
1074:     public abstract TreePath path();
293:   public static <T> TreePath findPathFromEnclosingNodeToTopLevel(TreePath path, Class<T> klass) {
290:    * Given a TreePath, finds the first enclosing node of the given type and returns the path from
294:     if (path != null) {
296:         path = path.getParentPath();
297:       } while (path != null && !(klass.isInstance(path.getLeaf())));
299:     return path;
307:   public static <T> T findEnclosingNode(TreePath path, Class<T> klass) {
308:     path = findPathFromEnclosingNodeToTopLevel(path, klass);
309:     return (path == null) ? null : klass.cast(path.getLeaf());
944:    * normalized to always use '/' to separate elements of the path and to always have a leading '/'.
1076:     static TargetType create(Type type, TreePath path) {
1077:       return new AutoValue_ASTHelpers_TargetType(type, path);
1134:    * Returns the target type of the tree at the given {@link VisitorState}'s path, or else {@code
1212:       for (TreePath path = parent; path != null; path = path.getParentPath()) {
1213:         Tree enclosing = path.getLeaf();
68: import com.sun.source.util.TreePath;
303:    * Given a TreePath, walks up the tree until it finds a node of the given type. Returns null if no
595:       // @Inherited won't work if the annotation isn't on the classpath, but we can still check
793:     TreePath pathToExpr = new TreePath(state.getPath(), expr);
794:     return nullnessAnalysis.getNullness(pathToExpr, state.context);
898:    * Returns true if the leaf node in the {@link TreePath} from {@code state} sits somewhere
902:     for (Tree ancestor : state.getPath()) {
949:       return uri.getPath();
954:       // It's possible (though it violates the zip file spec) for paths to zip file entries to use
1142:     if (!(state.getPath().getLeaf() instanceof ExpressionTree)) {
1145:     TreePath parent = state.getPath();
1149:       parent = parent.getParentPath();
1166:     private final TreePath parent;
1169:     private TargetTypeVisitor(ExpressionTree current, VisitorState state, TreePath parent) {
github.com/apache/ignite:modules/core/src/main/java/org/apache/ignite/internal/util/snaptree/SnapTreeMap.java: [ master, ] java
2047:         private Node<K,V>[] path;
2129:         private void path(Node<K,V> node) {
93:  *  the critical path.</em>
2059:             this.path = (Node<K,V>[]) new Node[1 + height(root)];
2100:             this.path = (Node<K,V>[]) new Node[1 + height(root)];
2124:                 path(node);
2130:         	if (depth == path.length)
2131:         		path = Arrays.copyOf(path, depth + 2);
2133:         	path[depth++] = node;
2144:                     path(node);
2157:             return path[depth - 1];
2165:                     path = null;
2176:                         popped = path[--depth];
2181:                     // clear out the path so we don't pin too much stuff
2182:                     path = null;
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/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/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/cloudstack:api/src/main/java/org/apache/cloudstack/api/ApiConstants.java: [ master, ] java
222:     public static final String PATH = "path";
634:     public static final String HEALTHCHECK_PINGPATH = "pingpath";
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/pdfbox:pdfbox/src/main/java/org/apache/pdfbox/cos/COSName.java: [ trunk, ] java
425:     public static final COSName PATH = new COSName("Path");
github.com/apache/hbase:hbase-server/src/main/java/org/apache/hadoop/hbase/io/hfile/HFileReaderImpl.java: [ master, ] java
117:   private final Path path;
1245:   public Path getPath() {
317:   private static String getPathOffsetEndStr(final Path path, final long offset, final long end) {
31: import org.apache.hadoop.fs.Path;
116:   /** Path of file */
163:   public HFileReaderImpl(Path path, FixedFileTrailer trailer, FSDataInputStreamWrapper fsdis,
166:     this(path, trailer, fsdis, fileSize, cacheConf, hfs, true, conf);
172:    * @param path
173:    *          Path to HFile.
188:   public HFileReaderImpl(Path path, FixedFileTrailer trailer, FSDataInputStreamWrapper fsdis,
195:     this.path = path;
196:     this.name = path.getName();
200:     this.hfileContext = createHFileContext(fsdis, fileSize, hfs, path, trailer);
201:     this.fsBlockReader = new HFileBlock.FSReaderImpl(fsdis, fileSize, hfs, path, hfileContext);
257:       PrefetchExecutor.request(path, new Runnable() {
265:               LOG.trace("Prefetch start " + getPathOffsetEndStr(path, offset, end));
291:               LOG.trace("Prefetch " + getPathOffsetEndStr(path, offset, end), e);
295:                 getPathOffsetEndStr(path, offset, end), e);
298:             LOG.warn("Prefetch " + getPathOffsetEndStr(path, offset, end), e);
300:             PrefetchExecutor.complete(path);
318:     return "path=" + path.toString() + ", offset=" + offset + ", end=" + end;
354:     return "reader=" + path.toString() +
906:     @edu.umd.cs.findbugs.annotations.SuppressWarnings(value="NP_NULL_ON_SOME_PATH",
929:         if (block != null && !block.getBlockType().isData()) { // Findbugs: NP_NULL_ON_SOME_PATH
1005:       // Okie to create new Pair. Not used in hot path
1246:     return path;
1571:     PrefetchExecutor.cancel(path);
1786:     return PrefetchExecutor.isCompleted(path);
1790:       HFileSystem hfs, Path path, FixedFileTrailer trailer) throws IOException {
1816:       LOG.trace("Reader" + (path != null? " for " + path: "") +
github.com/apache/curator:curator-recipes/src/main/java/org/apache/curator/framework/recipes/cache/TreeCache.java: [ master, ] java
81:         private final String path;
214:         final String path;
64:  * <p>A utility that attempts to keep all data from all children of a ZK path locally cached. This class
65:  * will watch the ZK path, respond to update/create/delete events, pull down the data, etc. You can
89:         private Builder(CuratorFramework client, String path)
92:             this.path = validatePath(path);
105:             return new TreeCache(client, path, cacheData, dataIsCompressed, maxDepth, executor, createParentNodes, selector);
156:          * By default, TreeCache does not auto-create parent nodes for the cached path. Change
182:      * Create a TreeCache builder for the given client and path to configure advanced options.
185:      * the namespace, including all published events.  The given path is the root at which the
186:      * TreeCache will watch and explore.  If no node exists at the given path, the TreeCache will
190:      * @param path   the path to the root node to watch/explore; this path need not actually exist on
194:     public static Builder newBuilder(CuratorFramework client, String path)
196:         return new Builder(client, path);
218:         TreeNode(String path, TreeNode parent)
220:             this.path = path;
227:             if ((depth < maxDepth) && selector.traverseChildren(path))
239:             if ((depth < maxDepth) && selector.traverseChildren(path))
256:                 client.getChildren().usingWatcher(this).inBackground(this).forPath(path);
266:                     client.getData().decompressed().usingWatcher(this).inBackground(this).forPath(path);
270:                     client.getData().usingWatcher(this).inBackground(this).forPath(path);
324:                 client.checkExists().usingWatcher(this).inBackground(this).forPath(path);
332:                     parentChildMap.remove(ZKPaths.getNodeFromPath(path), this);
413:                         if ( !childMap.containsKey(child) && selector.acceptChild(ZKPaths.makePath(path, child)) )
422:                         String fullPath = ZKPaths.makePath(path, child);
524:      * Create a TreeCache for the given client and path with default options.
527:      * the namespace, including all published events.  The given path is the root at which the
528:      * TreeCache will watch and explore.  If no node exists at the given path, the TreeCache will
532:      * @param path   the path to the root node to watch/explore; this path need not actually exist on
536:     public TreeCache(CuratorFramework client, String path)
538:         this(client, path, true, false, Integer.MAX_VALUE, Executors.newSingleThreadExecutor(defaultThreadFactory), false, ne...(30 bytes skipped)...
543:      * @param path             path to watch
545:      * @param dataIsCompressed if true, data in the path is compressed
550:     TreeCache(CuratorFramework client, String path, boolean cacheData, boolean dataIsCompressed, int maxDepth, final ExecutorService executorService, ...(54 bytes skipped)...
554:         this.root = new TreeNode(validatePath(path), null);
574:             client.createContainers(root.path);
632:         LinkedList<String> rootElements = new LinkedList<String>(ZKPaths.split(root.path));
636:                 // Target path shorter than root path
642:                 // Initial root path does not match
665:      * Return the current set of children at the given path, mapped by child name. There are no
667:      * node at this path, {@code null} is returned.
669:      * @param fullPath full path to the node to check
705:      * Return the current data for the given path. There are no guarantees of accuracy. This is
706:      * merely the most recent view of the data. If there is no node at the given path,
709:      * @param fullPath full path to the node to check
36: import org.apache.curator.utils.PathUtils;
61: import static org.apache.curator.utils.PathUtils.validatePath;
146:          * root node and its immediate children (kind of like {@link PathChildrenCache}.
391: ...(5 bytes skipped)...                   childDataUpdater.compareAndSet(this, oldChildData, new ChildData(oldChildData.getPath(), newStat, oldChildData.getData()));
423:                         TreeNode node = new TreeNode(fullPath, this);
438:                     String eventPath = event.getPath();
439:                     ChildData toPublish = new ChildData(eventPath, newStat, event.getData());
440:                     ChildData toUpdate = cacheData ? toPublish : new ChildData(eventPath, newStat, null);
629:     private TreeNode find(String findPath)
631:         PathUtils.validatePath(findPath);
633:         LinkedList<String> findElements = new LinkedList<String>(ZKPaths.split(findPath));
672:     public Map<String, ChildData> getCurrentChildren(String fullPath)
674:         TreeNode node = find(fullPath);
712:     public ChildData getCurrentData(String fullPath)
714:         TreeNode node = find(fullPath);
38: import org.apache.curator.utils.ZKPaths;
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/apache/jmeter:src/protocol/http/org/apache/jmeter/protocol/http/sampler/HTTPSamplerBase.java: [ trunk, ] java
154:     public static final String PATH = "HTTPSampler.path"; // $NON-NLS-1$
462:     public void setPath(String path) {
477:     public void setPath(String path, String contentEncoding) {
495:     public String getPath() {
365:      * i.e. there is a single file entry which has a non-empty path and
431:                 log.warn("File {} is invalid as no path is defined", httpFileArg);
456:      * Sets the Path attribute of the UrlConfig object Also calls parseArguments
459:      * @param path
460:      *            The new Path value
464:         setPath(path, EncoderCache.URL_ARGUMENT_ENCODING);
468:      * Sets the PATH property; if the request is a GET or DELETE (and the path
472:      * @param path
473:      *            The new Path value
478:         boolean fullUrl = path.startsWith(HTTP_PREFIX) || path.startsWith(HTTPS_PREFIX);
482:             int index = path.indexOf(QRY_PFX);
484:                 setProperty(PATH, path.substring(0, index));
486:                 parseArguments(path.substring(index + 1), contentEncoding);
488:                 setProperty(PATH, path);
491:             setProperty(PATH, path);
496:         String p = getPropertyAsString(PATH);
1001:      * As a special case, if the path starts with "http[s]://",
1002:      * then the path is assumed to be the entire URL.
1010:         String path = this.getPath();
1012:         if (path.startsWith(HTTP_PREFIX)
1013:                 || path.startsWith(HTTPS_PREFIX)) {
1014:             return new URL(path);
1023:             if (!path.startsWith("/")) { // $NON-NLS-1$
1027:         pathAndQuery.append(path);
1038:                 if (path.contains(QRY_PFX)) {// Already contains a prefix
1500:     protected String encodeSpaces(String path) {
1501:         return JOrphanUtils.replaceAllChars(path, ' ', "%20"); // $NON-NLS-1$
1935:      * Version 2.3.3 introduced a list of files, each with their own path, name and mimetype.
2096:      * Replace by replaceBy in path and body (arguments) properties
299:     /** Whether to remove '/pathsegment/..' from redirects; default true */
373:                 && (files[0].getPath().length() > 0)
430:             if(StringUtils.isEmpty(httpFileArg.getPath())) {
1009:         StringBuilder pathAndQuery = new StringBuilder(100);
1024:                 pathAndQuery.append('/'); // $NON-NLS-1$
1039:                     pathAndQuery.append(QRY_SEP);
1041:                     pathAndQuery.append(QRY_PFX);
1043:                 pathAndQuery.append(queryString);
1048:             return new URL(protocol, domain, pathAndQuery.toString());
1050:         return new URL(protocol, domain, getPort(), pathAndQuery.toString());
2115:         String value = getPath();
2122:                 setPath(replacedText);
github.com/apache/tinkerpop:gremlin-javascript/src/main/javascript/gremlin-javascript/lib/process/graph-traversal.js: [ master, ] javascript
810:   path(...args) {
1215:   path: (...args) => callOnEmptyTraversal('path', args),
80:   withPath(...args) {
370:   cyclicPath(...args) {
950:   simplePath(...args) {
1174:   cyclicPath: (...args) => callOnEmptyTraversal('cyclicPath', args),
1226:   simplePath: (...args) => callOnEmptyTraversal('simplePath', args),
806:    * Graph traversal path method.
811:     this.bytecode.addStep('path', args);
76:    * Graph Traversal Source withPath method.
81:     const b = new Bytecode(this.bytecode).addSource('withPath', args);
366:    * Graph traversal cyclicPath method.
371:     this.bytecode.addStep('cyclicPath', args);
946:    * Graph traversal simplePath method.
951:     this.bytecode.addStep('simplePath', args);
github.com/apache/tinkerpop:gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/dsl/graph/__.java: [ master, ] java
301:     public static <A> GraphTraversal<A, Path> path() {
821:     public static <A> GraphTraversal<A, A> simplePath() {
828:     public static <A> GraphTraversal<A, A> cyclicPath() {
22: import org.apache.tinkerpop.gremlin.process.traversal.Path;
299:      * @see GraphTraversal#path()
302:         return __.<A>start().path();
819:      * @see GraphTraversal#simplePath()
822:         return __.<A>start().simplePath();
826:      * @see GraphTraversal#cyclicPath()
829:         return __.<A>start().cyclicPath();
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/bundletool:src/main/java/com/android/tools/build/bundletool/utils/flags/Flag.java: [ master, ] java
97:   public static Flag<Path> path(String name) {
102:   public static Flag<ImmutableList<Path>> pathList(String name) {
336:   static class PathFlag extends SingleValueFlag<Path> {
338:     public PathFlag(String name) {
363:   static class ZipPathFlag extends SingleValueFlag<ZipPath> {
365:     public ZipPathFlag(String name) {
38: import java.nio.file.Path;
53:  * @param <T> the type that the flag should be parsed as (e.g. string, file path etc).
96:   /** Path flag holding a single value. */
101:   /** Path flag holding a list of comma-delimited values. */
343:     protected Path parse(String value) {
454:     } else if (clazz.equals(Path.class)) {
493:         Path passwordFile = Paths.get(flagValue.substring("file:".length()));
511:     private static String readPasswordFromFile(Path passwordFile) {
27: import com.android.tools.build.bundletool.model.ZipPath;
39: import java.nio.file.Paths;
98:     return new PathFlag(name);
103:     return new ListFlag<>(new PathFlag(name));
347:       return Paths.get(value);
370:     protected ZipPath parse(String value) {
371:       return ZipPath.create(value);
455:       return (SingleValueFlag<T>) new PathFlag(name);
458:     } else if (clazz.equals(ZipPath.class)) {
459:       return (SingleValueFlag<T>) new ZipPathFlag(name);
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
android.googlesource.com/platform/libcore:benchmarks/src/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;
chromium.googlesource.com/chromium/src/codesearch:third_party/android_tools/sdk/sources/android-25/benchmarks/regression/R.java: [ master, ] java Duplicate result
android.googlesource.com/platform/external/robolectric:v1/src/main/java/android/net/Uri__FromAndroid.java: [ master, ] java
534:         private PathPart path;
1086:         private final PathPart path;
1266:         private PathPart path;
1330:         Builder path(PathPart path) {
1346:         public Builder path(String path) {
252:     public abstract String getPath();
260:     public abstract String getEncodedPath();
542:         public String getPath() {
546:         public String getEncodedPath() {
554:         private String parsePath() {
685:         static String parsePath(String uriString, int ssi) {
835:         public String getPath() {
839:         public String getEncodedPath() {
915:     static class PathSegments extends AbstractList<String>
923:         PathSegments(String[] segments, int size) {
944:     static class PathSegmentsBuilder {
1183:         public String getEncodedPath() {
1187:         public String getPath() {
1357:         public Builder encodedPath(String path) {
1364:         public Builder appendPath(String newSegment) {
1371:         public Builder appendEncodedPath(String newSegment) {
2051:     static class PathPart extends AbstractPart {
2059:         private PathPart(String encoded, String decoded) {
2075:         private PathSegments pathSegments;
2245:     public static Uri__FromAndroid withAppendedPath(Uri__FromAndroid baseUri, String pathSegment) {
301:     public abstract List<String> getPathSegments();
308:     public abstract String getLastPathSegment();
536:         private PathPart getPathPart() {
550:         public List<String> getPathSegments() {
859:         public List<String> getPathSegments() {
863:         public String getLastPathSegment() {
980:         public String getLastPathSegment() {
1207:         public List<String> getPathSegments() {
2083:         PathSegments getPathSegments() {
90:        and a path component that begins with two slash characters.  The
96:     <scheme>://<authority><path>?<query>
247:      * Gets the decoded path.
249:      * @return the decoded path, or null if this is not a hierarchical URI
255:      * Gets the encoded path.
257:      * @return the encoded path, or null if this is not a hierarchical URI
297:      * Gets the decoded path segments.
299:      * @return decoded path segments, each without a leading or trailing '/'
304:      * Gets the decoded last segment in the path.
306:      * @return the decoded last segment or null if the path is empty
383:      * "file://<absolute path>". Encodes path characters with the exception of
396:         PathPart path = PathPart.fromDecoded(file.getAbsolutePath());
398:                 "file", Part.EMPTY, path, Part.NULL, Part.NULL);
537:             return path == null
538:                     ? path = PathPart.fromEncoded(parsePath())
539:                     : path;
657:                 // Look for the start of the path, query, or fragment, or the
662:                         case '/': // Start of path
678:          * Parses a path out of this given URI string.
683:          * @return the path
688:             // Find start of path.
693:                 // Skip over authority to path.
699:                             return ""; // Empty path.
700:                         case '/': // Start of path!
706:                 // Path starts immediately after scheme separator.
710:             // Find end of path.
729:                         .path(getPathPart())
913:      * Wrapper for path segment array.
1090:         private HierarchicalUri(String scheme, Part authority, PathPart path,
1094:             this.path = path == null ? PathPart.NULL : path;
1117:             path.writeTo(parcel);
1165:             String encodedPath = path.getEncoded();
1184:             return this.path.getEncoded();
1188:             return this.path.getDecoded();
1208:             return this.path.getPathSegments();
1241:                     .path(path)
1252:      * {@code &lt;scheme&gt;://&lt;authority&gt;&lt;absolute path&gt;?&lt;query&gt;#&lt;fragment&gt;}
1255:      * of two patterns: {@code &lt;relative or absolute path&gt;?&lt;query&gt;#&lt;fragment&gt;}
1256:      * or {@code //&lt;authority&gt;&lt;absolute path&gt;?&lt;query&gt;#&lt;fragment&gt;}
1334:             this.path = path;
1339:          * Sets the path. Leaves '/' characters intact but encodes others as
1342:          * <p>If the path is not null and doesn't start with a '/', and if
1344:          * given path with a '/'.
1347:             return path(PathPart.fromDecoded(path));
1351:          * Sets the previously encoded path.
1353:          * <p>If the path is not null and doesn't start with a '/', and if
1355:          * given path with a '/'.
1358:             return path(PathPart.fromEncoded(path));
1362:          * Encodes the given segment and appends it to the path.
1365:             return path(PathPart.appendDecodedSegment(path, newSegment));
1369:          * Appends the given segment to the path.
1372:             return path(PathPart.appendEncodedSegment(path, newSegment));
1461:                 PathPart path = this.path;
1462:                 if (path == null || path == PathPart.NULL) {
1463:                     path = PathPart.EMPTY;
1465:                     // If we have a scheme and/or authority, the path must
1468:                         path = PathPart.makeAbsolute(path);
1473:                         scheme, authority, path, query, fragment);
2048:      * Immutable wrapper of encoded and decoded versions of a path part. Lazily
2072:          * Cached path segments. This doesn't need to be volatile--we don't
2078:          * Gets the individual path segments. Parses them if necessary.
2080:          * @return parsed path segments or null if this isn't a hierarchical
2088:             String path = getEncoded();
2089:             if (path == null) {
2097:             while ((current = path.indexOf('/', previous)) > -1) {
2098:                 // This check keeps us from adding a segment if the path starts
2102:                             = decode(path.substring(previous, current));
2108:             // Add in the final path segment.
2109:             if (previous < path.length()) {
2110:                 segmentBuilder.add(decode(path.substring(previous)));
2118:             // If there is no old path, should we make the new path relative
2122:                 // No old path.
2135:                 // No old path.
2168:          * Creates a path from the encoded string.
2177:          * Creates a path from the decoded string.
2186:          * Creates a path from the encoded and decoded strings.
2204:          * Prepends path values with "/" if they're present, not empty, and
2236:      * Creates a new Uri by appending an already-encoded path segment to a
2239:      * @param baseUri Uri to append path segment to
2240:      * @param pathSegment encoded path segment to append
2242:      *  the path
119:             PathPart.EMPTY, Part.NULL, Part.NULL);
313:      * equal. Case counts. Paths are not normalized. If one Uri specifies a
576:             return parsePath(uriString, ssi);
689:             int pathStart;
694:                 pathStart = ssi + 3;
695:                 LOOP: while (pathStart < length) {
696:                     switch (uriString.charAt(pathStart)) {
703:                     pathStart++;
707:                 pathStart = ssi + 1;
711:             int pathEnd = pathStart;
712:             LOOP: while (pathEnd < length) {
713:                 switch (uriString.charAt(pathEnd)) {
718:                 pathEnd++;
721:             return uriString.substring(pathStart, pathEnd);
918:         static final PathSegments EMPTY = new PathSegments(null, 0);
942:      * Builds PathSegments.
961:         PathSegments build() {
963:                 return PathSegments.EMPTY;
967:                 return new PathSegments(segments, size);
1103:                 PathPart.readFrom(parcel),
1166:             if (encodedPath != null) {
1167:                 builder.append(encodedPath);
1460:                 // Hierarchical URIs should not return null for getPath().
2054:         static final PathPart NULL = new PathPart(null, null);
2057:         static final PathPart EMPTY = new PathPart("", "");
2084:             if (pathSegments != null) {
2085:                 return pathSegments;
2090:                 return pathSegments = PathSegments.EMPTY;
2093:             PathSegmentsBuilder segmentBuilder = new PathSegmentsBuilder();
2113:             return pathSegments = segmentBuilder.build();
2116:         static PathPart appendEncodedSegment(PathPart oldPart,
2126:             String oldPath = oldPart.getEncoded();
2128:             if (oldPath == null) {
2129:                 oldPath = "";
2132:             int oldPathLength = oldPath.length();
2133:             String newPath;
2136:                 newPath = "/" + newSegment;
2137:             } else if (oldPath.charAt(oldPathLength - 1) == '/') {
2138:                 newPath = oldPath + newSegment;
2140:                 newPath = oldPath + "/" + newSegment;
2143:             return fromEncoded(newPath);
2146:         static PathPart appendDecodedSegment(PathPart oldPart, String decoded) {
2149:             // TODO: Should we reuse old PathSegments? Probably not.
2153:         static PathPart readFrom(Parcel parcel) {
2172:         static PathPart fromEncoded(String encoded) {
2181:         static PathPart fromDecoded(String decoded) {
2191:         static PathPart from(String encoded, String decoded) {
2200:             return new PathPart(encoded, decoded);
2207:         static PathPart makeAbsolute(PathPart oldPart) {
2213:             String oldPath = encodedCached ? oldPart.encoded : oldPart.decoded;
2215:             if (oldPath == null || oldPath.length() == 0
2216:                     || oldPath.startsWith("/")) {
2231:             return new PathPart(newEncoded, newDecoded);
2247:         builder = builder.appendEncodedPath(pathSegment);
543:             return getPathPart().getDecoded();
547:             return getPathPart().getEncoded();
551:             return getPathPart().getPathSegments();
984:             List<String> segments = getPathSegments();
2134:             if (oldPathLength == 0) {
chromium.googlesource.com/android_tools:sdk/sources/android-25/benchmarks/regression/R.java: [ master, ] java Duplicate result
chromium.googlesource.com/chromium/codesearch:src:codesearch-gitlink-overlay/third_party/android_tools/sdk/sources/android-25/benchmarks/regression/R.java: [ master, ] java Duplicate result
android.googlesource.com/platform/superproject:libcore/benchmarks/src/benchmarks/regression/R.java: [ master, ] java Duplicate result
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/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);
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/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};
android.googlesource.com/platform/superproject:external/cldr/tools/java/org/unicode/cldr/icu/LDMLConstants.java: [ master, ] java Duplicate result
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,
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();
gerrit.googlesource.com/gerrit:java/com/google/gerrit/server/query/change/ChangeQueryBuilder.java: [ master, ] java
711:   public Predicate<ChangeData> path(String path) {
160:   public static final String FIELD_PATH = "path";
712:     if (path.startsWith("^")) {
713:       return new RegexPathPredicate(path);
715:     return new EqualsPathPredicate(FIELD_PATH, path);
705:       return new RegexPathPredicate(file);
android.googlesource.com/platform/superproject:external/turbine/java/com/google/turbine/bytecode/ClassFile.java: [ master, ] java
498:     private final TypePath path;
530:     public TypePath path() {
685:     public static class TypePath {
730:       private TypePath(Kind kind, TypePath parent) {
735:       private TypePath(int index, Kind kind, TypePath parent) {
502:         TargetType targetType, Target target, TypePath path, AnnotationInfo anno) {
505:       this.path = path;
528:      * A JVMS 4.7.20 type_path structure, denotes which part of the type the annotation applies to.
531:       return path;
680:      * A JVMS 4.7.20.2 type_path.
687:       /** The root type_path_kind, used for initialization. */
692:       /** Adds an array type_path_kind entry. */
697:       /** Adds a nested type type_path_kind entry. */
702:       /** Adds a wildcard bound type_path_kind entry. */
707:       /** Adds a type argument type_path_kind entry. */
712:       /** A type_path_kind. */
746:       /** The JVMS 4.7.20.2-A serialized value of the type_path_kind. */
751:       /** Returns a flattened view of the type path. */
688:       public static TypePath root() {
689:         return new TypePath(null, null);
693:       public TypePath array() {
694:         return new TypePath(Kind.ARRAY, this);
698:       public TypePath nested() {
699:         return new TypePath(Kind.NESTED, this);
703:       public TypePath wild() {
704:         return new TypePath(Kind.WILDCARD_BOUND, this);
708:       public TypePath typeArgument(int idx) {
709:         return new TypePath(idx, Kind.TYPE_ARGUMENT, this);
726:       private final TypePath parent;
752:       public ImmutableList<TypePath> flatten() {
753:         Deque<TypePath> flat = new ArrayDeque<>();
754:         for (TypePath curr = this; curr.kind != null; curr = curr.parent) {
gwt.googlesource.com/gwt-site:src/main/java/com/google/gwt/site/markdown/fs/MDNode.java: [ master, ] java
19:   private final String path;
23:   private final String relativePath;
46:   public String getPath() {
67:   public String getRelativePath() {
29:   public MDNode(MDParent parent, String name, String path, int depth, String relativePath) {
32:     this.path = path;
47:     return path;
34:     this.relativePath = relativePath;
68:     return relativePath;
github.com/apache/isis:core/viewer-restfulobjects-applib/src/main/java/org/apache/isis/viewer/restfulobjects/applib/JsonRepresentation.java: [ master, ] java
1556: 	private static class Path {
1560: 		private Path(final List<String> head, final String tail) {
193: 	public boolean isArray(final String path) {
194: 		return isArray(getNode(path));
205: 	public JsonRepresentation getArray(final String path) {
206: 		return getArray(path, getNode(path));
213: 	private JsonRepresentation getArray(final String path, final JsonNode node) {
219: 			throw new IllegalArgumentException(formatExMsg(path, "is not an array"));
224: 	public JsonRepresentation getArrayEnsured(final String path) {
225: 		return getArrayEnsured(path, getNode(path));
228: 	private JsonRepresentation getArrayEnsured(final String path, final JsonNode node) {
239: 	public boolean isMap(final String path) {
240: 		return isMap(getNode(path));
251: 	public JsonRepresentation getMap(final String path) {
252: 		return getMap(path, getNode(path));
259: 	private JsonRepresentation getMap(final String path, final JsonNode node) {
264: 			throw new IllegalArgumentException(formatExMsg(path, "is not a map"));
273: 	public boolean isNumber(final String path) {
274: 		return isNumber(getNode(path));
289: 	private Number getNumber(final String path, final JsonNode node) {
293: 		checkValue(path, node, "a number");
295: 			throw new IllegalArgumentException(formatExMsg(path, "is not a number"));
308: 	public boolean isIntegralNumber(final String path) {
309: 		return isIntegralNumber(getNode(path));
330: 	public java.util.Date getDate(final String path) {
331: 		return getDate(path, getNode(path));
338: 	private java.util.Date getDate(final String path, final JsonNode node) {
342: 		checkValue(path, node, "a date");
344: 			throw new IllegalArgumentException(formatExMsg(path, "is not a date"));
356: 	public java.util.Date getDateTime(final String path) {
357: 		return getDateTime(path, getNode(path));
364: 	private java.util.Date getDateTime(final String path, final JsonNode node) {
368: 		checkValue(path, node, "a date-time");
370: 			throw new IllegalArgumentException(formatExMsg(path, "is not a date-time"));
382: 	public java.util.Date getTime(final String path) {
383: 		return getTime(path, getNode(path));
390: 	private java.util.Date getTime(final String path, final JsonNode node) {
394: 		checkValue(path, node, "a time");
396: 			throw new IllegalArgumentException(formatExMsg(path, "is not a time"));
407: 	public boolean isBoolean(final String path) {
408: 		return isBoolean(getNode(path));
422: 	public Boolean getBoolean(final String path) {
423: 		return getBoolean(path, getNode(path));
433: 	private Boolean getBoolean(final String path, final JsonNode node) {
437: 		checkValue(path, node, "a boolean");
439: 			throw new IllegalArgumentException(formatExMsg(path, "is not a boolean"));
451: 	public Byte getByte(final String path) {
452: 		final JsonNode node = getNode(path);
453: 		return getByte(path, node);
463: 	private Byte getByte(final String path, final JsonNode node) {
467: 		checkValue(path, node, "an byte");
470: 			throw new IllegalArgumentException(formatExMsg(path, "is not a number"));
482: 	public Short getShort(final String path) {
483: 		final JsonNode node = getNode(path);
484: 		return getShort(path, node);
494: 	private Short getShort(final String path, final JsonNode node) {
498: 		checkValue(path, node, "an short");
501: 			throw new IllegalArgumentException(formatExMsg(path, "is not a number"));
514: 	public Character getChar(final String path) {
515: 		final JsonNode node = getNode(path);
516: 		return getChar(path, node);
526: 	private Character getChar(final String path, final JsonNode node) {
530: 		checkValue(path, node, "an short");
532: 			throw new IllegalArgumentException(formatExMsg(path, "is not textual"));
546: 	public boolean isInt(final String path) {
547: 		return isInt(getNode(path));
561: 	public Integer getInt(final String path) {
562: 		final JsonNode node = getNode(path);
563: 		return getInt(path, node);
573: 	private Integer getInt(final String path, final JsonNode node) {
577: 		checkValue(path, node, "an int");
579: 			throw new IllegalArgumentException(formatExMsg(path, "is not an int"));
589: 	public boolean isLong(final String path) {
590: 		return isLong(getNode(path));
604: 	public Long getLong(final String path) {
605: 		final JsonNode node = getNode(path);
606: 		return getLong(path, node);
616: 	private Long getLong(final String path, final JsonNode node) {
620: 		checkValue(path, node, "a long");
627: 		throw new IllegalArgumentException(formatExMsg(path, "is not a long"));
637: 	public Float getFloat(final String path) {
638: 		final JsonNode node = getNode(path);
639: 		return getFloat(path, node);
649: 	private Float getFloat(final String path, final JsonNode node) {
653: 		checkValue(path, node, "a float");
655: 			throw new IllegalArgumentException(formatExMsg(path, "is not a number"));
665: 	public boolean isDecimal(final String path) {
666: 		return isDecimal(getNode(path));
677: 	public boolean isDouble(final String path) {
678: 		return isDecimal(path);
696: 	public Double getDouble(final String path) {
697: 		final JsonNode node = getNode(path);
698: 		return getDouble(path, node);
708: 	private Double getDouble(final String path, final JsonNode node) {
712: 		checkValue(path, node, "a double");
714: 			throw new IllegalArgumentException(formatExMsg(path, "is not a double"));
723: 	public boolean isBigInteger(final String path) {
724: 		return isBigInteger(getNode(path));
747: 	public BigInteger getBigInteger(final String path) {
748: 		return getBigInteger(path, (String)null);
754: 	public BigInteger getBigInteger(final String path, final String formatRequested) {
758: 			node = getNode(path);
761: 			final NodeAndFormat nodeAndFormat = getNodeAndFormat(path);
765: 		return getBigInteger(path, format, node);
779: 	private BigInteger getBigInteger(final String path, final String format, final JsonNode node) {
785: 			throw new IllegalArgumentException(formatExMsg(path, "is not " + requiredType));
787: 		checkValue(path, node, requiredType);
788: 		final BigInteger bigInteger = getBigInteger(path, node);
802: 	private BigInteger getBigInteger(String path, JsonNode node) {
815: 		throw new IllegalArgumentException(formatExMsg(path, "is not a biginteger, is not any other integral number, is not text parseable as a biginteger"));
822: 	public boolean isBigDecimal(final String path) {
823: 		return isBigDecimal(getNode(path));
846: 	public BigDecimal getBigDecimal(final String path) {
847: 		return getBigDecimal(path, (String)null);
853: 	public BigDecimal getBigDecimal(final String path, final String formatRequested) {
857: 			node = getNode(path);
860: 			final NodeAndFormat nodeAndFormat = getNodeAndFormat(path);
864: 		return getBigDecimal(path, format, node);
881: 	private BigDecimal getBigDecimal(final String path, final String format, final JsonNode node) {
887: 			throw new IllegalArgumentException(formatExMsg(path, "is not " + requiredType));
889: 		checkValue(path, node, requiredType);
890: 		final BigDecimal bigDecimal = getBigDecimal(path, node);
906: 	private BigDecimal getBigDecimal(String path, JsonNode node) {
926: 		throw new IllegalArgumentException(formatExMsg(path, "is not a bigdecimal, is not any other numeric, is not text parseable as a bigdecimal"));
934: 	public boolean isString(final String path) {
935: 		return isString(getNode(path));
949: 	public String getString(final String path) {
950: 		final JsonNode node = getNode(path);
951: 		return getString(path, node);
961: 	private String getString(final String path, final JsonNode node) {
965: 		checkValue(path, node, "a string");
967: 			throw new IllegalArgumentException(formatExMsg(path, "is not a string"));
988: 	public boolean isLink(final String path) {
989: 		return isLink(getNode(path));
1007: 	public LinkRepresentation getLink(final String path) {
1008: 		return getLink(path, getNode(path));
1018: 	private LinkRepresentation getLink(final String path, final JsonNode node) {
1024: 			throw new IllegalArgumentException(formatExMsg(path, "is an array that does not represent a link"));
1027: 			throw new IllegalArgumentException(formatExMsg(path, "is a value that does not represent a link"));
1032: 			throw new IllegalArgumentException(formatExMsg(path, "is a map that does not fully represent a link"));
1048: 	 * was no node with the provided path.
1050: 	public Boolean isNull(final String path) {
1051: 		return isNull(getNode(path));
1066: 	 * was no node with the provided path.
1071: 	public JsonRepresentation getNull(final String path) {
1072: 		return getNull(path, getNode(path));
1079: 	 * was no node with the provided path.
1088: 	private JsonRepresentation getNull(final String path, final JsonNode node) {
1093: 		checkValue(path, node, "the null value");
1095: 			throw new IllegalArgumentException(formatExMsg(path, "is not the null value"));
1341: 			final String path = paths[i];
1342: 			final boolean has = node.has(path);
1348: 				final JsonNode subNode = node.get(path);
1377: 		final Path path = Path.parse(key);
1378: 		final ObjectNode node = JsonNodeUtils.walkNodeUpTo(asObjectNode(), path.getHead());
1379: 		node.put(path.getTail(), value != null ? new POJONode(value) : NullNode.getInstance());
1390: 		final Path path = Path.parse(key);
1391: 		final ObjectNode node = JsonNodeUtils.walkNodeUpTo(asObjectNode(), path.getHead());
1392: 		node.put(path.getTail(), value.asJsonNode());
1403: 		final Path path = Path.parse(key);
1404: 		final ObjectNode node = JsonNodeUtils.walkNodeUpTo(asObjectNode(), path.getHead());
1405: 		node.put(path.getTail(), value);
1416: 		final Path path = Path.parse(key);
1417: 		final ObjectNode node = JsonNodeUtils.walkNodeUpTo(asObjectNode(), path.getHead());
1418: 		node.put(path.getTail(), value);
1442: 		final Path path = Path.parse(key);
1443: 		final ObjectNode node = JsonNodeUtils.walkNodeUpTo(asObjectNode(), path.getHead());
1444: 		node.put(path.getTail(), value);
1456: 		final Path path = Path.parse(key);
1457: 		final ObjectNode node = JsonNodeUtils.walkNodeUpTo(asObjectNode(), path.getHead());
1458: 		node.put(path.getTail(), value);
1470: 		final Path path = Path.parse(key);
1471: 		final ObjectNode node = JsonNodeUtils.walkNodeUpTo(asObjectNode(), path.getHead());
1472: 		node.put(path.getTail(), value);
1484: 		final Path path = Path.parse(key);
1485: 		final ObjectNode node = JsonNodeUtils.walkNodeUpTo(asObjectNode(), path.getHead());
1486: 		node.put(path.getTail(), value);
1498: 		final Path path = Path.parse(key);
1499: 		final ObjectNode node = JsonNodeUtils.walkNodeUpTo(asObjectNode(), path.getHead());
1500: 		node.put(path.getTail(), value);
1520: 		final Path path = Path.parse(key);
1521: 		final ObjectNode node = JsonNodeUtils.walkNodeUpTo(asObjectNode(), path.getHead());
1523: 			node.put(path.getTail(), value.toString());
1525: 			node.put(path.getTail(), NullNode.getInstance());
1546: 		final Path path = Path.parse(key);
1547: 		final ObjectNode node = JsonNodeUtils.walkNodeUpTo(asObjectNode(), path.getHead());
1549: 			node.put(path.getTail(), value.toString());
1551: 			node.put(path.getTail(), NullNode.getInstance());
1573: 		public static Path parse(final String pathStr) {
1576: 				throw new IllegalArgumentException(String.format("Malformed path '%s'", pathStr));
1579: 			return new Path(keyList, tail);
1659: 	private JsonNode getNode(final String path) {
1660: 		return getNodeAndFormat(path).node;
1673: 	 * Walks the path to the specified node, and also returns the value of 'format' in the parent node if present.
1675: 	private NodeAndFormat getNodeAndFormat(final String path) {
1677: 		final List<String> keys = PathNode.split(path);
1682: 				// grab format (if present) before moving down the path
1684: 				jsonNode = jsonNode.path(pathNode.getKey());
1697: 			// grab format (if present) before moving down the path
1736: 	private static void checkValue(final String path, final JsonNode node, final String requiredType) {
1740: 		throw new IllegalArgumentException(formatExMsg(path, "is not " + requiredType));
43: import org.apache.isis.viewer.restfulobjects.applib.util.PathNode;
177: 	public JsonRepresentation getRepresentation(final String pathTemplate, final Object... args) {
178: 		final String pathStr = String.format(pathTemplate, args);
180: 		final JsonNode node = getNode(pathStr);
1339: 		final String[] paths = key.split("\\.");
1340: 		for (int i = 0; i < paths.length; i++) {
1346: 			if (i + 1 < paths.length) {
1574: 			final List<String> keyList = new ArrayList<>(Arrays.asList(pathStr.split("\\.")));
1680: 			final PathNode pathNode = PathNode.parse(key);
1681: 			if (!pathNode.getKey().isEmpty()) {
1686: 				// pathNode is criteria only; don't change jsonNode
1691: 			if (!pathNode.hasCriteria()) {
1699: 			jsonNode = matching(jsonNode, pathNode);
1714: 	private JsonNode matching(final JsonNode jsonNode, final PathNode pathNode) {
1718: 				.filter(input->pathNode.matches(new JsonRepresentation(input)))
1747: 	private static String formatExMsg(final String pathIfAny, final String errorText) {
1749: 		if (pathIfAny != null) {
1750: 			buf.append("'").append(pathIfAny).append("' ");
github.com/apache/apex-core:engine/src/main/java/com/datatorrent/stram/plan/logical/LogicalPlanConfiguration.java: [ master, ] java
166:     ATTR("attr"), PROP("prop"), CLASS("class"), PATH("path"), UNIFIER("unifier");
471:     public static List<StramElement> getPathFromChildToRootInclusive(StramElement conf)
496:     public static List<StramElement> getPathFromRootToChildInclusive(StramElement conf)
511:     public static List<StramElement> getPathFromChildToParentInclusive(StramElement child, StramElement parent)
550:     public static List<StramElement> getPathFromParentToChildInclusive(StramElement child, StramElement parent)
464:      * Creates a list of {@link StramElement}s which represent the path from the current {@link Conf} type to
465:      * a root {@link Conf} type. This path includes the current {@link Conf} type as well as the root.
468:      * @return A path from the current {@link Conf} type to a root {@link Conf} type, which includes the current and root...(0 bytes skipped)...
479:       List<StramElement> path = Lists.newArrayList();
482:         path.add(confElement.getStramElement());
485:       return path;
489:      * Creates a list of {@link StramElement}s which represent the path from the root {@link Conf} type to
490:      * the current {@link Conf} type. This path includes the root {@link Conf} type as well as the current {@link Conf} type.
493:      * @return A path from the root {@link Conf} type to the current {@link Conf} type, which includes the current and ro...(2 bytes skipped)...
498:       List<StramElement> path = getPathFromChildToRootInclusive(conf);
499:       return Lists.reverse(path);
503:      * Creates a list of {@link StramElement}s which represent the path from the current {@link Conf} type to
504:      * a parent {@link Conf} type. This path includes the current {@link Conf} type as well as the parent.
508:      * @return A path from the current {@link Conf} type to a parent {@link Conf} type, which includes the current and pa...(4 bytes skipped)...
519:       List<StramElement> path = Lists.newArrayList();
522:         path.add(child);
523:         return path;
527:         path.add(confElement.getStramElement());
534:       if (path.get(path.size() - 1) != parent) {
538:       return path;
542:      * Creates a list of {@link StramElement}s which represent the path from the parent {@link Conf} type to
543:      * a child {@link Conf} type. This path includes the parent {@link Conf} type as well as the current {@link Conf} type.
547:      * @return A path from the parent {@link Conf} type to the current {@link Conf} type, which includes the current and ...(6 bytes skipped)...
552:       List<StramElement> path = getPathFromChildToParentInclusive(child, parent);
553:       return Lists.reverse(path);
585:       List<StramElement> path = ConfElement.getPathFromParentToChildInclusive(childConfElement.getStramElement(), parentConf.getConfElement().getStramE...(10 bytes skipped)...
587:       for (int pathIndex = 1; pathIndex < path.size(); pathIndex++) {
589:         StramElement pathElement = path.get(pathIndex);
1227:         StramElement.CLASS, StramElement.PATH, StramElement.PROP, StramElement.UNIFIER};
1237:       if ((element == StramElement.CLASS) || (element == StramElement.PATH)) {
1690:    * The path for the application class is specified as a parameter. If an alias was specified
1694:    * @param appPath The path of the application class in the jar
2250:    * @param name The path of the application class in the jar.
591:         parentConf = addConf(pathElement, WILDCARD, parentConf);
1697:   public String getAppAlias(String appPath)
1700:     if (appPath.endsWith(CLASS_SUFFIX)) {
1701:       appPath = appPath.replace("/", KEY_SEPARATOR).substring(0, appPath.length() - CLASS_SUFFIX.length());
1703:     appAlias = stramConf.appAliases.get(appPath);
1706:         ApplicationAnnotation an = Thread.currentThread().getContextClassLoader().loadClass(appPath).getAnnotation(ApplicationAnnotation.class);
2309:   public static Properties readProperties(String filePath) throws IOException
2311:     InputStream is = new FileInputStream(filePath);
android.googlesource.com/platform/external/turbine:java/com/google/turbine/bytecode/ClassFile.java: [ master, ] java Duplicate result