Found 110050 results in 11202 files, showing top 50 files (show more).
github.com/bazelbuild/rules_closure:java/io/bazel/rules/closure/Webpath.java: [ master, ]
72:   private final String path;
55:   private static final Webpath EMPTY_PATH = new Webpath("");
56:   private static final Webpath ROOT_PATH = new Webpath(ROOT);
49: public final class Webpath implements CharSequence, Comparable<Webpath> {
76:   private Webpath(String path) {
170:   public Webpath subpath(int beginIndex, int endIndex) {
393:   public Webpath toAbsolutePath(Webpath currentWorkingDirectory) {
399:   public Webpath toAbsolutePath() {
34:  * Web server path.
36:  * <p>This class is a de facto implementation of the {@link java.nio.file.Path} API. That interface
62:   /** Returns new path of {@code first}. */
63:   public static Webpath get(String path) {
64:     if (path.isEmpty()) {
65:       return EMPTY_PATH;
66:     } else if (isRootInternal(path)) {
67:       return ROOT_PATH;
69:     return new Webpath(path);
77:     this.path = checkNotNull(path);
82:     return isRootInternal(path);
85:   private static boolean isRootInternal(String path) {
86:     return path.length() == 1 && path.charAt(0) == SEPARATOR;
89:   /** Returns {@code true} if path starts with {@code separator}. */
91:     return isAbsoluteInternal(path);
94:   private static boolean isAbsoluteInternal(String path) {
95:     return !path.isEmpty() && path.charAt(0) == SEPARATOR;
98:   /** Returns {@code true} if path ends with {@code separator}. */
100:     return hasTrailingSeparatorInternal(path);
103:   private static boolean hasTrailingSeparatorInternal(CharSequence path) {
104:     return path.length() != 0 && path.charAt(path.length() - 1) == SEPARATOR;
107:   /** Returns {@code true} if path ends with a trailing slash, or would after normalization. */
109:     int length = path.length();
110:     return path.isEmpty()
111:         || path.charAt(length - 1) == SEPARATOR
112:         || (path.endsWith(".") && (length == 1 || path.charAt(length - 2) == SEPARATOR))
113:         || (path.endsWith("..") && (length == 2 || path.charAt(length - 3) == SEPARATOR));
117:    * Returns last component in {@code path}.
119:    * @see java.nio.file.Path#getFileName()
123:     if (path.isEmpty()) {
124:       return EMPTY_PATH;
130:       return parts.size() == 1 && path.equals(last) ? this : new Webpath(last);
137:    * @see java.nio.file.Path#getParent()
141:     if (path.isEmpty() || isRoot()) {
146:             ? path.lastIndexOf(SEPARATOR, path.length() - 2)
147:             : path.lastIndexOf(SEPARATOR);
149:       return isAbsolute() ? ROOT_PATH : null;
151:       return new Webpath(path.substring(0, index + 1));
156:    * Returns root component if an absolute path, otherwise {@code null}.
158:    * @see java.nio.file.Path#getRoot()
162:     return isAbsolute() ? ROOT_PATH : null;
166:    * Returns specified range of sub-components in path joined together.
168:    * @see java.nio.file.Path#subpath(int, int)
171:     if (path.isEmpty() && beginIndex == 0 && endIndex == 1) {
185:    * Returns number of components in {@code path}.
187:    * @see java.nio.file.Path#getNameCount()
190:     if (path.isEmpty()) {
200:    * Returns component in {@code path} at {@code index}.
202:    * @see java.nio.file.Path#getName(int)
205:     if (path.isEmpty()) {
217:    * Returns path without extra separators or {@code .} and {@code ..}, preserving trailing slash.
219:    * @see java.nio.file.Path#normalize()
228:       index = path.indexOf(SEPARATOR, mark);
229:       String part = path.substring(mark, index == -1 ? path.length() : index + 1);
280:    * Returns {@code other} appended to {@code path}.
282:    * @see java.nio.file.Path#resolve(java.nio.file.Path)
285:     if (other.path.isEmpty()) {
290:       return new Webpath(path + other.path);
292:       return new Webpath(path + SEPARATOR + other.path);
297:    * Returns {@code other} resolved against parent of {@code path}.
299:    * @see java.nio.file.Path#resolveSibling(java.nio.file.Path)
307:   /** Returns absolute path of {@code reference} relative to {@code file}. */
313:    * Returns {@code other} made relative to {@code path}.
315:    * @see java.nio.file.Path#relativize(java.nio.file.Path)
318:     checkArgument(isAbsolute() == other.isAbsolute(), "'other' is different type of Path");
319:     if (path.isEmpty()) {
331:     StringBuilder result = new StringBuilder(path.length() + other.path.length());
348:    * Returns {@code true} if {@code path} starts with {@code other}.
350:    * @see java.nio.file.Path#startsWith(java.nio.file.Path)
355:     if (other.path.length() > me.path.length()) {
359:     } else if (!me.path.isEmpty() && other.path.isEmpty()) {
375:    * Returns {@code true} if {@code path} ends with {@code other}.
377:    * @see java.nio.file.Path#endsWith(java.nio.file.Path)
382:     if (other.path.length() > me.path.length()) {
384:     } else if (!me.path.isEmpty() && other.path.isEmpty()) {
387:       return me.isAbsolute() && me.path.equals(other.path);
392:   /** Converts relative path to an absolute path. */
398:   /** Returns {@code toAbsolutePath(ROOT_PATH)}. */
400:     return toAbsolutePath(ROOT_PATH);
403:   /** Removes beginning separator from path, if an absolute path. */
405:     return isAbsolute() ? new Webpath(path.substring(1)) : this;
408:   /** Adds trailing separator to path, if it isn't present. */
410:     return hasTrailingSeparator() ? this : new Webpath(path + SEPARATOR);
413:   /** Removes trailing separator from path, unless it's root. */
416:       return new Webpath(path.substring(0, path.length() - 1));
422:   /** Splits path into components, excluding separators and empty strings. */
427:   /** Splits path into components in reverse, excluding separators and empty strings. */
435:    * @see java.nio.file.Path#compareTo(java.nio.file.Path)
481:     String path2 = ((Webpath) other).path;
485:       if (i == path.length()) {
486:         return i2 == path2.length();
488:       if (i2 == path2.length()) {
491:       char c = path.charAt(i++);
493:         while (i < path.length() && path.charAt(i) == SEPARATOR) {
497:       char c2 = path2.charAt(i2++);
502:         while (i2 < path2.length() && path2.charAt(i2) == SEPARATOR) {
515:       for (int i = 0; i < path.length(); i++) {
516:         char c = path.charAt(i);
527:   /** Returns path as a string. */
530:     return path;
535:     return path.length();
540:     return path.charAt(index);
545:     return path.subSequence(start, end);
548:   /** Returns {@code true} if this path is an empty string. */
550:     return path.isEmpty();
553:   /** Returns list of path components, excluding slashes. */
559:             path.isEmpty() || isRoot()
561:                 : SPLITTER.splitToList(path));
37:  * is not formally implemented because it would not be desirable to have web paths accidentally
38:  * intermingle with file system paths.
40:  * <p>This implementation is almost identical to {@code sun.nio.fs.UnixPath}. The main difference is
122:   public Webpath getFileName() {
140:   public Webpath getParent() {
161:   public Webpath getRoot() {
181:     return new Webpath(JOINER.join(subList));
204:   public Webpath getName(int index) {
210:       return new Webpath(getParts().get(index));
221:   public Webpath normalize() {
276:     return new Webpath(result.toString());
284:   public Webpath resolve(Webpath other) {
301:   public Webpath resolveSibling(Webpath other) {
303:     Webpath parent = getParent();
308:   public Webpath lookup(Webpath reference) {
317:   public Webpath relativize(Webpath other) {
344:     return new Webpath(result.toString());
352:   public boolean startsWith(Webpath other) {
353:     Webpath me = removeTrailingSeparator();
379:   public boolean endsWith(Webpath other) {
380:     Webpath me = removeTrailingSeparator();
404:   public Webpath removeBeginningSeparator() {
409:   public Webpath addTrailingSeparator() {
414:   public Webpath removeTrailingSeparator() {
433:    * Compares two paths lexicographically for ordering.
438:   public int compareTo(Webpath other) {
478:     if (!(other instanceof Webpath) || hashCode() != other.hashCode()) {
github.com/bazelbuild/eclipse:java/com/google/devtools/bazel/e4b/classpath/BazelClasspathContainer.java: [ master, ]
48:   private final IPath path;
15: package com.google.devtools.bazel.e4b.classpath;
60:   private boolean isSourcePath(String path) throws JavaModelException, BackingStoreException {
137:   private static IPath getJarIPath(File execRoot, String file) {
156:   public IPath getPath() {
45: public class BazelClasspathContainer implements IClasspathContainer {
52:   public BazelClasspathContainer(IPath path, IJavaProject project)
93:   private boolean isSourceInPaths(List<String> sources)
104:   public IClasspathEntry[] getClasspathEntries() {
125:   private IClasspathEntry[] jarsToClasspathEntries(Set<Jars> jars) {
20: import java.nio.file.Path;
55:     this.path = path;
61:     Path pp = new File(instance.getWorkspaceRoot().toString() + File.separator + path).toPath();
81:   private boolean matchPatterns(Path path, IPath[] patterns) {
85:         if (matcher.matches(path)) {
141:     File path = new File(execRoot, file);
142:     return org.eclipse.core.runtime.Path.fromOSString(path.toString());
157:     return path;
21: import java.nio.file.PathMatcher;
30: import org.eclipse.core.runtime.IPath;
63:     for (IClasspathEntry entry : project.getRawClasspath()) {
65:         IResource res = root.findMember(entry.getPath());
69:             IPath[] inclusionPatterns = entry.getInclusionPatterns();
83:       for (IPath p : patterns) {
84:         PathMatcher matcher = FileSystems.getDefault().getPathMatcher("glob:" + p.toOSString());
96:       if (isSourcePath(s)) {
117:       Activator.error("Unable to compute classpath containers entries.", e);
130:       entries[i] = JavaCore.newLibraryEntry(getJarIPath(execRoot, j.getJar()),
131:           getJarIPath(execRoot, j.getSrcJar()), null);
147:     return "Bazel Classpath Container";
31: import org.eclipse.jdt.core.IClasspathContainer;
32: import org.eclipse.jdt.core.IClasspathEntry;
64:       if (entry.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
111:         if (!isSourceInPaths(s.getSources())) {
115:       return jarsToClasspathEntries(jars);
118:       return new IClasspathEntry[] {};
121:       return new IClasspathEntry[] {};
126:     IClasspathEntry[] entries = new IClasspathEntry[jars.size()];
github.com/GoogleCloudPlatform/qupath-chcapi-extension:src/main/java/com/quantumsoft/qupathcloud/imageserver/StubImageServer.java: [ master, ]
35:   private String path;
38:   public String getPath() {
47:   public void setPath(String path) {
192:   public String getSubImagePath(String s) {
16: package com.quantumsoft.qupathcloud.imageserver;
30:  * Stub image server which contains only displayed image name and path.
39:     return path;
43:    * Sets path.
45:    * @param path the path
48:     this.path = path;
22: import qupath.lib.images.PathImage;
23: import qupath.lib.images.servers.ImageChannel;
24: import qupath.lib.images.servers.ImageServer;
25: import qupath.lib.images.servers.ImageServerMetadata;
26: import qupath.lib.images.servers.TileRequest;
27: import qupath.lib.regions.RegionRequest;
172:   public PathImage<BufferedImage> readRegion(RegionRequest regionRequest) {
github.com/google/climb-tracker:climblib/src/main/java/fr/steren/climblib/Path.java: [ master, ]
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, ]
101:     private final String path;
69:     public static final String PATH_DIRECTIVE = "path";
33: public class PathEntry extends ImportOptions {
154:     public PathEntry(ManifestHeader.Entry entry, long bundleLastModified) {
248:     public String getPath() {
132:     public static Iterator<PathEntry> getContentPaths(final Bundle bundle) {
31:  * A path entry from the manifest for initial content.
66:      * The path directive specifying the target node where initial content will
100:     /** The path for the initial content. */
122:      * Target path where initial content will be loaded. If it´s null then
155:         this.path = entry.getValue();
201:         // path directive
202:         final String pathValue = entry.getDirectiveValue(PATH_DIRECTIVE);
249:         return this.path;
133:         final List<PathEntry> entries = new ArrayList<>();
144:                 entries.add(new PathEntry(entry, bundleLastModified ));
203:         if (pathValue != null) {
204:             this.target = pathValue;
237:         if (pathValue != null) {
github.com/apache/sling-org-apache-sling-commons-jcr-file:src/main/java/org/apache/sling/commons/jcr/file/internal/JcrPath.java: [ master, ]
41:     private final String path;
37: public class JcrPath implements Path {
47:     JcrPath(final JcrFileSystem fileSystem, final String path) {
54:     JcrPath(final JcrFileSystem fileSystem, final String first, final String... more) {
137:     public Path subpath(int beginIndex, int endIndex) {
229:     public Path toAbsolutePath() {
240:     public Path toRealPath(LinkOption... options) throws IOException {
26: import java.nio.file.Path;
49:         this.path = PathUtil.normalize(path);
50:         this.names = names(this.path);
51:         logger.info("new path: {}", path);
56:         this.path = PathUtil.normalize(first + JcrFileSystem.SEPARATOR + String.join(JcrFileSystem.SEPARATOR, more));
57:         this.names = names(this.path);
58:         logger.info("new path: {}", path);
61:     private List<String> names(final String path) {
63:         if (path != null) {
64:             final String[] strings = path.split("/");
76:         logger.info("getting file system for {}", path);
82:         logger.info("isAbsolute: {}", path);
83:         return path.startsWith("/");
87:     public Path getRoot() {
88:         logger.info("getting root for {}", path);
93:     public Path getFileName() {
94:         logger.info("getting file name for {}", path);
105:     public Path getParent() {
106:         logger.info("getting parent for {}", path);
107:         final String parent = PathUtil.getParent(path);
116:         logger.info("getting name count: {}", path);
121:     public Path getName(int index) {
122:         logger.info("getting name: {}", path);
138:         logger.info("subpath: {}", path);
144:     public boolean startsWith(Path other) {
145:         logger.info("startsWith: {}", path);
152:         logger.info("startsWith: {}", path);
158:     public boolean endsWith(Path other) {
159:         logger.info("endsWith: {}", path);
166:         logger.info("endsWith: {}", path);
171:     public Path normalize() {
172:         logger.info("normalizing path {}", path);
173:         return new JcrPath(fileSystem, PathUtil.normalize(path));
178:     public Path resolve(Path other) {
179:         logger.info("resolving given path {} against this path {}", other, this);
183:         if (this.path.endsWith("/")) {
184:             final String path = this.path.concat(other.toString());
185:             return new JcrPath(fileSystem, path);
187:             final String path = String.format("%s/%s", this.path, other.toString());
188:             return new JcrPath(fileSystem, path);
194:     public Path resolve(String other) {
195:         logger.info("resolving given path {} against this path {}", other, this);
196:         final Path path = new JcrPath(fileSystem, other); // TODO InvalidPathException
197:         return resolve(path);
202:     public Path resolveSibling(Path other) {
209:     public Path resolveSibling(String other) {
216:     public Path relativize(Path other) {
224:         logger.info("toUri: {}", path);
230:         logger.info("toAbsolutePath: {}", path);
234:             return new JcrPath(fileSystem, "/".concat(path));
241:         logger.info("toRealPath: {}", path);
247:         logger.info("to file: {}", path);
248:         return new JcrFile(fileSystem, path);
267:     public Iterator<Path> iterator() {
274:     public int compareTo(Path other) {
281:         return path;
45:     private final Logger logger = LoggerFactory.getLogger(JcrPath.class);
89:         return new JcrPath(fileSystem, "/");
100:             return new JcrPath(fileSystem, name);
111:         return new JcrPath(fileSystem, parent);
132:         return new JcrPath(fileSystem, names.get(index));
github.com/apache/sling-org-apache-sling-models-api:src/main/java/org/apache/sling/models/annotations/injectorspecific/ResourcePath.java: [ master, ]
43:     public String path() default "";
38: public @interface ResourcePath {
48:     public String[] paths() default {};
32:  * resource by path(s). The path may be either in the path/paths attribute or in a value map property with the given name.
37: @Source("resource-path")
41:      * Specifies the path of the resource. If not provided, the path is derived from the property name.
46:      * Specifies more than one path for the resource. If not provided, a single path is derived from the property name.
51:      * Specifies the name of the property containing the resource path. If empty or not set, then the name
github.com/GoogleCloudPlatform/datanucleus-appengine:testing/selenium-core/xpath/javascript-xpath-0.1.8.js: [ master, ]
645: UnionExpr.prototype.path = function(path) {
74: var PathExpr;
673: PathExpr = function(filter) {
2755:     win.XPathExpression = function(expr) {
2773:     win.XPathResult = function (value, type) {
614:     union.path(expr);
619:             throw Error('missing next union location path');
621:         union.path(PathExpr.parse(lexer));
646:     this.paths.push(path);
648:     if (path.needContextPosition) {
651:     if (path.needContextNode) {
686:     var op, expr, path, token;
698:         path = new PathExpr(FilterExpr.root()); // RootExpr
704:         path.step(op, expr);
710:             path = new PathExpr(FilterExpr.context());
711:             path.step('/', expr);
716:             path = new PathExpr(expr);
725:         path.step(op, Step.parse(lexer));
728:     return path;
806:     t += indent + 'path:' + '\n';
1: /*  JavaScript-XPath 0.1.8
4:  *  JavaScript-XPath is freely distributable under the terms of an MIT-style license.
5:  *  For details, see the JavaScript-XPath web site: http://coderepos.org/share/wiki/JavaScript-XPath
24: if (window.jsxpath) {
25:     config = window.jsxpath;
57:                         && document.implementation.hasFeature("XPath", null));
600:     this.paths = [];
609:     expr = PathExpr.parse(lexer);
635:     var paths = this.paths;
637:     for (var i = 0, l = paths.length; i < l; i ++) {
638:         var exrs = paths[i].evaluate(ctx);
639:         if (!exrs.isNodeSet) throw Error('PathExpr must be nodeset');
660:     for (var i = 0; i < this.paths.length; i ++) {
661:         t += this.paths[i].show(indent);
668:  * class: PathExpr
670: if (!window.PathExpr && window.defaultConfig)
671:     window.PathExpr = null;
683: PathExpr.ops = { '//': 1, '/': 1 };
685: PathExpr.parse = function(lexer) {
731: PathExpr.prototype = new BaseExpr();
733: PathExpr.prototype.evaluate = function(ctx) {
786: PathExpr.prototype.step = function(op, step) {
803: PathExpr.prototype.show = function(indent) {
1013:             // fix for "xpath href with spaces" (http://jira.openqa.org/browse/SEL-347)   
2273:         return node.__jsxpath_id__ || (node.__jsxpath_id__ = this.uuid++);
2769:     win.XPathExpression.prototype.evaluate = function(node, type) {
2770:         return new win.XPathResult(this.expr.evaluate(new Ctx(node)), type);
2807:     win.XPathResult.prototype.iterateNext = function() { return this.nodes[this.index++] };
2808:     win.XPathResult.prototype.snapshotItem = function(i) { return this.nodes[i] };
2810:     win.XPathResult.ANY_TYPE = 0;
2811:     win.XPathResult.NUMBER_TYPE = 1;
2812:     win.XPathResult.STRING_TYPE = 2;
2813:     win.XPathResult.BOOLEAN_TYPE = 3;
2814:     win.XPathResult.UNORDERED_NODE_ITERATOR_TYPE = 4;
2815:     win.XPathResult.ORDERED_NODE_ITERATOR_TYPE = 5;
2816:     win.XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE = 6;
2817:     win.XPathResult.ORDERED_NODE_SNAPSHOT_TYPE = 7;
2818:     win.XPathResult.ANY_UNORDERED_NODE_TYPE = 8;
2819:     win.XPathResult.FIRST_ORDERED_NODE_TYPE = 9;
2823:         return new win.XPathExpression(expr, null);
android.googlesource.com/platform/external/mp4parser:isoparser/src/main/java/com/googlecode/mp4parser/util/Path.java: [ master, ]
29: public class Path {
31:     private Path() {
36:     public static String createPath(Box box) {
40:     private static String createPath(Box box, String path) {
52:     public static Box getPath(Box box, String path) {
58:     public static List<Box> getPaths(Box box, String path) {
42:             return path;
46:             path = String.format("/%s[%d]", box.getType(), index) + path;
48:             return createPath(box.getParent(), path);
53:         List<Box> all = getPaths(box, path);
59:         if (path.startsWith("/")) {
65:             return getPaths(isoFile, path.substring(1));
66:         } else if (path.isEmpty()) {
71:             if (path.contains("/")) {
72:                 later = path.substring(path.indexOf('/') + 1);
73:                 now = path.substring(0, path.indexOf('/'));
75:                 now = path;
104:                 throw new RuntimeException(now + " is invalid path.");
111:     public static boolean isContained(Box box, String path) {
112:         assert path.startsWith("/") : "Absolute path required";
113:         return getPaths(box, path).contains(box);
37:         return createPath(box, "");
83:                     return getPaths(box.getParent(), later);
96:                                 children.addAll(getPaths(box1, later));
github.com/apache/sling-org-apache-sling-models-api:src/main/java/org/apache/sling/models/annotations/Path.java: [ master, ]
33: public @interface Path {
36:     public String[] paths() default {};
27:  * Provide path(s) on an &#64;Inject. Not necessarily tied to the Resource Path injector (thus no
github.com/apache/dubbo:dubbo-common/src/main/java/org/apache/dubbo/common/URL.java: [ master, ]
107:     private final String path;
467:     public String getPath() {
471:     public URL setPath(String path) {
475:     public String getAbsolutePath() {
1288:     public String getPathKey() {
52: import static org.apache.dubbo.common.constants.CommonConstants.PATH_KEY;
72:  * for this case, url protocol = null, url host = 192.168.1.3, port = 20880, url path = null
74:  * for this case, url protocol = file, url host = null, url path = home/user1/router.js
76:  * for this case, url protocol = file, url host = home, url path = user1/router.js
78:  * for this case, url protocol = file, url host = null, url path = D:/1/router.js
82:  * for this case, url protocol = null, url host = null, url path = home/user1/router.js
84:  * for this case, url protocol = null, url host = home, url path = user1/router.js
133:         this.path = null;
141: ...(16 bytes skipped)...tring protocol, String host, int port, String[] pairs) { // varargs ... conflict with the following path argument, use array instead.
149:     public URL(String protocol, String host, int port, String path) {
150:         this(protocol, null, null, host, port, path, (Map<String, String>) null);
153:     public URL(String protocol, String host, int port, String path, String... pairs) {
154:         this(protocol, null, null, host, port, path, CollectionUtils.toStringMap(pairs));
157:     public URL(String protocol, String host, int port, String path, Map<String, String> parameters) {
158:         this(protocol, null, null, host, port, path, parameters);
161:     public URL(String protocol, String username, String password, String host, int port, String path) {
162:         this(protocol, username, password, host, port, path, (Map<String, String>) null);
165:     public URL(String protocol, String username, String password, String host, int port, String path, String... pairs) {
166:         this(protocol, username, password, host, port, path, CollectionUtils.toStringMap(pairs));
169:     public URL(String protocol, String username, String password, String host, int port, String path, Map<String, String> parameters) {
180:         while (path != null && path.startsWith("/")) {
181:             path = path.substring(1);
183:         this.path = path;
208:         String path = null;
235:             // case: file:/path/to/file.txt
248:             path = url.substring(i + 1);
276:         return new URL(protocol, username, password, host, port, path, parameters);
347:         return new URL(protocol, username, password, host, port, path, getParameters());
355:         return new URL(protocol, username, password, host, port, path, getParameters());
363:         return new URL(protocol, username, password, host, port, path, getParameters());
380:         return new URL(protocol, username, password, host, port, path, getParameters());
403:         return new URL(protocol, username, password, host, port, path, getParameters());
424:         return new URL(protocol, username, password, host, port, path, getParameters());
468:         return path;
472:         return new URL(protocol, username, password, host, port, path, getParameters());
476:         if (path != null && !path.startsWith("/")) {
477:             return "/" + path;
479:         return path;
958:         return new URL(protocol, username, password, host, port, path, map);
971:         return new URL(protocol, username, password, host, port, path, map);
1007:         return new URL(protocol, username, password, host, port, path, map);
1016:         return new URL(protocol, username, password, host, port, path, map);
1066:         return new URL(protocol, username, password, host, port, path, map);
1070:         return new URL(protocol, username, password, host, port, path, new HashMap<>());
1089:         if (PATH_KEY.equals(key)) {
1090:             return path;
1112:         if (path != null) {
1113:             map.put(PATH_KEY, path);
1219:         String path;
1221:             path = getServiceKey();
1223:             path = getPath();
1225:         if (path != null && path.length() > 0) {
1227:             buf.append(path);
1285:      * The format of return value is '{group}/{path/interfaceName}:{version}'
1289:         String inf = StringUtils.isNotEmpty(path) ? path : getServiceInterface();
1296:     public static String buildKey(String path, String group, String version) {
1301:         buf.append(path);
1322:         return getParameter(INTERFACE_KEY, path);
1432:         result = prime * result + ((path == null) ? 0 : path.hashCode());
1472:         if (path == null) {
1473:             if (other.path != null) {
1476:         } else if (!path.equals(other.path)) {
316: ...(36 bytes skipped)...w URL(url.getProtocol(), url.getUsername(), url.getPassword(), url.getHost(), url.getPort(), url.getPath())
317: ...(20 bytes skipped)...w URL(url.getProtocol(), url.getUsername(), url.getPassword(), url.getHost(), url.getPort(), url.getPath(), newMap);
github.com/apache/incubator-weex:android/sdk/src/main/java/com/taobao/weex/common/Constants.java: [ master, ]
375:     String PATH = "codeCachePath";
377:     String SAVE_PATH = "v8";
github.com/apache/zookeeper:zookeeper-server/src/main/java/org/apache/zookeeper/server/ZooKeeperServer.java: [ master, ]
817:         String path;
169:     final Map<String, ChangeRecord> outstandingChangesForPath = new HashMap<String, ChangeRecord>();
1696:     private String parentPath(String path) throws KeeperException.BadArgumentsException {
1704:     private String effectiveACLPath(Request request) throws KeeperException.BadArgumentsException, KeeperException.InvalidACLException ...(1 bytes skipped)...
149:     private final RequestPathMetricsCollector requestPathMetricsCollector;
302:     public RequestPathMetricsCollector getRequestPathMetricsCollector() {
454:         File path = zkDb.snapLog.getDataDir();
455:         return getDirSize(path);
463:         File path = zkDb.snapLog.getSnapDir();
464:         return getDirSize(path);
807:         ChangeRecord(long zxid, String path, StatPersisted stat, int childCount, List<ACL> acl) {
809:             this.path = path;
830:             return new ChangeRecord(zxid, path, stat, childCount, acl == null ? new ArrayList<>() : new ArrayList<>(acl));
1647:      * @param path :    the ZNode path
1650:     public void checkACL(ServerCnxn cnxn, List<ACL> acl, int perm, List<Id> ids, String path, List<ACL> setAcls) throws KeeperException.NoAuthException {
1679:                                 new ServerAuthenticationProvider.MatchValues(path, authId.getId(), id.getId(), perm, setAcls))) {
1690:      * Trim a path to get the immediate predecessor.
1692:      * @param path
1697:         int lastSlash = path.lastIndexOf('/');
1698:         if (lastSlash == -1 || path.indexOf('\0') != -1 || getZKDatabase().isSpecialPath(path)) {
1699:             throw new KeeperException.BadArgumentsException(path);
1701:         return lastSlash == 0 ? "/" : path.substring(0, lastSlash);
1706:         String path = null;
1716:                 path = parentPath(req.getPath());
1723:                 path = parentPath(req.getPath());
1730:                 path = req.getPath();
1739:                 path = req.getPath();
1750:             PrepRequestProcessor.fixupACL(path, request.authInfo, acl);
1753:         return path;
1810:             LOG.debug("ACL check against illegal node path: {}", e.getMessage());
316:         pwriter.println(zkDb.snapLog.getSnapDir().getAbsolutePath());
320:         pwriter.println(zkDb.snapLog.getDataDir().getAbsolutePath());
341:             zkDb.snapLog.getSnapDir().getAbsolutePath(),
342:             zkDb.snapLog.getDataDir().getAbsolutePath(),
1788:         String pathToCheck;
1797:             pathToCheck = effectiveACLPath(request);
1798:             if (pathToCheck != null) {
1799:                 checkACL(request.cnxn, zkDb.getACL(pathToCheck, null), effectiveACLPerms(request), request.authInfo, pathToCheck, null);
80: import org.apache.zookeeper.server.util.RequestPathMetricsCollector;
234:         this.requestPathMetricsCollector = new RequestPathMetricsCollector();
260:         this.requestPathMetricsCollector = new RequestPathMetricsCollector();
303:         return requestPathMetricsCollector;
601:         requestPathMetricsCollector.start();
751:         requestPathMetricsCollector.shutdown();
github.com/apache/zookeeper:zookeeper-server/src/main/java/org/apache/zookeeper/KeeperException.java: [ master, ]
505:     private String path;
538:     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;
511:     KeeperException(Code code, String path) {
513:         this.path = path;
535:      * Read the path for this exception
536:      * @return the path associated with this error, null if none
539:         return path;
544:         if (path == null || path.isEmpty()) {
547:         return "KeeperErrorCode = " + getCodeMessage(code) + " for " + path;
599:         public BadArgumentsException(String path) {
600:             super(Code.BADARGUMENTS, path);
614:         public BadVersionException(String path) {
615:             super(Code.BADVERSION, path);
653:         public InvalidACLException(String path) {
654:             super(Code.INVALIDACL, path);
728:         public NoChildrenForEphemeralsException(String path) {
729:             super(Code.NOCHILDRENFOREPHEMERALS, path);
743:         public NodeExistsException(String path) {
744:             super(Code.NODEEXISTS, path);
758:         public NoNodeException(String path) {
759:             super(Code.NONODE, path);
773:         public NotEmptyException(String path) {
774:             super(Code.NOTEMPTY, path);
897:         public NoWatcherException(String path) {
898:             super(Code.NOWATCHER, path);
912:         public ReconfigDisabledException(String path) {
913:             super(Code.RECONFIGDISABLED, path);
926:         public SessionClosedRequireAuthException(String path) {
927:             super(Code.SESSIONCLOSEDREQUIRESASLAUTH, path);
github.com/google/google-authenticator:mobile/blackberry/src/com/google/authenticator/blackberry/Uri.java: [ master, ]
496:         private PathPart path;
1025:         private final PathPart path;
1183:         private PathPart path;
1247:         Builder path(PathPart path) {
1263:         public Builder path(String path) {
248:     public abstract String getPath();
256:     public abstract String getEncodedPath();
504:         public String getPath() {
508:         public String getEncodedPath() {
516:         private String parsePath() {
647:         static String parsePath(String uriString, int ssi) {
778:         public String getPath() {
782:         public String getEncodedPath() {
857:     static class PathSegments {
864:         PathSegments(String[] segments, int size) {
885:     static class PathSegmentsBuilder {
1099:         public String getEncodedPath() {
1103:         public String getPath() {
1274:         public Builder encodedPath(String path) {
1281:         public Builder appendPath(String newSegment) {
1288:         public Builder appendEncodedPath(String newSegment) {
1897:     static class PathPart extends AbstractPart {
1905:         private PathPart(String encoded, String decoded) {
1920:         private PathSegments pathSegments;
2074:     public static Uri withAppendedPath(Uri baseUri, String pathSegment) {
297:     public abstract String[] getPathSegments();
304:     public abstract String getLastPathSegment();
498:         private PathPart getPathPart() {
512:         public String[] getPathSegments() {
802:         public String[] getPathSegments() {
806:         public String getLastPathSegment() {
921:         public String getLastPathSegment() {
1123:         public String[] getPathSegments() {
1928:         PathSegments getPathSegments() {
90:        and a path component that begins with two slash characters.  The
96:     <scheme>://<authority><path>?<query>
243:      * Gets the decoded path.
245:      * @return the decoded path, or null if this is not a hierarchical URI
251:      * Gets the encoded path.
253:      * @return the encoded path, or null if this is not a hierarchical URI
293:      * Gets the decoded path segments.
295:      * @return decoded path segments, each without a leading or trailing '/'
300:      * Gets the decoded last segment in the path.
302:      * @return the decoded last segment or null if the path is empty
499:             return path == null
500:                     ? path = PathPart.fromEncoded(parsePath())
501:                     : path;
619:                 // Look for the start of the path, query, or fragment, or the
624:                         case '/': // Start of path
640:          * Parses a path out of this given URI string.
645:          * @return the path
650:             // Find start of path.
655:                 // Skip over authority to path.
661:                             return ""; // Empty path.
662:                         case '/': // Start of path!
668:                 // Path starts immediately after scheme separator.
672:             // Find end of path.
691:                         .path(getPathPart())
855:      * Wrapper for path segment array.
1029:         private HierarchicalUri(String scheme, Part authority, PathPart path,
1033:             this.path = path == null ? PathPart.NULL : path;
1081:             String encodedPath = path.getEncoded();
1100:             return this.path.getEncoded();
1104:             return this.path.getDecoded();
1124:             return this.path.getPathSegments().segments;
1158:                     .path(path)
1169:      * {@code &lt;scheme&gt;://&lt;authority&gt;&lt;absolute path&gt;?&lt;query&gt;#&lt;fragment&gt;}
1172:      * of two patterns: {@code &lt;relative or absolute path&gt;?&lt;query&gt;#&lt;fragment&gt;}
1173:      * or {@code //&lt;authority&gt;&lt;absolute path&gt;?&lt;query&gt;#&lt;fragment&gt;}
1251:             this.path = path;
1256:          * Sets the path. Leaves '/' characters intact but encodes others as
1259:          * <p>If the path is not null and doesn't start with a '/', and if
1261:          * given path with a '/'.
1264:             return path(PathPart.fromDecoded(path));
1268:          * Sets the previously encoded path.
1270:          * <p>If the path is not null and doesn't start with a '/', and if
1272:          * given path with a '/'.
1275:             return path(PathPart.fromEncoded(path));
1279:          * Encodes the given segment and appends it to the path.
1282:             return path(PathPart.appendDecodedSegment(path, newSegment));
1286:          * Appends the given segment to the path.
1289:             return path(PathPart.appendEncodedSegment(path, newSegment));
1378:                 PathPart path = this.path;
1379:                 if (path == null || path == PathPart.NULL) {
1380:                     path = PathPart.EMPTY;
1382:                     // If we have a scheme and/or authority, the path must
1385:                         path = PathPart.makeAbsolute(path);
1390:                         scheme, authority, path, query, fragment);
1894:      * Immutable wrapper of encoded and decoded versions of a path part. Lazily
1917:          * Cached path segments. This doesn't need to be volatile--we don't
1923:          * Gets the individual path segments. Parses them if necessary.
1925:          * @return parsed path segments or null if this isn't a hierarchical
1933:             String path = getEncoded();
1934:             if (path == null) {
1942:             while ((current = path.indexOf('/', previous)) > -1) {
1943:                 // This check keeps us from adding a segment if the path starts
1947:                             = decode(path.substring(previous, current));
1953:             // Add in the final path segment.
1954:             if (previous < path.length()) {
1955:                 segmentBuilder.add(decode(path.substring(previous)));
1963:             // If there is no old path, should we make the new path relative
1967:                 // No old path.
1980:                 // No old path.
1999:          * Creates a path from the encoded string.
2008:          * Creates a path from the decoded string.
2017:          * Creates a path from the encoded and decoded strings.
2035:          * Prepends path values with "/" if they're present, not empty, and
2065:      * Creates a new Uri by appending an already-encoded path segment to a
2068:      * @param baseUri Uri to append path segment to
2069:      * @param pathSegment encoded path segment to append
2071:      *  the path
115:             PathPart.EMPTY, Part.NULL, Part.NULL);
309:      * equal. Case counts. Paths are not normalized. If one Uri specifies a
538:             return parsePath(uriString, ssi);
651:             int pathStart;
656:                 pathStart = ssi + 3;
657:                 LOOP: while (pathStart < length) {
658:                     switch (uriString.charAt(pathStart)) {
665:                     pathStart++;
669:                 pathStart = ssi + 1;
673:             int pathEnd = pathStart;
674:             LOOP: while (pathEnd < length) {
675:                 switch (uriString.charAt(pathEnd)) {
680:                 pathEnd++;
683:             return uriString.substring(pathStart, pathEnd);
859:         static final PathSegments EMPTY = new PathSegments(null, 0);
883:      * Builds PathSegments.
902:         PathSegments build() {
904:                 return PathSegments.EMPTY;
908:                 return new PathSegments(segments, size);
1082:             if (encodedPath != null) {
1083:                 builder.append(encodedPath);
1377:                 // Hierarchical URIs should not return null for getPath().
1900:         static final PathPart NULL = new PathPart(null, null);
1903:         static final PathPart EMPTY = new PathPart("", "");
1929:             if (pathSegments != null) {
1930:                 return pathSegments;
1935:                 return pathSegments = PathSegments.EMPTY;
1938:             PathSegmentsBuilder segmentBuilder = new PathSegmentsBuilder();
1958:             return pathSegments = segmentBuilder.build();
1961:         static PathPart appendEncodedSegment(PathPart oldPart,
1971:             String oldPath = oldPart.getEncoded();
1973:             if (oldPath == null) {
1974:                 oldPath = "";
1977:             int oldPathLength = oldPath.length();
1978:             String newPath;
1981:                 newPath = "/" + newSegment;
1982:             } else if (oldPath.charAt(oldPathLength - 1) == '/') {
1983:                 newPath = oldPath + newSegment;
1985:                 newPath = oldPath + "/" + newSegment;
1988:             return fromEncoded(newPath);
1991:         static PathPart appendDecodedSegment(PathPart oldPart, String decoded) {
1994:             // TODO: Should we reuse old PathSegments? Probably not.
2003:         static PathPart fromEncoded(String encoded) {
2012:         static PathPart fromDecoded(String decoded) {
2022:         static PathPart from(String encoded, String decoded) {
2031:             return new PathPart(encoded, decoded);
2038:         static PathPart makeAbsolute(PathPart oldPart) {
2043:             String oldPath = encodedCached ? oldPart.encoded : oldPart.decoded;
2045:             if (oldPath == null || oldPath.length() == 0
2046:                     || oldPath.startsWith("/")) {
2060:             return new PathPart(newEncoded, newDecoded);
2076:         builder = builder.appendEncodedPath(pathSegment);
505:             return getPathPart().getDecoded();
509:             return getPathPart().getEncoded();
513:             return getPathPart().getPathSegments().segments;
925:             String[] segments = getPathSegments();
1979:             if (oldPathLength == 0) {
github.com/google/error-prone:check_api/src/main/java/com/google/errorprone/util/ASTHelpers.java: [ master, ]
1260:     public abstract TreePath path();
339:   public static <T> TreePath findPathFromEnclosingNodeToTopLevel(TreePath path, Class<T> klass) {
336:    * Given a TreePath, finds the first enclosing node of the given type and returns the path from
340:     if (path != null) {
342:         path = path.getParentPath();
343:       } while (path != null && !(klass.isInstance(path.getLeaf())));
345:     return path;
353:   public static <T> T findEnclosingNode(TreePath path, Class<T> klass) {
354:     path = findPathFromEnclosingNodeToTopLevel(path, klass);
355:     return (path == null) ? null : klass.cast(path.getLeaf());
1110:    * The return value is normalized to always use '/' to separate elements of the path and to always
1122:    * normalized to always use '/' to separate elements of the path and to always have a leading '/'.
1262:     static TargetType create(Type type, TreePath path) {
1263:       return new AutoValue_ASTHelpers_TargetType(type, path);
1320:    * Returns the target type of the tree at the given {@link VisitorState}'s path, or else {@code
1425:       for (TreePath path = parent; path != null; path = path.getParentPath()) {
1426:         Tree enclosing = path.getLeaf();
72: import com.sun.source.util.TreePath;
349:    * Given a TreePath, walks up the tree until it finds a node of the given type. Returns null if no
697:             /* @Inherited won't work if the annotation isn't on the classpath, but we can still
904:     JCCompilationUnit compilationUnit = (JCCompilationUnit) state.getPath().getCompilationUnit();
918:     TreePath pathToExpr = new TreePath(state.getPath(), expr);
919:     return nullnessAnalysis.getNullness(pathToExpr, state.context);
1036:    * Returns true if the leaf node in the {@link TreePath} from {@code state} sits somewhere
1040:     for (Tree ancestor : state.getPath()) {
1127:       return uri.getPath();
1132:       // It's possible (though it violates the zip file spec) for paths to zip file entries to use
1202:     for (Tree enclosing : state.getPath()) {
1328:     if (!(state.getPath().getLeaf() instanceof ExpressionTree)) {
1331:     TreePath parent = state.getPath();
1335:       parent = parent.getParentPath();
1352:     private final TreePath parent;
1355:     private TargetTypeVisitor(ExpressionTree current, VisitorState state, TreePath parent) {
github.com/apache/hive:ql/src/java/org/apache/hadoop/hive/ql/io/AcidUtils.java: [ master, ]
901:     final Path path;
310:   public static Path baseOrDeltaSubdirPath(Path directory, AcidOutputFormat.Options options) {
833:     private final Path baseDirPath;
848:     public Path getBaseDirPath() {
940:     public Path getPath() {
1406:     public Path getPath();
1447:     private Path dirPath;
1470:     public Path getPath() {
2551:     public static Path getVersionFilePath(Path deltaOrBase) {
2651:   public static String getFirstLevelAcidDirPath(Path dataPath, FileSystem fileSystem) throws IOException {
1009:   public static Path[] getPaths(List<ParsedDelta> deltas) {
2614:   public static List<Path> getValidDataPaths(Path dataPath, Configuration conf, String validWriteIdStr)
2689:   public static class IdPathFilter implements PathFilter {
2693:     public IdPathFilter(long writeId, int stmtId) {
47: import org.apache.hadoop.fs.Path;
104:     public boolean accept(Path path) {
105:       return path.getName().startsWith(BASE_PREFIX);
112:    * {@link org.apache.orc.impl.OrcAcidUtils#getSideFile(Path)} side file which stores the length of
119:    * @see org.apache.orc.impl.OrcAcidUtils#getLastFlushLength(FileSystem, Path)
125:     public boolean accept(Path path) {
126:       return path.getName().startsWith(DELTA_PREFIX);
131:     public boolean accept(Path path) {
132:       return path.getName().startsWith(DELETE_DELTA_PREFIX);
138:     public boolean accept(Path path) {
139:       return path.getName().startsWith(BUCKET_PREFIX) &&
140:           !path.getName().endsWith(DELTA_SIDE_FILE_SUFFIX);
164:     public boolean accept(Path path) {
165:       return ORIGINAL_PATTERN.matcher(path.getName()).matches() ||
166:         ORIGINAL_PATTERN_COPY.matcher(path.getName()).matches();
186:     public boolean accept(Path p){
194:     public boolean accept(Path p) {
210:     public boolean accept(Path dirPath) {
235:   public static Path createBucketFile(Path subdir, int bucket) {
245:   private static Path createBucketFile(Path subdir, int bucket, boolean isAcidSchema) {
247:       return new Path(subdir,
251:       return new Path(subdir,
308:    * Return a base or delta directory path according to the given "options".
333:     return new Path(directory, subdir);
342:   public static Path createFilename(Path directory,
345:       return new Path(directory, String.format(LEGACY_FILE_BUCKET_DIGITS,
390:     public static BucketMetaData parse(Path bucketFile) {
407:    * Get the bucket id from the file path
408:    * @param bucketFile - bucket file path
411:   public static int parseBucketId(Path bucketFile) {
424:    * @param bucketFile the path to a bucket file
429:                     parseBaseOrDeltaBucketFilename(Path bucketFile,
486:     private final List<Path> abortedDirectories;
489:     private final List<Path> obsolete;
491:     private final Path base;
493:     public DirectoryImpl(List<Path> abortedDirectories,
495:         List<Path> obsolete, List<ParsedDelta> deltas, Path base) {
506:     public Path getBaseDirectory() {
526:     public List<Path> getObsolete() {
531:     public List<Path> getAbortedDirectories() {
788:     Path getBaseDirectory();
812:     List<Path> getObsolete();
818:     List<Path> getAbortedDirectories();
834:     ParsedBase(long writeId, Path baseDirPath) {
837:     ParsedBase(long writeId, long visibilityTxnId, Path baseDirPath) {
851:     public static ParsedBase parseBase(Path path) {
852:       String filename = path.getName();
858:         return new ParsedBase(Long.parseLong(filename.substring(BASE_PREFIX.length())), path);
861:           Long.parseLong(filename.substring(idxOfv + VISIBILITY_PREFIX.length())), path);
877:     private ParsedDelta(long min, long max, Path path, boolean isDeleteDelta,
879:       this(min, max, path, -1, isDeleteDelta, isRawFormat, visibilityTxnId);
881:     private ParsedDelta(long min, long max, Path path, int statementId,
883:       super(min, max, path, statementId, isDeleteDelta, visibilityTxnId);
894:    * This encapsulates info obtained form the file path.
915:     public static ParsedDeltaLight parse(Path deltaDir) {
922:     private ParsedDeltaLight(long min, long max, Path path, int statementId,
926:       this.path = path;
941:       return path;
956:      * may contain a {@link OrcAcidUtils#getSideFile(Path)}.
999:         return path.compareTo(parsedDelta.path);
1010:     Path[] result = new Path[deltas.size()];
1054:   public static Path[] deserializeDeleteDeltas(Path root, final List<AcidInputFormat.DeltaMetaData> deleteDeltas) throws IOException {
1055:     List<Path> results = new ArrayList<>(deleteDeltas.size());
1058:         results.add(new Path(root, dmd.getName()));
1062:         results.add(new Path(root, dmd.getName(stmtId)));
1065:     return results.toArray(new Path[results.size()]);
1073:   public static ParsedDelta parsedDelta(Path deltaDir, FileSystem fs) throws IOException {
1081:   private static ParsedDelta parseDelta(Path path, String deltaPrefix, FileSystem fs, HdfsDirSnapshot dirSnapshot)
1083:     ParsedDelta p = parsedDelta(path, deltaPrefix, fs, dirSnapshot);
1086:         p.getMaxWriteId(), path, p.statementId, isDeleteDelta, p.isRawFormat(), p.visibilityTxnId);
1089:   public static ParsedDelta parsedDelta(Path deltaDir, String deltaPrefix, FileSystem fs, HdfsDirSnapshot dirSnapshot)
1105:    * {@link #parsedDelta(Path, FileSystem)}
1107:   public static ParsedDelta parsedDelta(Path deltaDir, boolean isRawFormat) {
1144:   public static boolean isAcid(Path directory, Configuration conf) throws IOException {
1148:   public static boolean isAcid(FileSystem fileSystem, Path directory,
1169:     private Path oldestBase = null;
1185:   public static Directory getAcidState(FileSystem fileSystem, Path candidateDirectory, Configuration conf,
1209:     List<Path> originalDirectories = new ArrayList<>();
1210:     final List<Path> obsolete = new ArrayList<>();
1211:     final List<Path> abortedDirectories = new ArrayList<>();
1253:         for (Path origDir : originalDirectories) {
1287:         // the path. This may happen when we have split update and we have two types of delta
1301:         obsolete.add(next.path);
1326:     Path base = null;
1349:       //this does "Path.uri.compareTo(that.uri)"
1356:   public static List<HdfsDirSnapshot> getHdfsDirSnapshots(final FileSystem fs, final Path path) throws IOException {
1358:       Map<Path, HdfsDirSnapshot> dirToSnapshots = new HashMap<Path, HdfsDirSnapshot>();
1359:       RemoteIterator<LocatedFileStatus> itr = fs.listFiles(path, true);
1362:         Path fPath = fStatus.getPath();
1371:             Path parentDirPath = fPath.getParent();
1458:     public HdfsDirSnapshotImpl(Path path, FileStatus fStatus, List<FileStatus> files) {
1459:       this.dirPath = path;
1464:     public HdfsDirSnapshotImpl(Path path, FileStatus fStatus) {
1465:       this.dirPath = path;
1562:       sb.append("Path: " + dirPath);
1622:       ValidWriteIdList writeIdList, List<ParsedDelta> working, List<Path> originalDirectories,
1623:       List<HdfsFileStatusWithId> original, List<Path> obsolete, TxnBase bestBase,
1624:       boolean ignoreEmptyFiles, List<Path> aborted, Map<String, String> tblproperties,
1626:     Path p = child.getPath();
1682:   private static void getChildState(Path candidateDirectory, List<HdfsDirSnapshot> dirSnapshots, ValidWriteIdList writeIdList,
1683:       List<ParsedDelta> working, List<Path> originalDirectories, List<HdfsFileStatusWithId> original,
1684:       List<Path> obsolete, TxnBase bestBase, boolean ignoreEmptyFiles, List<Path> aborted,
1688:       Path dirPath = dirSnapshot.getPath();
1753:   private static boolean isDirUsable(Path child, long visibilityTxnId,
1754:       List<Path> aborted, ValidTxnList validTxnList) {
1798:   public static void findOriginals(FileSystem fs, Path dir,
1832:       Path directory) {
1882:   public static boolean isDeleteDelta(Path p) {
1885:   public static boolean isInsertDelta(Path p) {
2050:    * by {@link #getAcidState(Path, Configuration, ValidWriteIdList)} and so won't be read at all.
2054:     Path acidDir = file.getPath().getParent(); //should be base_x or delta_x_y_
2064:     Path lengths = OrcAcidUtils.getSideFile(file.getPath());
2364:     static boolean isCompacted(Path baseOrDeltaDir, FileSystem fs) throws IOException {
2370:       Path formatFile = new Path(baseOrDeltaDir, METADATA_FILE);
2402:     private static Path chooseFile(Path baseOrDeltaDir, FileSystem fs) throws IOException {
2409:         dataFiles = fs.listStatus(new Path[]{baseOrDeltaDir}, originalBucketFilter);
2433:     public static boolean isRawFormat(Path baseOrDeltaDir, FileSystem fs, HdfsDirSnapshot dirSnapshot) throws IOException {
2454:       Path dataFile;
2467:     public static boolean isRawFormatFile(Path dataFile, FileSystem fs) throws IOException {
2522:     public static int getAcidVersionFromDataFile(Path dataFile, FileSystem fs) throws IOException {
2540:     public static void writeVersionFile(Path deltaOrBaseDir, FileSystem fs)  throws IOException {
2541:       Path formatFile = getVersionFilePath(deltaOrBaseDir);
2552:       return new Path(deltaOrBase, ACID_FORMAT);
2555:     public static int getAcidVersionFromMetaFile(Path deltaOrBaseDir, FileSystem fs)
2557:       Path formatFile = getVersionFilePath(deltaOrBaseDir);
2579:       Table table, Path dir, Configuration jc, FileSystem fs) throws IOException {
2616:     List<Path> pathList = new ArrayList<>();
2618:       // If Non-Acid case, then all files would be in the base data path. So, just return it.
2640:   public static String getAcidSubDir(Path dataPath) {
2650:   //Get the first level acid directory (if any) from a given path
2665:     // We need the path for directory so no need to append file name
2667:       return acidDirPath + Path.SEPARATOR + dataPath.getName();
2684:      public boolean accept(Path path) {
2685:        return extractWriteId(path) != null;
2707:     public boolean accept(Path path) {
2708:       String name = path.getName();
2715:   public static Long extractWriteId(Path file) {
2980:       FileStatus[] fileStatuses = LoadSemanticAnalyzer.matchFilesOrDir(fs, new Path(uri));
2983:       throw new SemanticException(ErrorMsg.INVALID_PATH.getMsg(ex.getMessage()), ex);
48: import org.apache.hadoop.fs.PathFilter;
102:   public static final PathFilter baseFileFilter = new PathFilter() {
123:   public static final PathFilter deltaFileFilter = new PathFilter() {
129:   public static final PathFilter deleteEventDeltaDirFilter = new PathFilter() {
136:   public static final PathFilter bucketFileFilter = new PathFilter() {
162:   public static final PathFilter originalBucketFilter = new PathFilter() {
184:   public static final PathFilter hiddenFileFilter = new PathFilter(){
192:   public static final PathFilter acidHiddenFileFilter = new PathFilter() {
208:   public static final PathFilter acidTempDirFilter = new PathFilter() {
211:       String dirPathStr = dirPath.toString();
348:       return createBucketFile(baseOrDeltaSubdirPath(directory, options), options.getBucketId());
835:       this(writeId, 0, baseDirPath);
840:       this.baseDirPath = baseDirPath;
849:       return baseDirPath;
1007:    * @return a list of delta directory paths that need to be read
1012:       result[i] = deltas.get(i).getPath();
1028:       assert parsedDelta.isDeleteDelta() : "expected delete_delta, got " + parsedDelta.getPath();
1052:    * @return the list of delta paths
1152:       String filename = file.getPath().getName();
1239:         obsolete.add(fswid.getFileStatus().getPath());
1329:       base = bestBase.status.getPath();
1363:         if (acidHiddenFileFilter.accept(fPath)) {
1364:           if (fStatus.isDirectory() && acidTempDirFilter.accept(fPath)) {
1365:             HdfsDirSnapshot dirSnapshot = dirToSnapshots.get(fPath);
1367:               dirSnapshot = new HdfsDirSnapshotImpl(fPath, fStatus);
1368:               dirToSnapshots.put(fPath, dirSnapshot);
1372:             if (acidTempDirFilter.accept(parentDirPath)) {
1373:               FileStatus parentDirFStatus = fs.getFileStatus(parentDirPath);
1374:               HdfsDirSnapshot dirSnapshot = dirToSnapshots.get(parentDirPath);
1376:                 dirSnapshot = new HdfsDirSnapshotImpl(parentDirPath, parentDirFStatus);
1377:                 dirToSnapshots.put(parentDirPath, dirSnapshot);
1381:               if (fStatus.getPath().toString().contains(MetaDataFile.METADATA_FILE)) {
1383:               } else if (fStatus.getPath().toString().contains(OrcAcidVersion.ACID_FORMAT)) {
1471:       return dirPath;
1617:     return parsedBase.getVisibilityTxnId() > 0 || MetaDataFile.isCompacted(parsedBase.getBaseDirPath(), fs);
1636:       if(!isDirUsable(child.getPath(), parsedBase.getVisibilityTxnId(), aborted, validTxnList)) {
1652:           obsolete.add(bestBase.status.getPath());
1657:         obsolete.add(child.getPath());
1661:       ParsedDelta delta = parseDelta(child.getPath(), deltaPrefix, fs, null);
1662:       if(!isDirUsable(child.getPath(), delta.getVisibilityTxnId(), aborted, validTxnList)) {
1667:         aborted.add(child.getPath());
1678:       originalDirectories.add(child.getPath());
1689:       String dirName = dirPath.getName();
1692:         ParsedBase parsedBase = ParsedBase.parseBase(dirPath);
1693:         if (!isDirUsable(dirPath, parsedBase.getVisibilityTxnId(), aborted, validTxnList)) {
1699:           bestBase.oldestBase = dirPath;
1709:             obsolete.add(bestBase.status.getPath());
1714:           obsolete.add(dirPath);
1718:         ParsedDelta delta = parseDelta(dirPath, deltaPrefix, fs, dirSnapshot);
1719:         if (!isDirUsable(dirPath, delta.getVisibilityTxnId(), aborted, validTxnList)) {
1724:           aborted.add(dirPath);
1738:         if (!candidateDirectory.equals(dirPath)) {
1739:           originalDirectories.add(dirPath);
1806:             findOriginals(fs, child.getFileStatus().getPath(), original, useFileIds,
1820:             findOriginals(fs, child.getPath(), original, useFileIds, ignoreEmptyFiles, true);
2072:     long len = OrcAcidUtils.getLastFlushLength(fs, file.getPath());
2422:       return dataFiles != null && dataFiles.length > 0 ? dataFiles[0].getPath() : null;
2456:         dataFile = dirSnapshot.getFiles().get(0).getPath();
2601:       for (FileStatus f : HiveStatsUtils.getFileStatusRecurse(delta.getPath(), -1, fs)) {
2619:       pathList.add(dataPath);
2620:       return pathList;
2625:     Directory acidInfo = AcidUtils.getAcidState(dataPath.getFileSystem(conf), dataPath, conf, validWriteIdList, null,
2629:       pathList.add(hfs.getFileStatus().getPath());
2632:       pathList.add(delta.getPath());
2635:       pathList.add(acidInfo.getBaseDirectory());
2637:     return pathList;
2641:     String dataDir = dataPath.getName();
2652:     if (dataPath == null) {
2655:     String firstLevelAcidDir = getAcidSubDir(dataPath);
2660:     String acidDirPath = getFirstLevelAcidDirPath(dataPath.getParent(), fileSystem);
2661:     if (acidDirPath == null) {
2666:     if (fileSystem.isDirectory(dataPath)) {
2669:     return acidDirPath;
2682:   public static class AnyIdDirFilter implements PathFilter {
2963:         if (!AcidUtils.MetaDataFile.isRawFormatFile(oneSrc.getPath(), fs)) {
2964:           throw new SemanticException(ErrorMsg.LOAD_DATA_ACID_FILE, oneSrc.getPath().toString());
213:       if (dirPathStr.contains(SessionState.TMP_PREFIX)) {
216:       if ((dirPathStr.contains("/.")) || (dirPathStr.contains("/_"))) {
github.com/apache/camel:platforms/spring-boot/components-starter/camel-netty-http-starter/src/main/java/org/apache/camel/component/netty/http/springboot/NettyHttpComponentConfiguration.java: [ master, ]
240:         private String path;
288:         private Boolean useRelativePath = true;
370:         public String getPath() {
374:         public void setPath(String path) {
418:         public Boolean getUseRelativePath() {
422:         public void setUseRelativePath(Boolean useRelativePath) {
238:          * Resource path
286:          * Sets whether to use a relative path in HTTP requests.
371:             return path;
375:             this.path = path;
419:             return useRelativePath;
423:             this.useRelativePath = useRelativePath;
github.com/apache/shiro:web/src/main/java/org/apache/shiro/web/servlet/SimpleCookie.java: [ master, ]
77:     private String path;
62:     protected static final String PATH_ATTRIBUTE_NAME = "Path";
141:     public String getPath() {
145:     public void setPath(String path) {
189:     private String calculatePath(HttpServletRequest request) {
277:     private void appendPath(StringBuilder sb, String path) {
339:     private boolean pathMatches(String cookiePath, String requestPath) {
99:         this.path = cookie.getPath();
142:         return path;
146:         this.path = path;
182:      * Returns the Cookie's calculated path setting.  If the {@link javax.servlet.http.Cookie#getPath() path} is {@code null}, then the
183:      * {@code request}'s {@link javax.servlet.http.HttpServletRequest#getContextPath() context path}
184:      * will be returned. If getContextPath() is the empty string or null then the ROOT_PATH constant is returned.
187:      * @return the path to be used as the path when the cookie is created or removed
190:         String path = StringUtils.clean(getPath());
191:         if (!StringUtils.hasText(path)) {
192:             path = StringUtils.clean(request.getContextPath());
196:         if (path == null) {
197:             path = ROOT_PATH;
199:         log.trace("calculated path: {}", path);
200:         return path;
209:         String path = calculatePath(request);
215:         addCookieHeader(response, name, value, comment, domain, path, maxAge, version, secure, httpOnly);
219:                                  String domain, String path, int maxAge, int version,
222:         String headerValue = buildHeaderValue(name, value, comment, domain, path, maxAge, version, secure, httpOnly);
238:                                       String domain, String path, int maxAge, int version,
253:         appendPath(sb, path);
278:         if (StringUtils.hasText(path)) {
280:             sb.append(PATH_ATTRIBUTE_NAME).append(NAME_VALUE_DELIMITER).append(path);
337:      * @see <a href="https://tools.ietf.org/html/rfc6265#section-5.1.4">RFC 6265, Section 5.1.4 "Paths and Path-Match"</a>
367:         String path = calculatePath(request);
373:         addCookieHeader(response, name, value, comment, domain, path, maxAge, version, secure, httpOnly);
384:             String path = StringUtils.clean(getPath());
385:             if (path != null && !pathMatches(path, request.getRequestURI())) {
386:                 log.warn("Found '{}' cookie at path '{}', but should be only used for '{}'", new Object[] { name, request.getRequestURI(), path});
332:      * Check whether the given {@code cookiePath} matches the {@code requestPath}
334:      * @param cookiePath
335:      * @param requestPath
340:         if (!requestPath.startsWith(cookiePath)) {
344:         return requestPath.length() == cookiePath.length()
345:             || cookiePath.charAt(cookiePath.length() - 1) == '/'
346:             || requestPath.charAt(cookiePath.length()) == '/';
github.com/git/git-scm.com:vendor/assets/javascripts/session.min.js: [ master, ]
8: ...(4305 bytes skipped)...e==null){e={visits:1,start:(new Date).getTime(),last_visit:(new Date).getTime(),url:a.location.href,path:a.location.path...(2214 bytes skipped)....length,h;for(;f<g;f++)h=e[f].split("="),h.length===2&&(d[h[0]]=decodeURI(h[1]))}return{host:c.host,path:c.path...(269 bytes skipped)...),"=",encodeURIComponent(String(d)),f.expires?"; expires="+(new Date(f.expires)).toUTCString():"",f.path?"; path="+f.path:"",f.domain?"; domain="+f.domain:"",a.location&&a.location.protocol==="https:"?"; secure":""].join(...(966 bytes skipped)...
github.com/apache/nifi:nifi-nar-bundles/nifi-hive-bundle/nifi-hive-processors/src/main/java/org/apache/hadoop/hive/ql/io/orc/OrcFlowFileWriter.java: [ master, ]
113:     private final Path path;
38: import org.apache.hadoop.fs.Path;
157:                              Path path,
175:         this.path = path;
213:         memoryManager.addWriter(path, stripeSize, this);
333:             LOG.debug("ORC writer " + path + " size = " + size + " limit = " +
2519:         memoryManager.removeWriter(path);
github.com/apache/pulsar:pulsar-client-tools/src/main/java/org/apache/pulsar/admin/cli/CmdFunctions.java: [ master, ]
901:         protected String path;
936:         protected String path;
587:         protected String DEPRECATED_tlsTrustCertFilePath;
589:         protected String tlsTrustCertFilePath;
198:         @Parameter(names = "--jar", description = "Path to the JAR file for the function (if the function is written in Java). It also supports URL path [http/https/file (file protocol assumes that file already exists on worker host)] from which worker...(67 bytes skipped)...
202:                 description = "Path to the main Python file/Python Wheel file for the function (if the function is written in Python)",...(0 bytes skipped)...
207:                 description = "Path to the main Go executable binary for the function (if the function is written in Go)")
242:         @Parameter(names = "--functionConfigFile", description = "The path to a YAML config file that specifies the configuration of a Pulsar Function", hidden = true)
244:         @Parameter(names = "--function-config-file", description = "The path to a YAML config file that specifies the configuration of a Pulsar Function")
586:         @Parameter(names = "--tls_trust_cert_path", description = "tls trust cert file path", hidden = true)
588:         @Parameter(names = "--tls-trust-cert-path", description = "tls trust cert file path")
860:         @Parameter(names = "--triggerFile", description = "The path to the file that contains the data with which you want to trigger the function", hidden = true)
862:         @Parameter(names = "--trigger-file", description = "The path to the file that contains the data with which you want to trigger the function")
898:                 names = "--path",
899:                 description = "Path where the contents need to be stored",
914:             admin.functions().uploadFunction(sourceFile, path);
933:                 names = "--path",
934:                 description = "Path to store the content",
944:             if (path == null) {
956:             if (path != null) {
957:                 admin.functions().downloadFunction(destinationFile, path);
604:             if (!StringUtils.isBlank(DEPRECATED_tlsTrustCertFilePath)) tlsTrustCertFilePath = DEPRECATED_tlsTrustCertFilePath;
877:                 throw new ParameterException("Either a trigger value or a trigger filepath needs to be specified");
github.com/apache/netbeans:contrib/javaee.wildfly/src/org/netbeans/modules/javaee/wildfly/ide/commands/Constants.java: [ master, ]
300:     public static final String PATH = "path";// NOI18N
227:     public static final String JAXRS_RESOURCE_PATH = "resource-path";// NOI18N
366:     public static final String RESOLVE_PATH = "resolve-path";// NOI18N
374:     public static final String RESULT_PATH = "result-path";// NOI18N
github.com/grpc/grpc-java:netty/src/main/java/io/grpc/netty/AbstractHttp2Headers.java: [ master, ]
534:   public Http2Headers path(CharSequence value) {
539:   public CharSequence path() {
github.com/apache/zeppelin:zeppelin-zengine/src/main/java/org/apache/zeppelin/notebook/Note.java: [ master, ]
96:   private String path;
132:   public String getPath() {
136:   public String getParentPath() {
199:   public void setPath(String path) {
95:   // The front end needs to judge TRASH_FOLDER according to the path
111:   public Note(String path, String defaultInterpreterGroup, InterpreterFactory factory,
114:     setPath(path);
133:     return path;
137:     int pos = path.lastIndexOf("/");
141:       return path.substring(0, pos);
145:   private String getName(String path) {
146:     int pos = path.lastIndexOf("/");
147:     return path.substring(pos + 1);
200:     if (!path.startsWith("/")) {
201:       this.path = "/" + path;
203:       this.path = path;
205:     this.name = getName(path);
339:     if (this.path == null) {
341:         this.path = name;
343:         this.path = "/" + name;
346:       int pos = this.path.lastIndexOf("/");
347:       this.path = this.path.substring(0, pos + 1) + this.name;
877:     return this.path.startsWith("/" + NoteManager.TRASH_FOLDER);
1019:     if (this.path != null) {
1020:       return this.path;
1078:     //TODO(zjffdu) exclude path because FolderView.index use Note as key and consider different path
1080:     //    if (path != null ? !path.equals(note.path) : note.path != null) return false;
1098:     //    result = 31 * result + (path != null ? path.hashCode() : 0);
129:     setPath(noteInfo.getPath());
github.com/apache/curator:curator-recipes/src/main/java/org/apache/curator/framework/recipes/cache/TreeCache.java: [ master, ]
85:         private final String path;
231:         final String path;
67:  * <p>A utility that attempts to keep all data from all children of a ZK path locally cached. This class
68:  * will watch the ZK path, respond to update/create/delete events, pull down the data, etc. You can
94:         private Builder(CuratorFramework client, String path)
97:             this.path = validatePath(path);
110:             return new TreeCache(client, path, cacheData, dataIsCompressed, maxDepth, executor, createParentNodes, disableZkWatches, selector);
161:          * By default, TreeCache does not auto-create parent nodes for the cached path. Change
174: ...(6 bytes skipped)...   * By default, TreeCache creates {@link org.apache.zookeeper.ZooKeeper} watches for every created path.
199:      * Create a TreeCache builder for the given client and path to configure advanced options.
202:      * the namespace, including all published events.  The given path is the root at which the
203:      * TreeCache will watch and explore.  If no node exists at the given path, the TreeCache will
207:      * @param path   the path to the root node to watch/explore; this path need not actually exist on
211:     public static Builder newBuilder(CuratorFramework client, String path)
213:         return new Builder(client, path);
235:         TreeNode(String path, TreeNode parent)
237:             this.path = path;
244:             if ((depth < maxDepth) && selector.traverseChildren(path))
256:             if ((depth < maxDepth) && selector.traverseChildren(path))
273:                 maybeWatch(client.getChildren()).forPath(path);
283:                     maybeWatch(client.getData().decompressed()).forPath(path);
287:                     maybeWatch(client.getData()).forPath(path);
350:                 maybeWatch(client.checkExists()).forPath(path);
358:                     parentChildMap.remove(ZKPaths.getNodeFromPath(path), this);
439:                         if ( !childMap.containsKey(child) && selector.acceptChild(ZKPaths.makePath(path, child)) )
448:                         String fullPath = ZKPaths.makePath(path, child);
550:      * Create a TreeCache for the given client and path with default options.
553:      * the namespace, including all published events.  The given path is the root at which the
554:      * TreeCache will watch and explore.  If no node exists at the given path, the TreeCache will
558:      * @param path   the path to the root node to watch/explore; this path need not actually exist on
562:     public TreeCache(CuratorFramework client, String path)
564:         this(client, path, true, false, Integer.MAX_VALUE, Executors.newSingleThreadExecutor(defaultThreadFactory), false, fa...(37 bytes skipped)...
569:      * @param path             path to watch
571:      * @param dataIsCompressed if true, data in the path is compressed
577:     TreeCache(CuratorFramework client, String path, boolean cacheData, boolean dataIsCompressed, int maxDepth, final ExecutorService executorService, ...(80 bytes skipped)...
581:         this.root = new TreeNode(validatePath(path), null);
602:             client.createContainers(root.path);
660:         LinkedList<String> rootElements = new LinkedList<String>(ZKPaths.split(root.path));
664:                 // Target path shorter than root path
670:                 // Initial root path does not match
693:      * Return the current set of children at the given path, mapped by child name. There are no
695:      * node at this path, {@code null} is returned.
697:      * @param fullPath full path to the node to check
733:      * Return the current data for the given path. There are no guarantees of accuracy. This is
734:      * merely the most recent view of the data. If there is no node at the given path,
737:      * @param fullPath full path to the node to check
32: import org.apache.curator.framework.api.Pathable;
39: import org.apache.curator.utils.PathUtils;
64: import static org.apache.curator.utils.PathUtils.validatePath;
151:          * root node and its immediate children (kind of like {@link PathChildrenCache}.
292:         private <T, P extends Watchable<BackgroundPathable<T>> & BackgroundPathable<T>> Pathable<T> maybeWatch(
417: ...(5 bytes skipped)...                   childDataUpdater.compareAndSet(this, oldChildData, new ChildData(oldChildData.getPath(), newStat, oldChildData.getData()));
449:                         TreeNode node = new TreeNode(fullPath, this);
464:                     String eventPath = event.getPath();
465:                     ChildData toPublish = new ChildData(eventPath, newStat, event.getData());
466:                     ChildData toUpdate = cacheData ? toPublish : new ChildData(eventPath, newStat, null);
657:     private TreeNode find(String findPath)
659:         PathUtils.validatePath(findPath);
661:         LinkedList<String> findElements = new LinkedList<String>(ZKPaths.split(findPath));
700:     public Map<String, ChildData> getCurrentChildren(String fullPath)
702:         TreeNode node = find(fullPath);
740:     public ChildData getCurrentData(String fullPath)
742:         TreeNode node = find(fullPath);
30: import org.apache.curator.framework.api.BackgroundPathable;
41: import org.apache.curator.utils.ZKPaths;
github.com/apache/cloudstack:api/src/main/java/org/apache/cloudstack/api/ApiConstants.java: [ master, ]
247:     public static final String PATH = "path";
119:     public static final String DOMAIN_PATH = "domainpath";
663:     public static final String HEALTHCHECK_PINGPATH = "pingpath";
github.com/apache/pdfbox:pdfbox/src/main/java/org/apache/pdfbox/cos/COSName.java: [ trunk, ]
436:     public static final COSName PATH = new COSName("Path");
github.com/apache/jmeter:src/protocol/http/org/apache/jmeter/protocol/http/sampler/HTTPSamplerBase.java: [ trunk, ]
156:     public static final String PATH = "HTTPSampler.path"; // $NON-NLS-1$
464:     public void setPath(String path) {
479:     public void setPath(String path, String contentEncoding) {
497:     public String getPath() {
367:      * i.e. there is a single file entry which has a non-empty path and
433:                 log.warn("File {} is invalid as no path is defined", httpFileArg);
458:      * Sets the Path attribute of the UrlConfig object Also calls parseArguments
461:      * @param path
462:      *            The new Path value
466:         setPath(path, EncoderCache.URL_ARGUMENT_ENCODING);
470:      * Sets the PATH property; if the request is a GET or DELETE (and the path
474:      * @param path
475:      *            The new Path value
480:         boolean fullUrl = path.startsWith(HTTP_PREFIX) || path.startsWith(HTTPS_PREFIX);
484:             int index = path.indexOf(QRY_PFX);
486:                 setProperty(PATH, path.substring(0, index));
488:                 parseArguments(path.substring(index + 1), contentEncoding);
490:                 setProperty(PATH, path);
493:             setProperty(PATH, path);
498:         String p = getPropertyAsString(PATH);
1006:      * As a special case, if the path starts with "http[s]://",
1007:      * then the path is assumed to be the entire URL.
1014:         String path = this.getPath();
1016:         if (path.startsWith(HTTP_PREFIX)
1017:                 || path.startsWith(HTTPS_PREFIX)) {
1018:             return new URL(path);
1028:             if (!path.startsWith("/")) { // $NON-NLS-1$
1032:         pathAndQuery.append(path);
1043:                 if (path.contains(QRY_PFX)) {// Already contains a prefix
1500:     protected String encodeSpaces(String path) {
1501:         return JOrphanUtils.replaceAllChars(path, ' ', "%20"); // $NON-NLS-1$
1929:      * Version 2.3.3 introduced a list of files, each with their own path, name and mimetype.
2090:      * Replace by replaceBy in path and body (arguments) properties
301:     /** Whether to remove '/pathsegment/..' from redirects; default true */
375:                 && (files[0].getPath().length() > 0)
432:             if(StringUtils.isEmpty(httpFileArg.getPath())) {
1023:         StringBuilder pathAndQuery = new StringBuilder(100);
1029:                 pathAndQuery.append('/'); // $NON-NLS-1$
1044:                     pathAndQuery.append(QRY_SEP);
1046:                     pathAndQuery.append(QRY_PFX);
1048:                 pathAndQuery.append(queryString);
1053:             return new URL(protocol, domain, pathAndQuery.toString());
1055:         return new URL(protocol, domain, getPort(), pathAndQuery.toString());
2100:         totalReplaced += JOrphanUtils.replaceValue(regex, replaceBy, caseSensitive, getPath(), this::setPath);
github.com/apache/cloudstack:plugins/storage/volume/cloudbyte/src/main/java/org/apache/cloudstack/storage/datastore/util/ElastistorUtil.java: [ master, ]
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/tinkerpop:gremlin-javascript/src/main/javascript/gremlin-javascript/lib/process/graph-traversal.js: [ master, ]
870:   path(...args) {
1306:   path: (...args) => callOnEmptyTraversal('path', args),
110:   withPath(...args) {
420:   cyclicPath(...args) {
1010:   shortestPath(...args) {
1030:   simplePath(...args) {
1264:   cyclicPath: (...args) => callOnEmptyTraversal('cyclicPath', args),
1317:   simplePath: (...args) => callOnEmptyTraversal('simplePath', args),
866:    * Graph traversal path method.
871:     this.bytecode.addStep('path', args);
106:    * Graph Traversal Source withPath method.
111:     const b = new Bytecode(this.bytecode).addSource('withPath', args);
416:    * Graph traversal cyclicPath method.
421:     this.bytecode.addStep('cyclicPath', args);
1006:    * Graph traversal shortestPath method.
1011:     this.bytecode.addStep('shortestPath', args);
1026:    * Graph traversal simplePath method.
1031:     this.bytecode.addStep('simplePath', args);
github.com/apache/hbase:hbase-server/src/main/java/org/apache/hadoop/hbase/io/hfile/HFileReaderImpl.java: [ master, ]
117:   private final Path path;
1243:   public Path getPath() {
324:   private static String getPathOffsetEndStr(final Path path, final long offset, final long end) {
30: import org.apache.hadoop.fs.Path;
116:   /** Path of file */
170:   public HFileReaderImpl(Path path, FixedFileTrailer trailer, FSDataInputStreamWrapper fsdis,
173:     this(path, trailer, fsdis, fileSize, cacheConf, hfs, true, conf);
179:    * @param path
180:    *          Path to HFile.
195:   public HFileReaderImpl(Path path, FixedFileTrailer trailer, FSDataInputStreamWrapper fsdis,
202:     this.path = path;
203:     this.name = path.getName();
207:     this.hfileContext = createHFileContext(fsdis, fileSize, hfs, path, trailer);
208:     this.fsBlockReader = new HFileBlock.FSReaderImpl(fsdis, fileSize, hfs, path, hfileContext,
263:       PrefetchExecutor.request(path, new Runnable() {
271:               LOG.trace("Prefetch start " + getPathOffsetEndStr(path, offset, end));
298:               LOG.trace("Prefetch " + getPathOffsetEndStr(path, offset, end), e);
302:                 getPathOffsetEndStr(path, offset, end), e);
305:             LOG.warn("Prefetch " + getPathOffsetEndStr(path, offset, end), e);
307:             PrefetchExecutor.complete(path);
325:     return "path=" + path.toString() + ", offset=" + offset + ", end=" + end;
340:       "major=2 and minor=" + MAX_MINOR_VERSION + ", path=" + path);
345:     public BlockIndexNotLoadedException(Path path) {
347:       super(path + " block index not loaded");
361:     return "reader=" + path.toString() +
386:       throw new BlockIndexNotLoadedException(path);
476:     public NotSeekedException(Path path) {
477:       super(path + " not seeked to a key/value");
632:           " path=" + reader.getPath());
720:               + " path=" + reader.getPath());
736:                 + " path=" + reader.getPath());
752:                   + ", path=" + reader.getPath());
908:     @edu.umd.cs.findbugs.annotations.SuppressWarnings(value="NP_NULL_ON_SOME_PATH",
923:           throw new IOException("Invalid block file offset: " + block + ", path=" + reader.getPath());
1006:       // Okie to create new Pair. Not used in hot path
1037:             + "; path=" + reader.getPath());
1134:         throw new IOException("Invalid block offset: " + newBlock.getOffset() + ", path=" + reader.getPath());
1176:             + " (without header)." + ", path=" + reader.getPath());
1244:     return path;
1342:                 + expectedDataBlockEncoding + ", actual: " + actualDataBlockEncoding + ", path=" + path);
1368:       throw new IOException(path + " meta index not loaded");
1439:       throw new IOException(path + " block index not loaded");
1446:         ", path=" + path);
1483:                 // Remember to release the block when in exceptional path.
1487:                     + dataBlockEncoder.getDataBlockEncoding() + "), path=" + path);
1562:           "but got " + actualBlockType + ": " + block + ", path=" + path);
1593:     PrefetchExecutor.cancel(path);
1667:                   + DataBlockEncoding.getNameFromId(dataBlockEncoderId) + ",path=" + reader.getPath());
1788:           " is not supported, path=" + path) ;
1813:     return PrefetchExecutor.isCompleted(path);
1817:       HFileSystem hfs, Path path, FixedFileTrailer trailer) throws IOException {
1834:             + ", path=" + path);
1844:       LOG.trace("Reader" + (path != null? " for " + path: "") +
561:         throw new NotSeekedException(reader.getPath());
1192:                   + "HFileName=" + reader.getPath() + ", " + "dataBlockEncoder="
1742:         throw new NotSeekedException(reader.getPath());
github.com/google/ion:third_party/icu/android_icu4j/src/main/java/android/icu/impl/number/Parse.java: [ master, ]
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, ]
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/tinkerpop:gremlin-driver/src/main/java/org/apache/tinkerpop/gremlin/driver/Cluster.java: [ master, ]
538:         private String path = "/gremlin";
597:         public Builder path(final String path) {
981:         private final String path;
295:     public String getPath() {
181:                 .path(settings.path)
293:      * Gets the path to the Gremlin service.
296:         return manager.path;
595:          * The path to the Gremlin service on the host which is "/gremlin" by default.
598:             this.path = path;
1024:             path = builder.path;
github.com/firebase/firebase-android-sdk:firebase-database/src/main/java/com/google/firebase/database/connection/PersistentConnectionImpl.java: [ master, ]
41:     private final List<String> path;
148:     private final List<String> path;
189:   private static final String REQUEST_PATH = "p";
221:   private static final String SERVER_DATA_UPDATE_PATH = "p";
223:   private static final String SERVER_DATA_START_PATH = "s";
224:   private static final String SERVER_DATA_END_PATH = "e";
164:     public List<String> getPath() {
196:   private static final String REQUEST_COMPOUND_HASH_PATHS = "ps";
44:     public ListenQuerySpec(List<String> path, Map<String, Object> queryParams) {
45:       this.path = path;
58:       if (!path.equals(that.path)) {
66:       int result = path.hashCode();
73:       return ConnectionUtils.pathToString(this.path) + " (params: " + queryParams + ")";
153:         String action, List<String> path, Object data, RequestResultCallback onComplete) {
155:       this.path = path;
165:       return path;
326:       List<String> path,
331:     ListenQuerySpec query = new ListenQuerySpec(path, queryParams);
358:   public void put(List<String> path, Object data, RequestResultCallback onComplete) {
359:     putInternal(REQUEST_ACTION_PUT, path, data, /*hash=*/ null, onComplete);
364:       List<String> path, Object data, String hash, RequestResultCallback onComplete) {
365:     putInternal(REQUEST_ACTION_PUT, path, data, hash, onComplete);
369:   public void merge(List<String> path, Map<String, Object> data, RequestResultCallback onComplete) {
370:     putInternal(REQUEST_ACTION_MERGE, path, data, /*hash=*/ null, onComplete);
458:   public void unlisten(List<String> path, Map<String, Object> queryParams) {
459:     ListenQuerySpec query = new ListenQuerySpec(path, queryParams);
478:   public void onDisconnectPut(List<String> path, Object data, RequestResultCallback onComplete) {
481:       sendOnDisconnect(REQUEST_ACTION_ONDISCONNECT_PUT, path, data, onComplete);
484:           new OutstandingDisconnect(REQUEST_ACTION_ONDISCONNECT_PUT, path, data, onComplete));
495:       List<String> path, Map<String, Object> updates, final RequestResultCallback onComplete) {
498:       sendOnDisconnect(REQUEST_ACTION_ONDISCONNECT_MERGE, path, updates, onComplete);
501:           new OutstandingDisconnect(REQUEST_ACTION_ONDISCONNECT_MERGE, path, updates, onComplete));
507:   public void onDisconnectCancel(List<String> path, RequestResultCallback onComplete) {
512:       sendOnDisconnect(REQUEST_ACTION_ONDISCONNECT_CANCEL, path, null, onComplete);
515:           new OutstandingDisconnect(REQUEST_ACTION_ONDISCONNECT_CANCEL, path, null, onComplete));
675:       String action, List<String> path, Object data, final RequestResultCallback onComplete) {
677:     request.put(REQUEST_PATH, ConnectionUtils.pathToString(path));
723:     request.put(REQUEST_PATH, ConnectionUtils.pathToString(listen.query.path));
749:   private Collection<OutstandingListen> removeListens(List<String> path) {
750:     if (logger.logsDebug()) logger.debug("removing all listens at path " + path);
755:       if (query.path.equals(path)) {
774:       String pathString = (String) body.get(SERVER_DATA_UPDATE_PATH);
779:         if (logger.logsDebug()) logger.debug("ignoring empty merge for path " + pathString);
781:         List<String> path = ConnectionUtils.stringToPath(pathString);
782:         delegate.onDataUpdate(path, payloadData, isMerge, tagNumber);
785:       String pathString = (String) body.get(SERVER_DATA_UPDATE_PATH);
786:       List<String> path = ConnectionUtils.stringToPath(pathString);
793:         String startString = (String) range.get(SERVER_DATA_START_PATH);
794:         String endString = (String) range.get(SERVER_DATA_END_PATH);
801:         if (logger.logsDebug()) logger.debug("Ignoring empty range merge for path " + pathString);
803:         this.delegate.onRangeMergeUpdate(path, rangeMerges, tag);
806:       String pathString = (String) body.get(SERVER_DATA_UPDATE_PATH);
807:       List<String> path = ConnectionUtils.stringToPath(pathString);
808:       onListenRevoked(path);
820:   private void onListenRevoked(List<String> path) {
823:     Collection<OutstandingListen> listens = removeListens(path);
983:   private Map<String, Object> getPutObject(List<String> path, Object data, String hash) {
985:     request.put(REQUEST_PATH, ConnectionUtils.pathToString(path));
995:       List<String> path,
999:     Map<String, Object> request = getPutObject(path, data, hash);
1053:     request.put(REQUEST_PATH, ConnectionUtils.pathToString(listen.getQuery().path));
1068:       for (List<String> path : compoundHash.getPosts()) {
1069:         posts.add(ConnectionUtils.pathToString(path));
1146:               + ConnectionUtils.pathToString(query.path)
795:         List<String> start = startString != null ? ConnectionUtils.stringToPath(startString) : null;
796:         List<String> end = endString != null ? ConnectionUtils.stringToPath(endString) : null;
968:           disconnect.getPath(),
1073:       hash.put(REQUEST_COMPOUND_HASH_PATHS, posts);
github.com/google/caja:third_party/java/htmlparser/src/nu/validator/htmlparser/impl/AttributeName.java: [ master, ]
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/firebase/firebase-android-sdk:firebase-database/src/main/java/com/google/firebase/database/core/Repo.java: [ master, ]
733:     private Path path;
305:     Path path = new Path(pathSegments);
307:       operationLogger.debug("onDataUpdate: " + path);
310:       operationLogger.debug("onDataUpdate: " + path + " " + message);
319:           Map<Path, Node> taggedChildren = new HashMap<Path, Node>();
323:             taggedChildren.put(new Path(entry.getKey()), newChildNode);
325:           events = this.serverSyncTree.applyTaggedQueryMerge(path, taggedChildren, tag);
328:           events = this.serverSyncTree.applyTaggedQueryOverwrite(path, taggedSnap, tag);
331:         Map<Path, Node> changedChildren = new HashMap<Path, Node>();
335:           changedChildren.put(new Path(entry.getKey()), newChildNode);
337:         events = this.serverSyncTree.applyServerMerge(path, changedChildren);
340:         events = this.serverSyncTree.applyServerOverwrite(path, snap);
345:         this.rerunTransactions(path);
359:     Path path = new Path(pathSegments);
361:       operationLogger.debug("onRangeMergeUpdate: " + path);
364:       operationLogger.debug("onRangeMergeUpdate: " + path + " " + merges);
375:       events = this.serverSyncTree.applyTaggedRangeMerges(path, parsedMerges, new Tag(tagNumber));
377:       events = this.serverSyncTree.applyServerRangeMerges(path, parsedMerges);
382:       this.rerunTransactions(path);
391:       final Path path) {
394:       ChildKey last = path.getBack();
396:         ref = InternalHelpers.createReference(this, path.getParent());
398:         ref = InternalHelpers.createReference(this, path);
410:   private void ackWriteAndRerunTransactions(long writeId, Path path, DatabaseError error) {
418:         rerunTransactions(path);
425:       final Path path,
429:       operationLogger.debug("set: " + path);
432:       dataLogger.debug("set: " + path + " " + newValueUnresolved);
441:             path, newValueUnresolved, newValue, writeId, /*visible=*/ true, /*persist=*/ true);
445:         path.asList(),
451:             warnIfWriteFailed("setValue", path, error);
452:             ackWriteAndRerunTransactions(writeId, path, error);
453:             callOnComplete(onComplete, error, path);
457:     Path affectedPath = abortTransactions(path, DatabaseError.OVERRIDDEN_BY_SET);
462:       final Path path,
467:       operationLogger.debug("update: " + path);
470:       dataLogger.debug("update: " + path + " " + unParsedUpdates);
477:       callOnComplete(onComplete, null, path);
487:         this.serverSyncTree.applyUserMerge(path, updates, resolved, writeId, /*persist=*/ true);
493:         path.asList(),
499:             warnIfWriteFailed("updateChildren", path, error);
500:             ackWriteAndRerunTransactions(writeId, path, error);
501:             callOnComplete(onComplete, error, path);
505:     for (Entry<Path, Node> update : updates) {
506:       Path pathFromRoot = path.child(update.getKey());
507:       Path affectedPath = abortTransactions(pathFromRoot, DatabaseError.OVERRIDDEN_BY_SET);
519:     abortTransactions(Path.getEmptyPath(), DatabaseError.WRITE_CANCELED);
537:       final Path path, final Node newValue, final DatabaseReference.CompletionListener onComplete) {
539:         path.asList(),
545:             warnIfWriteFailed("onDisconnect().setValue", path, error);
547:               onDisconnect.remember(path, newValue);
549:             callOnComplete(onComplete, error, path);
555:       final Path path,
556:       final Map<Path, Node> newChildren,
560:         path.asList(),
566:             warnIfWriteFailed("onDisconnect().updateChildren", path, error);
568:               for (Map.Entry<Path, Node> entry : newChildren.entrySet()) {
569:                 onDisconnect.remember(path.child(entry.getKey()), entry.getValue());
572:             callOnComplete(listener, error, path);
578:       final Path path, final DatabaseReference.CompletionListener onComplete) {
580:         path.asList(),
586:               onDisconnect.forget(path);
588:             callOnComplete(onComplete, error, path);
654:     Path path = new Path(Constants.DOT_INFO, childKey);
657:       infoData.update(path, node);
658:       List<? extends Event> events = this.infoSyncTree.applyServerOverwrite(path, node);
676:         Path.getEmptyPath(),
679:           public void visitTree(Path prefixPath, Node node) {
681:             Path affectedPath = abortTransactions(prefixPath, DatabaseError.OVERRIDDEN_BY_SET);
689:   private void warnIfWriteFailed(String writeType, Path path, DatabaseError error) {
694:       operationLogger.warn(writeType + " at " + path.toString() + " failed: " + error.toString());
747:         Path path,
753:       this.path = path;
778:   public void startTransaction(Path path, final Transaction.Handler handler, boolean applyLocally) {
780:       operationLogger.debug("transaction: " + path);
783:       operationLogger.debug("transaction: " + path);
799:     DatabaseReference watchRef = InternalHelpers.createReference(this, path);
816:             path,
824:     Node currentState = this.getLatestState(path);
859:       Tree<List<TransactionData>> queueNode = transactionQueueTree.subTree(path);
877:               path,
888:   private Node getLatestState(Path path) {
889:     return this.getLatestState(path, new ArrayList<Long>());
892:   private Node getLatestState(Path path, List<Long> excudeSets) {
893:     Node state = this.serverSyncTree.calcCompleteEventCache(path, excudeSets);
939:   private void sendTransactionQueue(final List<TransactionData> queue, final Path path) {
946:     Node latestState = this.getLatestState(path, setsToIgnore);
958:       Path relativePath = Path.getRelative(path, txn.path);
969:         path.asList(),
976:             warnIfWriteFailed("Transaction", path, error);
992:                         InternalHelpers.createReference(repo, txn.path), IndexedNode.from(node));
1006:                         QuerySpec.defaultQueryAtPath(txn.path)));
1010:               pruneCompletedTransactions(transactionQueueTree.subTree(path));
1040:               rerunTransactions(path);
1078:   private Path rerunTransactions(Path changedPath) {
1080:     Path path = rootMostTransactionNode.getPath();
1083:     rerunTransactionQueue(queue, path);
1085:     return path;
1088:   private void rerunTransactionQueue(List<TransactionData> queue, Path path) {
1106:       Path relativePath = Path.getRelative(path, transaction.path);
1130:           Node currentNode = this.getLatestState(transaction.path, setsToIgnore);
1158:                     transaction.path,
1184:         final DatabaseReference ref = InternalHelpers.createReference(this, transaction.path);
1202:                         QuerySpec.defaultQueryAtPath(transaction.path)));
1229:   private Tree<List<TransactionData>> getAncestorTransactionNode(Path path) {
1231:     while (!path.isEmpty() && transactionNode.getValue() == null) {
1232:       transactionNode = transactionNode.subTree(new Path(path.getFront()));
1233:       path = path.popFront();
1264:   private Path abortTransactions(Path path, final int reason) {
1265:     Path affectedPath = getAncestorTransactionNode(path).getPath();
1269:           "Aborting transactions for path: " + path + ". Affected: " + affectedPath);
1272:     Tree<List<TransactionData>> transactionNode = transactionQueueTree.subTree(path);
1329:                   QuerySpec.defaultQueryAtPath(transaction.path)));
156:                         final Node node = infoData.getNode(query.getPath());
159:                               infoSyncTree.applyServerOverwrite(query.getPath(), node);
183:                     query.getPath().asList(),
200:                     query.getPath().asList(), query.getParams().getWireProtocolParams());
221:               warnIfWriteFailed("Persisted write", write.getPath(), error);
222:               ackWriteAndRerunTransactions(write.getWriteId(), write.getPath(), error);
234:         connection.put(write.getPath().asList(), write.getOverwrite().getValue(true), onComplete);
238:             write.getPath(),
248:         connection.merge(write.getPath().asList(), write.getMerge().getValue(true), onComplete);
252:             write.getPath(), write.getMerge(), resolved, write.getWriteId(), /*persist=*/ false);
304:       List<String> pathSegments, Object message, boolean isMerge, Long optTag) {
356:       List<String> pathSegments,
458:     this.rerunTransactions(affectedPath);
508:       rerunTransactions(affectedPath);
528:     if (Constants.DOT_INFO.equals(eventRegistration.getQuerySpec().getPath().getFront())) {
630:     ChildKey front = eventRegistration.getQuerySpec().getPath().getFront();
640:     assert query.getPath().isEmpty() || !query.getPath().getFront().equals(Constants.DOT_INFO);
680:             events.addAll(serverSyncTree.applyServerOverwrite(prefixPath, node));
682:             rerunTransactions(affectedPath);
926:         sendTransactionQueue(queue, node.getPath());
960:       snapToSend = snapToSend.updateChild(relativePath, txn.currentOutputSnapshotRaw);
1079:     Tree<List<TransactionData>> rootMostTransactionNode = getAncestorTransactionNode(changedPath);
1111:       assert relativePath != null; // rerunTransactionQueue: relativePath should not be null.
1292:     return affectedPath;
android.googlesource.com/platform/superproject:libcore/benchmarks/src/benchmarks/regression/R.java: [ master, ]
1967:     public static final int path = 0;
709:     public final int mpath = 0;
909:     public final int msearchSuggestPath = 0;
1968:     public static final int pathData = 0;
1969:     public static final int pathPattern = 0;
1970:     public static final int pathPrefix = 0;
2167:     public static final int searchSuggestPath = 0;
710:     public final int mpathData = 0;
711:     public final int mpathPattern = 0;
712:     public final int mpathPrefix = 0;
713:     public final int mpatternPathData = 0;
1171:     public final int mtrimPathEnd = 0;
1172:     public final int mtrimPathOffset = 0;
1173:     public final int mtrimPathStart = 0;
1971:     public static final int patternPathData = 0;
2429:     public static final int trimPathEnd = 0;
2430:     public static final int trimPathOffset = 0;
2431:     public static final int trimPathStart = 0;
android.googlesource.com/platform/external/universal-tween-engine:java/api/src/aurelienribon/tweenengine/Tween.java: [ master, ]
345: 	private TweenPath path;
715: 	public Tween path(TweenPath path) {
360: 	private float[] pathBuffer = new float[(2+waypointsLimit)*combinedAttrsLimit];
211: 		tween.path(TweenPaths.catmullRom);
249: 		tween.path(TweenPaths.catmullRom);
379: 		path = null;
623: 	 * Adds a waypoint to the path. The default path runs from the start values
624: 	 * to the end values linearly. If you add waypoints, the default path will
626: 	 * you can change this behavior by using the {@link #path(TweenPath)}
640: 	 * Adds a waypoint to the path. The default path runs from the start values
641: 	 * to the end values linearly. If you add waypoints, the default path will
643: 	 * you can change this behavior by using the {@link #path(TweenPath)}
662: 	 * Adds a waypoint to the path. The default path runs from the start values
663: 	 * to the end values linearly. If you add waypoints, the default path will
665: 	 * you can change this behavior by using the {@link #path(TweenPath)}
686: 	 * Adds a waypoint to the path. The default path runs from the start values
687: 	 * to the end values linearly. If you add waypoints, the default path will
689: 	 * you can change this behavior by using the {@link #path(TweenPath)}
710: 	 * @param path A TweenPath implementation.
716: 		this.path = path;
858: 		if (waypointsCnt == 0 || path == null) {
871: 				accessorBuffer[i] = path.compute(t, pathBuffer, waypointsCnt+2);
388: 		if (pathBuffer.length != (2+waypointsLimit)*combinedAttrsLimit) {
389: 			pathBuffer = new float[(2+waypointsLimit)*combinedAttrsLimit];
708: 	 * but you can find other paths in the {@link TweenPaths} class.
712: 	 * @see TweenPath
865: 				pathBuffer[0] = startValues[i];
866: 				pathBuffer[1+waypointsCnt] = targetValues[i];
868: 					pathBuffer[ii+1] = waypoints[ii*combinedAttrsCnt+i];
713: 	 * @see TweenPaths
android.googlesource.com/platform/libcore:benchmarks/src/benchmarks/regression/R.java: [ master, ] Duplicate result
chromium.googlesource.com/android_tools:sdk/sources/android-25/benchmarks/regression/R.java: [ master, ] Duplicate result
android.googlesource.com/platform/tools/idea:platform/platform-api/src/com/intellij/ui/tabs/impl/JBTabsImpl.java: [ master, ]
1878:     public ShapeTransform path;
1879:     public ShapeTransform fillPath;
1880:     public ShapeTransform labelPath;
1776:       g2d.draw(shapeInfo.path.getShape());
1793:     shape.path = getEffectiveLayout().createShapeTransform(getSize());
1794:     shape.insets = shape.path.transformInsets(getLayoutInsets());
1795:     shape.labelPath = shape.path.createTransform(getSelectedLabel().getBounds());
1814:       shape.path.moveTo(shape.insets.left, shape.labelTopY + shape.labelPath.deltaY(getEdgeArcSize()));
1815:       shape.path.quadTo(shape.labelLeftX, shape.labelTopY, shape.labelLeftX + shape.labelPath.deltaX(getEdgeArcSize()), shape.labelTopY);
1816:       shape.path.lineTo(shape.labelRightX - shape.labelPath.deltaX(getArcSize()), shape.labelTopY);
1819:       shape.path.moveTo(shape.insets.left, shape.labelBottomY);
1820:       shape.path.lineTo(shape.labelLeftX, shape.labelBottomY);
1821:       shape.path.lineTo(shape.labelLeftX, shape.labelTopY + shape.labelPath.deltaY(getArcSize()));
1822:       shape.path.quadTo(shape.labelLeftX, shape.labelTopY, shape.labelLeftX + shape.labelPath.deltaX(getArcSize()), shape.labelTopY);
1825:     int lastX = shape.path.getWidth() - shape.path.deltaX(shape.insets.right + 1);
1828:       shape.path.lineTo(lastX - shape.path.deltaX(getArcSize()), shape.labelTopY);
1829:       shape.path.quadTo(lastX, shape.labelTopY, lastX, shape.labelTopY + shape.path.deltaY(getArcSize()));
1830:       shape.path.lineTo(lastX, shape.labelBottomY);
1834:         shape.path.lineTo(shape.labelRightX + 1 - shape.path.deltaX(getArcSize()), shape.labelTopY);
1835:         shape.path.quadTo(shape.labelRightX + 1, shape.labelTopY, shape.labelRightX + 1, shape.labelTopY + shape.path.deltaY(getArcSize()));
1838:         shape.path.lineTo(shape.labelRightX - shape.path.deltaX(getArcSize()), shape.labelTopY);
1839:         shape.path.quadTo(shape.labelRightX, shape.labelTopY, shape.labelRightX, shape.labelTopY + shape.path.deltaY(getArcSize()));
1842:         shape.path.lineTo(shape.labelRightX, shape.labelBottomY - shape.path.deltaY(getArcSize()));
1843:         shape.path.quadTo(shape.labelRightX, shape.labelBottomY, shape.labelRightX + shape.path.deltaX(getArcSize()), shape.labelBottomY);
1847:           shape.path.lineTo(shape.labelRightX + 1, shape.labelBottomY);
1850:           shape.path.lineTo(shape.labelRightX, shape.labelBottomY);
1856:       shape.path.lineTo(lastX, shape.labelBottomY);
1860:       shape.path.closePath();
1863:     shape.fillPath = shape.path.copy();
1892:     final ShapeTransform path = getEffectiveLayout().createShapeTransform(mySingleRowLayout.myLastSingRowLayout.firstGhost);
1894:     int topX = path.getX() + path.deltaX(getCurveArc());
1895:     int topY = path.getY() + path.deltaY(getSelectionTabVShift());
1896:     int bottomX = path.getMaxX() + path.deltaX(1);
1897:     int bottomY = path.getMaxY() + path.deltaY(1);
1899:     path.moveTo(topX, topY);
1904:       path.lineTo(bottomX, topY);
1907:       path.lineTo(bottomX - getArcSize(), topY);
1908:       path.quadTo(bottomX, topY, bottomX, topY + path.deltaY(getArcSize()));
1911:     path.lineTo(bottomX, bottomY);
1912:     path.lineTo(topX, bottomY);
1914:     path.quadTo(topX - path.deltaX(getCurveArc() * 2 - 1), bottomY - path.deltaY(Math.abs(bottomY - topY) / 4), topX,
1915:                 bottomY - path.deltaY(Math.abs(bottomY - topY) / 2));
1917:     path.quadTo(topX + path.deltaX(getCurveArc() - 1), topY + path.deltaY(Math.abs(bottomY - topY) / 4), topX, topY);
1919:     path.closePath();
1922:     g2d.fill(path.getShape());
1925:     g2d.draw(path.getShape());
1928:     g2d.drawLine(topX + path.deltaX(1), topY + path.deltaY(1), bottomX - path.deltaX(getArcSize()), topY + path.deltaY(1));
1931:     g2d.drawLine(bottomX - path.deltaX(1), topY + path.deltaY(getArcSize()), bottomX - path.deltaX(1), bottomY - path.deltaY(1));
1935:     final ShapeTransform path = getEffectiveLayout().createShapeTransform(mySingleRowLayout.myLastSingRowLayout.lastGhost);
1937:     int topX = path.getX() - path.deltaX(getArcSize());
1938:     int topY = path.getY() + path.deltaY(getSelectionTabVShift());
1939:     int bottomX = path.getMaxX() - path.deltaX(getCurveArc());
1940:     int bottomY = path.getMaxY() + path.deltaY(1);
1942:     path.moveTo(topX, topY);
1943:     path.lineTo(bottomX, topY);
1944:     path.quadTo(bottomX - getCurveArc(), topY + (bottomY - topY) / 4, bottomX, topY + (bottomY - topY) / 2);...(0 bytes skipped)...
1945:     path.quadTo(bottomX + getCurveArc(), bottomY - (bottomY - topY) / 4, bottomX, bottomY);
1946:     path.lineTo(topX, bottomY);
1948:     path.closePath();
1951:     g2d.fill(path.getShape());
1954:     g2d.draw(path.getShape());
1957:     g2d.drawLine(topX, topY + path.deltaY(1), bottomX - path.deltaX(getCurveArc()), topY + path.deltaY(1));
2188:     final ShapeTransform shaper = shape.path.copy().reset();
2190:     final Insets paintBorder = shape.path.transformInsets(myBorder.getEffectiveBorder());
2198:     final int boundsX = shape.path.getX() + shape.path.deltaX(shape.insets.left);
2201:       isHideTabs() ? shape.path.getY() + shape.path.deltaY(shape.insets.top) : shape.labelPath.getMaxY() + shape.path.deltaY(1);
2203:     final int boundsHeight = Math.abs(shape.path.getMaxY() - boundsY) - shape.insets.bottom - paintBorder.bottom;
2204:     final int boundsWidth = Math.abs(shape.path.getMaxX() - (shape.insets.left + shape.insets.right));
2216:           tabFillColor = shape.path.transformY1(shape.to, shape.from);
2220:         g2d.fill(shaper.reset().doRect(boundsX, topY + shape.path.deltaY(1), boundsWidth, paintBorder.top - 1).getShape());
2224:           final Line2D.Float line = shape.path.transformLine(boundsX, topY, boundsX + shape.path.deltaX(boundsWidth - 1), topY);
2236:           final int topLine = topY + shape.path.deltaY(paintBorder.top - 1);
2245:     g2d.fill(shaper.reset().doRect(boundsX, Math.abs(shape.path.getMaxY() - shape.insets.bottom - paintBorder.bottom), boundsWidth,
2253:                .doRect(shape.path.getMaxX() - shape.insets.right - paintBorder.right, boundsY, paintBorder.right, boundsHeight).getSh...(7 bytes skipped)...
1710:       g2d.fill(shapeInfo.fillPath.getShape());
1727:         paintBottomY = shapeInfo.labelTopY + shapeInfo.labelPath.deltaY(getArcSize() - 2);
1758:         g2d.fill(shapeInfo.fillPath.getShape());
1762:         shapeInfo.fillPath.transformLine(shapeInfo.fillPath.getX(), paintTopY, shapeInfo.fillPath.getX(), paintBottomY);
1766:                                      shapeInfo.fillPath.transformY1(shapeInfo.from, shapeInfo.to), (float)gradientLine.getX2(),
1767:                                      (float)gradientLine.getY2(), shapeInfo.fillPath.transformY1(shapeInfo.to, shapeInfo.from)));
1768:       g2d.fill(shapeInfo.fillPath.getShape());
1797:     shape.labelBottomY = shape.labelPath.getMaxY() + shape.labelPath.deltaY(1);
1798:     shape.labelTopY = shape.labelPath.getY();
1799:     shape.labelLeftX = shape.labelPath.getX();
1800:     shape.labelRightX = shape.labelPath.getX() + shape.labelPath.deltaX(shape.labelPath.getWidth());
1865:       shape.fillPath.lineTo(lastX, shape.labelBottomY + shape.fillPath.deltaY(1));
1866:       shape.fillPath.lineTo(shape.labelLeftX, shape.labelBottomY + shape.fillPath.deltaY(1));
1867:       shape.fillPath.closePath();
2192:     int topY = shape.labelPath.getMaxY() + shape.labelPath.deltaY(1);
github.com/apache/wicket:wicket-core/src/main/java/org/apache/wicket/protocol/http/mock/MockHttpServletRequest.java: [ master, ]
141: 	private String path;
425: 	public String getContextPath()
900: 	public String getRealPath(String name)
1098: 	public String getServletPath()
1458: 	public void setPath(final String path)
805: 	public String getPathInfo()
816: 	public String getPathTranslated()
419: 	 * Get the context path. For this mock implementation the name of the application is always
422: 	 * @return The context path
800: 	 * Get the path info.
802: 	 * @return The path info
807: 		return path;
895: 	 * @return The path
976: 	 * Returns context path and servlet path concatenated, typically
979: 	 * @return The path value
1092: 	 * The servlet path may either be the application name or /. For test purposes we always return
1095: 	 * @return The servlet path
1201: 		path = null;
1453: 	 * Set the path that this request is supposed to be serving. The path is relative to the web
1456: 	 * @param path
1460: 		this.path = UrlDecoder.PATH_INSTANCE.decode(path, getCharset());
1655: 		String path = url.getPath(getCharset());
1657: 		if (path.startsWith("/") == false)
1659: 			path = getContextPath() + getServletPath() + '/' + path;
1661: 		this.url = path;
1663: 		if (path.startsWith(getContextPath()))
1665: 			path = path.substring(getContextPath().length());
1667: 		if (path.startsWith(getServletPath()))
1669: 			path = path.substring(getServletPath().length());
1672: 		setPath(path);
228: 						+ file.getAbsolutePath());
896: 	 * @deprecated Use ServletContext.getRealPath(String) instead.
902: 		return context.getRealPath(name);
987: 			return getContextPath() + getServletPath();
1011: 		buf.append(getContextPath());
1724: 		return getServletPath().substring(1);
1012: 		if (getPathInfo() != null)
1014: 			buf.append(getPathInfo());
android.googlesource.com/platform/external/cldr:tools/java/org/unicode/cldr/icu/LDMLConstants.java: [ master, ]
37:     public static final String PATH = "path";
android.googlesource.com/platform/superproject:tools/idea/platform/platform-api/src/com/intellij/ui/tabs/impl/JBTabsImpl.java: [ master, ] Duplicate result
github.com/apache/sqoop:src/java/org/apache/sqoop/io/LobFile.java: [ trunk, ]
1030:     private Path path;
1530:     private Path path;
179:     public abstract Path getPath();
242:     public abstract Path getPath();
1229:     public Path getPath() {
1641:     public Path getPath() {
52: import org.apache.hadoop.fs.Path;
100:       open(Path p, Configuration conf) throws IOException {
121:    * @param p the path to create.
128:             create(Path p, Configuration conf, boolean isCharData,
136:    * @param p the path to create.
142:             create(Path p, Configuration conf, boolean isCharData,
150:    * @param p the path to create.
155:             create(Path p, Configuration conf, boolean isCharData)
162:    * @param p the path to create.
166:             create(Path p, Configuration conf) throws IOException {
176:      * the file path it is writing to. Otherwise it returns null.
177:      * @return the fully-qualified path being written to by this writer.
239:      * the file path it is reading from. Otherwise it returns null.
240:      * @return the fully-qualified path being read by this reader.
1029:     // The path being opened.
1033:     V0Reader(Path path, Configuration conf, LobFileHeader header,
1036:       this.path = LobReaderCache.qualify(path, conf);
1044:       LOG.debug("Opening LobFile path: " + path);
1230:       return this.path;
1573:      * @param p the path to create.
1579:     V0Writer(Path p, Configuration conf, boolean isCharData,
1582:       this.path = LobReaderCache.qualify(p, conf);
1605:       FileSystem fs = this.path.getFileSystem(conf);
1606:       FSDataOutputStream fsOut = fs.create(this.path);
1642:       return this.path;
868:         // Use the normal codepath; move the serialization buffer
github.com/google/caja:third_party/java/htmlparser/src/nu/validator/htmlparser/impl/ElementName.java: [ master, ]
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,
gerrit.googlesource.com/gerrit:java/com/google/gerrit/server/query/change/ChangeQueryBuilder.java: [ master, ]
727:   public Predicate<ChangeData> path(String path) {
166:   public static final String FIELD_PATH = "path";
728:     if (path.startsWith("^")) {
729:       return new RegexPathPredicate(path);
731:     return new EqualsPathPredicate(FIELD_PATH, path);
721:       return new RegexPathPredicate(file);
android.googlesource.com/platform/superproject:external/cldr/tools/java/org/unicode/cldr/icu/LDMLConstants.java: [ master, ] Duplicate result