Search some code: Max results:

Found 30325 results in 4389 files (4005303 ngram matches, 571685 docs considered, 4387 docs (50MB) loaded, 278892 docs skipped): for
(and substr:"path" file_substr:"java") with options &zoekt.SearchOptions{EstimateDocCount:false, Whole:false, ShardMaxMatchCount:250, TotalMaxMatchCount:1000000, ShardMaxImportantMatch:2, TotalMaxImportantMatch:100, MaxWallTime:10000000000}
in 1.245888698s (queued: 2.374┬Ás)

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/bazelbuild/rules_closure:java/io/bazel/rules/closure/Webpath.java:[master, ]
64:   private final String path;
57:   public static final Webpath EMPTY_PATH = new Webpath("");
58:   public static final Webpath ROOT_PATH = new Webpath(ROOT);
50: public final class Webpath implements CharSequence, Comparable<Webpath> {
67:   private Webpath(String path) {
171:   public Webpath subpath(int beginIndex, int endIndex) {
425:   public Webpath toAbsolutePath(Webpath currentWorkingDirectory) {
431:   public Webpath toAbsolutePath() {
35:  * Web server path.
37:  * <p>This class is a de facto implementation of the {@link java.nio.file.Path} API. That interface
68:     this.path = checkNotNull(path);
71:   /** Returns new path of {@code first}. */
72:   public static Webpath get(String path) {
73:     if (path.isEmpty()) {
74:       return EMPTY_PATH;
75:     } else if (isRootInternal(path)) {
76:       return ROOT_PATH;
78:     return new Webpath(path);
83:     return isRootInternal(path);
86:   private static boolean isRootInternal(String path) {
87:     return path.length() == 1 && path.charAt(0) == SEPARATOR;
90:   /** Returns {@code true} if path starts with {@code separator}. */
92:     return isAbsoluteInternal(path);
95:   private static boolean isAbsoluteInternal(String path) {
96:     return !path.isEmpty() && path.charAt(0) == SEPARATOR;
99:   /** Returns {@code true} if path ends with {@code separator}. */
101:     return hasTrailingSeparatorInternal(path);
104:   private static boolean hasTrailingSeparatorInternal(CharSequence path) {
105:     return path.length() != 0 && path.charAt(path.length() - 1) == SEPARATOR;
108:   /** Returns {@code true} if path ends with a trailing slash, or would after normalization. */
110:     int length = path.length();
111:     return path.isEmpty()
112:         || path.charAt(length - 1) == SEPARATOR
113:         || (path.endsWith(".") && (length == 1 || path.charAt(length - 2) == SEPARATOR))
114:         || (path.endsWith("..") && (length == 2 || path.charAt(length - 3) == SEPARATOR));
118:    * Returns last component in {@code path}.
120:    * @see java.nio.file.Path#getFileName()
124:     if (path.isEmpty()) {
125:       return EMPTY_PATH;
131:       return parts.size() == 1 && path.equals(last) ? this : new Webpath(last);
138:    * @see java.nio.file.Path#getParent()
142:     if (path.isEmpty() || isRoot()) {
147:             ? path.lastIndexOf(SEPARATOR, path.length() - 2)
148:             : path.lastIndexOf(SEPARATOR);
150:       return isAbsolute() ? ROOT_PATH : null;
152:       return new Webpath(path.substring(0, index + 1));
157:    * Returns root component if an absolute path, otherwise {@code null}.
159:    * @see java.nio.file.Path#getRoot()
163:     return isAbsolute() ? ROOT_PATH : null;
167:    * Returns specified range of sub-components in path joined together.
169:    * @see java.nio.file.Path#subpath(int, int)
172:     if (path.isEmpty() && beginIndex == 0 && endIndex == 1) {
186:    * Returns number of components in {@code path}.
188:    * @see java.nio.file.Path#getNameCount()
191:     if (path.isEmpty()) {
201:    * Returns component in {@code path} at {@code index}.
203:    * @see java.nio.file.Path#getName(int)
206:     if (path.isEmpty()) {
218:    * Returns path without extra separators or {@code .} and {@code ..}, preserving trailing slash.
220:    * @see java.nio.file.Path#normalize()
229:       index = path.indexOf(SEPARATOR, mark);
230:       String part = path.substring(mark, index == -1 ? path.length() : index + 1);
281:    * Returns {@code other} appended to {@code path}.
283:    * @see java.nio.file.Path#resolve(java.nio.file.Path)
286:     if (other.path.isEmpty()) {
291:       return new Webpath(path + other.path);
293:       return new Webpath(path + SEPARATOR + other.path);
298:    * Returns {@code other} resolved against parent of {@code path}.
300:    * @see java.nio.file.Path#resolveSibling(java.nio.file.Path)
308:   /** Returns absolute path of {@code reference} relative to {@code file}. */
314:    * Returns {@code other} made relative to {@code path}.
316:    * @see java.nio.file.Path#relativize(java.nio.file.Path)
319:     checkArgument(isAbsolute() == other.isAbsolute(), "'other' is different type of Path");
320:     if (path.isEmpty()) {
332:     StringBuilder result = new StringBuilder(path.length() + other.path.length());
349:    * Returns {@code true} if {@code path} starts with {@code other}.
351:    * @see java.nio.file.Path#startsWith(java.nio.file.Path)
356:     if (other.path.length() > me.path.length()) {
360:     } else if (!me.path.isEmpty() && other.path.isEmpty()) {
376:    * Returns {@code true} if {@code path} ends with {@code other}.
378:    * @see java.nio.file.Path#endsWith(java.nio.file.Path)
383:     if (other.path.length() > me.path.length()) {
385:     } else if (!me.path.isEmpty() && other.path.isEmpty()) {
388:       return me.isAbsolute() && me.path.equals(other.path);
396:    * @see java.nio.file.Path#compareTo(java.nio.file.Path)
424:   /** Converts relative path to an absolute path. */
430:   /** Returns {@code toAbsolutePath(ROOT_PATH)}. */
432:     return toAbsolutePath(ROOT_PATH);
435:   /** Removes beginning separator from path, if an absolute path. */
437:     return isAbsolute() ? new Webpath(path.substring(1)) : this;
440:   /** Adds trailing separator to path, if it isn't present. */
442:     return hasTrailingSeparator() ? this : new Webpath(path + SEPARATOR);
445:   /** Removes trailing separator from path, unless it's root. */
448:       return new Webpath(path.substring(0, path.length() - 1));
454:   /** Splits path into components, excluding separators and empty strings. */
459:   /** Splits path into components in reverse, excluding separators and empty strings. */
474:   /** Returns path as a string. */
477:     return path;
482:     return path.length();
487:     return path.charAt(index);
492:     return path.subSequence(start, end);
495:   /** Returns {@code true} if this path is an empty string. */
497:     return path.isEmpty();
500:   /** Returns list of path components, excluding slashes. */
506:             path.isEmpty() || isRoot()
508:                 : SPLITTER.splitToList(path));
38:  * is not formally implemented because it would not be desirable to have web paths accidentally
39:  * intermingle with file system paths.
41:  * <p>This implementation is almost identical to {@code sun.nio.fs.UnixPath}. The main difference is
123:   public Webpath getFileName() {
141:   public Webpath getParent() {
162:   public Webpath getRoot() {
182:     return new Webpath(JOINER.join(subList));
205:   public Webpath getName(int index) {
211:       return new Webpath(getParts().get(index));
222:   public Webpath normalize() {
277:     return new Webpath(result.toString());
285:   public Webpath resolve(Webpath other) {
302:   public Webpath resolveSibling(Webpath other) {
304:     Webpath parent = getParent();
309:   public Webpath lookup(Webpath reference) {
318:   public Webpath relativize(Webpath other) {
345:     return new Webpath(result.toString());
353:   public boolean startsWith(Webpath other) {
354:     Webpath me = removeTrailingSeparator();
380:   public boolean endsWith(Webpath other) {
381:     Webpath me = removeTrailingSeparator();
394:    * Compares two paths lexicographically for ordering.
399:   public int compareTo(Webpath other) {
436:   public Webpath removeBeginningSeparator() {
441:   public Webpath addTrailingSeparator() {
446:   public Webpath removeTrailingSeparator() {
466:     return this == other || (other instanceof Webpath && compareTo((Webpath) other) == 0);
android.googlesource.com/platform/gdk:samples/PhotoEditor/src/com/android/photoeditor/actions/ColorPath.java:[master, ]
30:     private final Path path;
37:     public Path path() {
27: public class ColorPath {
32:     public ColorPath(int color, Path path) {
22: import android.graphics.Path;
25:  * Colored path that could be painted on canvas.
34:         this.path = path;
38:         return path;
43:         canvas.drawPath(path, paint);
47:      * Creates a paint to draw color paths.
github.com/bazelbuild/e4b:com.google.devtools.bazel.e4b/src/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;
29: 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";
30: import org.eclipse.jdt.core.IClasspathContainer;
31: 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/bazelbuild/eclipse:com.google.devtools.bazel.e4b/src/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;
29: 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";
30: import org.eclipse.jdt.core.IClasspathContainer;
31: 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/datanucleus-appengine:testing/selenium-core/xpath/javascript-xpath-0.1.8.js:[master, ]
645: UnionExpr.prototype.path = function(path) {
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));
74: var PathExpr;
600:     this.paths = [];
609:     expr = PathExpr.parse(lexer);
635:     var paths = this.paths;
637:     for (var i = 0, l = paths.length; i < l; i ++) {
638:         var exrs = paths[i].evaluate(ctx);
639:         if (!exrs.isNodeSet) throw Error('PathExpr must be nodeset');
660:     for (var i = 0; i < this.paths.length; i ++) {
661:         t += this.paths[i].show(indent);
668:  * class: PathExpr
670: if (!window.PathExpr && window.defaultConfig)
671:     window.PathExpr = null;
683: PathExpr.ops = { '//': 1, '/': 1 };
685: PathExpr.parse = function(lexer) {
731: PathExpr.prototype = new BaseExpr();
733: PathExpr.prototype.evaluate = function(ctx) {
786: PathExpr.prototype.step = function(op, step) {
803: PathExpr.prototype.show = function(indent) {
1013:             // fix for "xpath href with spaces" (http://jira.openqa.org/browse/SEL-347)   
2273:         return node.__jsxpath_id__ || (node.__jsxpath_id__ = this.uuid++);
2769:     win.XPathExpression.prototype.evaluate = function(node, type) {
2770:         return new win.XPathResult(this.expr.evaluate(new Ctx(node)), type);
2807:     win.XPathResult.prototype.iterateNext = function() { return this.nodes[this.index++] };
2808:     win.XPathResult.prototype.snapshotItem = function(i) { return this.nodes[i] };
2810:     win.XPathResult.ANY_TYPE = 0;
2811:     win.XPathResult.NUMBER_TYPE = 1;
2812:     win.XPathResult.STRING_TYPE = 2;
2813:     win.XPathResult.BOOLEAN_TYPE = 3;
2814:     win.XPathResult.UNORDERED_NODE_ITERATOR_TYPE = 4;
2815:     win.XPathResult.ORDERED_NODE_ITERATOR_TYPE = 5;
2816:     win.XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE = 6;
2817:     win.XPathResult.ORDERED_NODE_SNAPSHOT_TYPE = 7;
2818:     win.XPathResult.ANY_UNORDERED_NODE_TYPE = 8;
2819:     win.XPathResult.FIRST_ORDERED_NODE_TYPE = 9;
2823:         return new win.XPathExpression(expr, null);
github.com/google/kythe:kythe/java/com/google/devtools/kythe/analyzers/base/CorpusPath.java:[master, ]
23:   private final String corpus, root, path;
22: public final class CorpusPath {
25:   public CorpusPath(String corpus, String root, String path) {
47:   public String getPath() {
21: /** Path within a particular corpus and corpus root. */
28:     this.path = path;
32:    * Returns a new {@link CorpusPath} equivalent to the corpus/path/root subset of the given {@link
48:     return path;
35:   public static CorpusPath fromVName(VName vname) {
36:     return new CorpusPath(vname.getCorpus(), vname.getRoot(), vname.getPath());
github.com/google/climb-tracker:climblib/src/main/java/fr/steren/climblib/Path.java:[master, ]
15: public class Path {
github.com/google/copybara:java/com/google/copybara/CheckoutPathAttributes.java:[master, ]
35:   private final Path path;
33: public class CheckoutPathAttributes {
38:   CheckoutPathAttributes(Path path, BasicFileAttributes attributes) {
24: import java.nio.file.Path;
32:     doc = "Represents a path attributes like size.")
39:     this.path = Preconditions.checkNotNull(path);
51:           String.format("File %s is too big to compute the size: %d bytes", path, size));
31: @SkylarkModule(name = "PathAttributes", category = SkylarkModuleCategory.BUILTIN,
github.com/google/copybara:java/com/google/copybara/CheckoutPath.java:[master, ]
46:   private final Path path;
42: public class CheckoutPath implements Comparable<CheckoutPath>{
49:   CheckoutPath(Path path, Path checkoutDir) {
68:   public String fullPath() {
28: import java.nio.file.Path;
39: @SkylarkModule(name = "Path",
41:     doc = "Represents a path in the checkout directory")
47:   private final Path checkoutDir;
50:     this.path = Preconditions.checkNotNull(path);
54:   private CheckoutPath create(Path path) throws FuncallException {
55:     return createWithCheckoutDir(path, checkoutDir);
58:   static CheckoutPath createWithCheckoutDir(Path relative, Path checkoutDir)
66:   @SkylarkCallable(name = "path", doc = "Full path relative to the checkout directory",
69:     return path.toString();
73:       doc = "Filename of the path. For foo/bar/baz.txt it would be baz.txt",
76:     return path.getFileName().toString();
79:   @SkylarkCallable(name = "parent", doc = "Get the parent path", structField = true,
82:     Path parent = path.getParent();
84:       // nio equivalent of new_path("foo").parent returns null, but we want to be able to do
86:       // to return the parent folder and another function resolve a path based on that.
87:       return path.toString().equals("")
89:           : create(path.getFileSystem().getPath(""));
95:       doc = "Constructs a relative path between this path and a given path. For example:<br>"
96:           + "    path('a/b').relativize('a/b/c/d')<br>"
100:               doc = "The path to relativize against this path"),
103:     return create(path.relativize(other.path));
107:       doc = "Resolve the given path against this path.",
110:               doc = "Resolve the given path against this path. The parameter"
111:                   + " can be a string or a Path.")})
114:       return create(path.resolve((String) child));
116:       return create(path.resolve(((CheckoutPath) child).path));
123:       doc = "Resolve the given path against this path.",
126:               doc = "Resolve the given path against this path. The parameter can be a string or"
127:                   + " a Path."),})
130:       return create(path.resolveSibling((String) other));
132:       return create(path.resolveSibling(((CheckoutPath) other).path));
142:       return new CheckoutPathAttributes(path,
143:           Files.readAttributes(checkoutDir.resolve(path), BasicFileAttributes.class));
145:       String msg = "Error getting attributes for " + path + ":" + e;
153:     return path.toString();
158:     return this.path.compareTo(o.path);
44:   private static final Logger logger = Logger.getLogger(CheckoutPath.class.getName());
61:       throw new FuncallException("Absolute paths are not allowed: " + relative);
63:     return new CheckoutPath(relative.normalize(), checkoutDir);
99:           @Param(name = "other", type = CheckoutPath.class,
102:   public CheckoutPath relativize(CheckoutPath other) throws FuncallException {
112:   public CheckoutPath resolve(Object child) throws FuncallException {
115:     } else if (child instanceof CheckoutPath) {
128:   public CheckoutPath resolveSibling(Object other) throws FuncallException {
131:     } else if (other instanceof CheckoutPath) {
157:   public int compareTo(CheckoutPath o) {
140:   public CheckoutPathAttributes attr() throws FuncallException {
github.com/foam-framework/foam:tools/genjava.js:[master, ]
23: var path = require('path');
38:     pathComponents
github.com/google/FreeBuilder:src/test/java/org/inferred/freebuilder/processor/util/testing/TempJavaFileManager.java:[master, ]
71:     private final String path;
218:   private static String path(String packageName, String relativeName) {
67:       return new FileKey(location, path(packageName, relativeName));
73:     private FileKey(Location location, String path) {
75:       this.path = path;
83:       return path;
89:       fields.add("path", path);
github.com/googlei18n/sfntly:java/test/com/google/typography/font/sfntly/testutils/TestFont.java:[master, ]
39:     private String path;
32:   private static final String TESTDATA_PATH = "../data/testdata/";
41:     private TestFontNames(String path) {
42:       this.path = path;
46:       return new File(TESTDATA_PATH + path);
android.googlesource.com/platform/external/archive-patcher:shared/src/test/java/com/google/archivepatcher/shared/UnitTestZipEntry.java:[master, ]
29:   public final String path;
27:    * The path under which the data is located in the archive.
53:    * @param path the path under which the data is located in the archive
58:   public UnitTestZipEntry(String path, int level, String content, String comment) {
59:     this(path, level, true, content, comment);
64:    * @param path the path under which the data is located in the archive
69:   public UnitTestZipEntry(String path, int level, boolean nowrap, String content, String comment) {
70:     this.path = path;
github.com/google/truth:extensions/proto/src/main/java/com/google/common/truth/extensions/proto/ProtoSubject.java:[master, ]
281:     abstract ImmutableList<SpecificField> path();
188:         ReportType type, Message message1, Message message2, ImmutableList<SpecificField> path) {
189:       ReporterRecord record = ReporterRecord.of(type, message1, message2, path);
210:                 record.type(), record.message1(), record.message2(), record.path());
219:                 record.type(), record.message1(), record.message2(), record.path());
229:                   record.type(), record.message1(), record.message2(), record.path());
257:           streamReporter.report(record.type(), record.message1(), record.message2(), record.path());
291:         ReportType type, Message message1, Message message2, ImmutableList<SpecificField> path) {
292:       return new AutoValue_ProtoSubject_ReporterRecord(type, message1, message2, path);
github.com/google/u2f-ref-code:u2f-ref-code/java/src/com/google/u2f/tools/httpserver/servlets/StaticHandler.java:[master, ]
23:   private final String path;
25:   public StaticHandler(String mimeType, String path) {
27:     this.path = path;
33:       InputStream inputStream = new BufferedInputStream(new FileInputStream(path));
github.com/google/ExoPlayer:library/src/main/java/com/google/android/exoplayer2/util/UriUtil.java:[release-v2, ]
46:   private static final int PATH = 1;
41:    * The value at this position in the array is the index of the path part. Equals (schemeColon + 1)
43:    * (query) if no path part. The characters starting at this index can be "//" only if the
95:       removeDotSegments(uri, refIndices[PATH], refIndices[QUERY]);
112:     if (refIndices[PATH] != 0) {
116:       return removeDotSegments(uri, baseLimit + refIndices[PATH], baseLimit + refIndices[QUERY]);
119:     if (referenceUri.charAt(refIndices[PATH]) == '/') {
120:       // The reference path is rooted. The target is the base scheme and authority (if any), plus
122:       uri.append(baseUri, 0, baseIndices[PATH]).append(referenceUri);
123:       return removeDotSegments(uri, baseIndices[PATH], baseIndices[PATH] + refIndices[QUERY]);
128:     if (baseIndices[SCHEME_COLON] + 2 < baseIndices[PATH]
129:         && baseIndices[PATH] == baseIndices[QUERY]) {
130:       // Case 1: The base hier-part is just the authority, with an empty path. An additional '/' is
132:       uri.append(baseUri, 0, baseIndices[PATH]).append('/').append(referenceUri);
133:       return removeDotSegments(uri, baseIndices[PATH], baseIndices[PATH] + refIndices[QUERY] + 1);
140:       int baseLimit = lastSlashIndex == -1 ? baseIndices[PATH] : lastSlashIndex + 1;
142:       return removeDotSegments(uri, baseIndices[PATH], baseLimit + refIndices[QUERY]);
147:    * Removes dot segments from the path of a URI.
150:    * @param offset The index of the start of the path in {@code uri}.
151:    * @param limit The limit (exclusive) of the path in {@code uri}.
159:       // If the path starts with a /, always retain it.
162:     // The first character of the current path segment.
175:       // We've encountered the end of a segment or the end of the path. If the final segment was
176:       // "." or "..", remove the appropriate segments of the path.
236:     // Determine hier-part structure: hier-part = "//" authority path / path
252:     indices[PATH] = pathIndex;
241:     int pathIndex;
243:       pathIndex = uriString.indexOf('/', schemeIndex + 3); // find first '/' after "://"
244:       if (pathIndex == -1 || pathIndex > queryIndex) {
245:         pathIndex = queryIndex;
248:       pathIndex = schemeIndex + 1;
github.com/vanadium/baku:permissions/app/src/main/java/examples/baku/io/permissions/Blessing.java:[master, ]
298:         String path;
126:     public int getPermissions(String path) {
127:         return permissionTree.getPermissions(path);
203:     public Blessing setPermissions(String path, int permissions) {
204:         this.permissions.put(path, permissions);
205:         getRef(path).setPermission(permissions);
215:     public Blessing clearPermissions(String path) {
216:         getRef(path).clearPermission();
217:         this.permissions.remove(path);
233:     //delete all permission above path
234:     public Blessing revokePermissions(String path) {
235:         if (path != null) {
236:             rulesRef.child(path).removeValue();
243:     private PermissionReference getRef(String path) {
244:         return new PermissionReference(rulesRef, path);
307:         public Permission(DataSnapshot snapshot, String path, int inherited) {
308:             this.path = path;
309:             if (path != null) {
321:                 if (path != null) {
322:                     childPath = path + "/" + childPath;
331:             result.path = path;
372:                 permission.permissions &= ref.getPermissions(permission.path);
374:             setInherited(inherited & ref.getPermissions(path));
378:         public Permission child(String path) {
379:             int index = path.indexOf("/");
381:                 return this.children.get(path);
383:             Permission child = this.children.get(path.substring(0, index));
384:             if (child != null && path.length() - index > 1) {
385:                 return child.child(path.substring(index));
450:                 permissionA = rules.get(permissionB.path);
451:                 permissionA.addPermissions(tree.getPermissions(permissionB.path));
453:                     if (rules.containsKey(child.path)) {
468:                 rules.put(permission.path, permission);
472:         public Permission get(String path) {
473:             return rules.get(path);
476:         public int getPermissions(String path) {
477:             path = Utils.getNearestCommonAncestor(path, keySet());
478:             Permission permission = get(path);
484:                 result &= parentTree.getPermissions(path);
320:                 String childPath = child.getKey();
324:                 children.put(child.getKey(), new Permission(child, childPath, this.permissions | this.inherited));
401:             final Stack<String> pathStack = new Stack<>();
402:             pathStack.push(null); //default rule
android.googlesource.com/platform/packages/services/BuiltInPrintService:src/com/android/bips/discovery/DiscoveredPrinter.java:[master, ]
46:     public final Uri path;
45:     /** Resource path at which the print service can be reached */
56:      * @param path     Network path at which the printer is currently available
59:     public DiscoveredPrinter(Uri uuid, String name, Uri path, String location) {
62:         this.path = path;
69:         Uri uuid = null, path = null;
81:                 case "path":
82:                     path = Uri.parse(reader.nextString());
91:         if (printerName == null || path == null) throw new IOException("Missing name or path");
94:         this.path = path;
100:      * from the path (if UUID is missing)
103:         return uuid != null ? uuid : path;
106:     /** Return a generated printer ID based on uuid or (if uuid is missing) its path */
116:         String host = path.getHost().replaceAll(":[0-9]+", "");
130:         writer.name("path").value(path.toString());
146:                 Objects.equals(path, other.path) &&
155:         result = 31 * result + path.hashCode();
android.googlesource.com/platform/external/mockwebserver:src/main/java/com/google/mockwebserver/RecordedRequest.java:[master, ]
36:     private final String path;
103:     public String getPath() {
88:             this.path = requestLine.substring(methodEnd + 1, pathEnd);
91:             this.path = null;
104:         return path;
86:             int pathEnd = requestLine.indexOf(' ', methodEnd + 1);
android.googlesource.com/platform/external/jcommander:src/test/java/com/beust/jcommander/ValidatePropertiesWhenParsingTest.java:[master, ]
29:     private String path = "W";
36:     private String path = "W";
18:   public static class MyPathValidator implements IParameterValidator {
15:     cmd.parse(new String[] { "a", "-path", "myPathToHappiness" });
28:     @Parameter(names = "-path")
35:     @Parameter(names = "-path", validateWith = MyPathValidator.class)
github.com/googleads/googleads-java-lib:modules/dfp_axis/src/main/java/com/google/api/ads/dfp/axis/v201702/SuggestedAdUnit.java:[master, ]
56:     private java.lang.String[] path;
70:     private com.google.api.ads.dfp.axis.v201702.AdUnitParent[] parentPath;
180:     public java.lang.String[] getPath() {
195:     public void setPath(java.lang.String[] path) {
199:     public java.lang.String getPath(int i) {
203:     public void setPath(int i, java.lang.String _value) {
224:     public com.google.api.ads.dfp.axis.v201702.AdUnitParent[] getParentPath() {
245:     public void setParentPath(com.google.api.ads.dfp.axis.v201702.AdUnitParent[] parentPath) {
249:     public com.google.api.ads.dfp.axis.v201702.AdUnitParent getParentPath(int i) {
253:     public void setParentPath(int i, com.google.api.ads.dfp.axis.v201702.AdUnitParent _value) {
36:      * is the complete path to the suggested ad
37:      *                 unit with path elements separated by '/' characters.
50:     /* The hierarchical path from the {@link #parentPath last existing
53:      * path element is a separate ad unit code in
58:     /* The existing hierarchical path leading up to, and including,
61:      * and the {@code path} make up the full
62:      *                 path of the suggested ad unit after it is approved.
93:            java.lang.String[] path,
100:            this.path = path;
114:      * is the complete path to the suggested ad
115:      *                 unit with path elements separated by '/' characters.
130:      * is the complete path to the suggested ad
131:      *                 unit with path elements separated by '/' characters.
171:      * Gets the path value for this SuggestedAdUnit.
173:      * @return path   * The hierarchical path from the {@link #parentPath last existing
176:      * path element is a separate ad unit code in
181:         return path;
186:      * Sets the path value for this SuggestedAdUnit.
188:      * @param path   * The hierarchical path from the {@link #parentPath last existing
191:      * path element is a separate ad unit code in
196:         this.path = path;
200:         return this.path[i];
204:         this.path[i] = _value;
211:      * @return parentPath   * The existing hierarchical path leading up to, and including,
214:      * and the {@code path} make up the full
215:      *                 path of the suggested ad unit after it is approved.
232:      * @param parentPath   * The existing hierarchical path leading up to, and including,
235:      * and the {@code path} make up the full
236:      *                 path of the suggested ad unit after it is approved.
355:             ((this.path==null && other.getPath()==null) || 
356:              (this.path!=null &&
357:               java.util.Arrays.equals(this.path, other.getPath()))) &&
451:         elemField.setFieldName("path");
452:         elemField.setXmlName(new javax.xml.namespace.QName("https://www.google.com/apis/ads/publisher/v201702", "path"));
60:      *                 ad unit in the ad unit hierarchy. The {@code parentPath}
94:            com.google.api.ads.dfp.axis.v201702.AdUnitParent[] parentPath,
101:            this.parentPath = parentPath;
209:      * Gets the parentPath value for this SuggestedAdUnit.
213:      *                 ad unit in the ad unit hierarchy. The {@code parentPath}
225:         return parentPath;
230:      * Sets the parentPath value for this SuggestedAdUnit.
234:      *                 ad unit in the ad unit hierarchy. The {@code parentPath}
246:         this.parentPath = parentPath;
250:         return this.parentPath[i];
254:         this.parentPath[i] = _value;
358:             ((this.parentPath==null && other.getParentPath()==null) || 
359:              (this.parentPath!=null &&
360:               java.util.Arrays.equals(this.parentPath, other.getParentPath()))) &&
387:         if (getPath() != null) {
389:                  i<java.lang.reflect.Array.getLength(getPath());
391:                 java.lang.Object obj = java.lang.reflect.Array.get(getPath(), i);
398:         if (getParentPath() != null) {
400:                  i<java.lang.reflect.Array.getLength(getParentPath());
402:                 java.lang.Object obj = java.lang.reflect.Array.get(getParentPath(), i);
459:         elemField.setFieldName("parentPath");
460:         elemField.setXmlName(new javax.xml.namespace.QName("https://www.google.com/apis/ads/publisher/v201702", "parentPath"));
android.googlesource.com/platform/frameworks/ex:common/java/com/android/common/content/SyncStateContentProviderHelper.java:[master, ]
47:     public static final String PATH = "syncstate";
github.com/vanadium/reader:android/common/src/main/java/io/v/android/apps/reader/PageControlMessage.java:[master, ]
13:     public static final String PATH = "/page-control";
github.com/googlesamples/android-SpeedTracker:Shared/src/main/java/com/example/android/wearable/speedtracker/common/Constants.java:[master, ]
24:     public static final String PATH = "/location";
android.googlesource.com/platform/packages/providers/ContactsProvider:src/com/android/providers/contacts/PhotoStore.java:[master, ]
289:         public final String path;
56:     private final File mStorePath;
55:     /** The file path for photo storage. */
288:         /** The path to the file. */
294:             path = file.getAbsolutePath();
70:         mStorePath = new File(rootDirectory, DIRECTORY);
72:             if (!mStorePath.exists()) {
73:                 if (!mStorePath.mkdirs()) {
75:                             + mStorePath.getPath());
88:         File[] files = mStorePath.listFiles();
119:         File[] files = mStorePath.listFiles();
198:                 file = File.createTempFile("img", null, mStorePath);
233:             Log.d("Could not clean up file %s", file.getAbsolutePath());
249:         return new File(mStorePath, String.valueOf(id));
github.com/google/earthengine-api:javascript/src/examples/Image/DownloadExample.js:[master, ]
6: var path = image.getDownloadURL({
11: print(path);
android.googlesource.com/platform/packages/providers/DownloadProvider:src/com/android/providers/downloads/DownloadScanner.java:[master, ]
52:         public final String path;
56:         public ScanRequest(long id, String path, String mimeType) {
58:             this.path = path;
64:             conn.scanFile(path, mimeType);
82:     public static void requestScanBlocking(Context context, long id, String path, String mimeType) {
85:         scanner.requestScan(new ScanRequest(id, path, mimeType));
123:         if (LOGV) Log.v(TAG, "requestScan() for " + req.path);
125:             mPending.put(req.path, req);
149:     public void onScanCompleted(String path, Uri uri) {
152:             req = mPending.remove(path);
155:             Log.w(TAG, "Missing request for path " + path);
github.com/MobileChromeApps/cordova-plugin-chrome-apps-system-storage:src/android/ChromeSystemStorage.java:[master, ]
36:         public File path;
28:     private static final String DATA_STORAGE_PATH = "StoragePath";
156:     private String getExternalStoragePath(String unitId) {
202:     private StorageFile getExternalStorageDirectoryByPath(String path, StorageFile[] directories) {
290:     private static String getBaseStoragePath(File directory) {
294:     private static String getBaseStoragePath(String fullPath) {
39:         public StorageFile(File path, String type) {
40:             this.path = path;
72:                 event.getData().putString(DATA_STORAGE_PATH, intent.getDataString());
81:                 // Sanitize the path provided with the event
82:                 String storagePath = getBaseStoragePath(Uri.parse(event.getData().getString(DATA_STORAGE_PATH)).getPath());
157:         // The unit ids are stored in the map where key = path, value = id,
171:         String path = getExternalStoragePath(unitId);
173:         return (path != null);
177:         String path = getExternalStoragePath(unitId);
179:         if (path == null) {
193:             // to have two external storage directories, whose path differs only by case
194:             if (getBaseStoragePath(storage).equalsIgnoreCase(path)) {
209:             if (getBaseStoragePath(storage.path).equalsIgnoreCase(path)) {
282:         String shortPath = getBaseStoragePath(directory.path);
284:         // Get the id based on the path for the directory
287:         return buildStorageUnitInfo(id, directory.path, directory.type, shortPath);
296:         // We want to use a shorter, more generic path
91:                 String unitId = plugin.getExternalStorageId(storagePath);
94:                     attachedStorage = plugin.getExternalStorageDirectoryByPath(storagePath, directories);
137:     private String getExternalStorageId(String storagePath) {
138:         return externalStorageIds.get(storagePath);
218:         // Setup the mapping from external storage paths to unit ids.  According to the
249:             String storagePath = getBaseStoragePath(storage);
251:             if (externalStorageIds.containsKey(storagePath)) {
256:             externalStorageIds.put(storagePath, id);
285:         String id = getExternalStorageId(shortPath);
291:         return getBaseStoragePath(directory.getAbsolutePath());
295:         // The generated storage paths will typically be an app-specific directory to store files
297:         int pos = fullPath.indexOf("/Android/data");
300:             return fullPath.substring(0, pos);
302:         return fullPath;
github.com/angular/protractor-cookbook:protractor-javascript/example-screenshot/screenshotReporter.js:[master, ]
3: var path = require('path');
8:   dir = path.join(dir, new Date().toISOString());
11:   // base function to take a screenshot -- change path as needed
17:       var stream = fs.createWriteStream(path.join(dir, fname));
gerrit.googlesource.com/plugins/owners:owners-common/src/main/java/com/vmware/gerrit/owners/common/Matcher.java:[master, ]
23:   protected String path;
43:   public void setPath(String path) {
48:   public String getPath() {
26:     this.path = key;
32:     return "Matcher [path=" + path + ", owners=" + owners + "]";
44:     this.path = path;
49:     return path;
52:   abstract public boolean matches(String pathToMatch);
gerrit.googlesource.com/plugins/hooks:src/main/java/com/googlesource/gerrit/plugins/hooks/Hook.java:[master, ]
20:   protected final Path path;
17: import java.nio.file.Path;
22:   Hook(Path path) {
23:     this.path = path;
android.googlesource.com/platform/packages/apps/Camera2:src/com/android/camera/MediaSaverImpl.java:[master, ]
205:         private String path;
110:     public void addVideo(String path, ContentValues values, OnMediaSavedListener l) {
113:         new VideoSaveTask(path, values, l, mContentResolver).execute();
210:         public VideoSaveTask(String path, ContentValues values, OnMediaSavedListener l,
212:             this.path = path;
230:                 if (new File(path).renameTo(finalFile)) {
231:                     path = finalName;
github.com/google/perf_data_converter:third_party/protobuf/java/compatibility_tests/v2.5.0/protos/src/proto/google/protobuf/descriptor.proto:[master, ]
574:     repeated int32 path = 1 [packed=true];
520:   //   span   path               represents
532:   //   have an outer location whose path refers to the "extensions" repeated
534:   // - Multiple locations may have the same path.  This happens when a single
537:   //   extend blocks in the same scope, each of which will have the same path.
554:     // Each element is a field number or an index.  They form a path from
556:     // example, this path:
569:     // Thus, the above path gives the location of a field name.  If we removed
572:     // this path refers to the whole field declaration (from the beginning
github.com/google/perf_data_converter:third_party/protobuf/java/compatibility_tests/v2.5.0/more_protos/src/proto/google/protobuf/descriptor.proto:[master, ]
574:     repeated int32 path = 1 [packed=true];
520:   //   span   path               represents
532:   //   have an outer location whose path refers to the "extensions" repeated
534:   // - Multiple locations may have the same path.  This happens when a single
537:   //   extend blocks in the same scope, each of which will have the same path.
554:     // Each element is a field number or an index.  They form a path from
556:     // example, this path:
569:     // Thus, the above path gives the location of a field name.  If we removed
572:     // this path refers to the whole field declaration (from the beginning
github.com/fuchsia-mirror/third_party-skia:platform_tools/android/apps/canvasproof/src/main/java/org/skia/canvasproof/CanvasProofActivity.java:[master, ]
35:         public String path;
54:     private void getAssetPaths() {
74:             String path = directory + File.separator + resources[i];
76:             this.assets[i].path = path;
78:                 this.assets[i].ptr = CreateSkiaPicture.create(mgr.open(path));
80:                     Log.e(TAG, "CreateSkiaPicture.create returned 0 " + path);
82:                 Picture p = CanvasProofActivity.ReadPicture(mgr.open(path));
85:                           "returned null " + path);
88:                           "empty picture" + path);
93:                 Log.e(TAG, "IOException in getAssetPaths " + path + e);
62:             Log.e(TAG, "IOException in getAssetPaths", e);
159:         this.getAssetPaths();
github.com/google/ideal:bootstrapped/ideal/runtime/resources/base_resource_identifier.java:[master, ]
13:   private final immutable_list<string> path;
14:   public base_resource_identifier(final resource_store the_resource_store, final immutable_list<string> path) {
16:     this.path = path;
19:     final int parent_path_size = path.size() - 1;
20:     if (parent_path_size >= 0) {
21:       final immutable_list<string> parent_path = path.slice(0, parent_path_size);
22:       return new base_resource_identifier(the_resource_store, path.slice(0, parent_path_size));
28:     return the_resource_store.exists(path);
37:     return the_resource_store.build_name(path);
50:       return the_identifier.the_resource_store.read_string(the_identifier.path);
53:       if (options instanceof make_catalog_option && the_identifier.path.size() > 1) {
54:         the_identifier.the_resource_store.make_catalog(the_identifier.parent().path);
56:       the_identifier.the_resource_store.write_string(the_identifier.path, new_value);
68:       return new base_resource_catalog(the_identifier.the_resource_store, the_identifier.path);
github.com/google/ideal:bootstrapped/ideal/runtime/resources/base_resource_catalog.java:[master, ]
16:   private final immutable_list<string> path;
14:   private static final pattern<Character> path_separator = new singleton_pattern<Character>('/');
17:   protected base_resource_catalog(final resource_store the_resource_store, final immutable_list<string> path) {
19:     this.path = path;
22:     return new base_resource_identifier(the_resource_store, path);
26:       return new base_resource_identifier(the_resource_store, path);
28:     final immutable_list<immutable_list<Character>> components = path_separator.split(name);
39:       result.append_all(path);
android.googlesource.com/platform/external/skia:platform_tools/android/apps/canvasproof/src/main/java/org/skia/canvasproof/CanvasProofActivity.java:[master, ]
35:         public String path;
54:     private void getAssetPaths() {
74:             String path = directory + File.separator + resources[i];
76:             this.assets[i].path = path;
78:                 this.assets[i].ptr = CreateSkiaPicture.create(mgr.open(path));
80:                     Log.e(TAG, "CreateSkiaPicture.create returned 0 " + path);
82:                 Picture p = CanvasProofActivity.ReadPicture(mgr.open(path));
85:                           "returned null " + path);
88:                           "empty picture" + path);
93:                 Log.e(TAG, "IOException in getAssetPaths " + path + e);
62:             Log.e(TAG, "IOException in getAssetPaths", e);
159:         this.getAssetPaths();
android.googlesource.com/platform/test/vts:harnesses/tradefed/src/com/android/tradefed/targetprep/VtsPythonVirtualenvPreparer.java:[master, ]
49:     private static final String PATH = "PATH";
53:     protected static final String VIRTUAL_ENV_PATH = "VIRTUALENVPATH";
52:     protected static final String PYTHONPATH = "PYTHONPATH";
59:     @Option(name = "venv-dir", description = "path of an existing virtualenv to use")
164:             mVenvDir = buildInfo.getFile(VIRTUAL_ENV_PATH);
170:             CLog.i(VIRTUAL_ENV_PATH + " = " + virtualEnvPath + "\n");
171:             buildInfo.setFile(VIRTUAL_ENV_PATH, new File(virtualEnvPath),
198:         String path = System.getenv(PATH);
199:         mRunUtil.setEnvVariable(PATH, binDir + File.pathSeparator + path);
111:                     "install", "-r", mRequirementsFile.getAbsolutePath());
114:                         mRequirementsFile.getAbsolutePath());
151:             buildInfo.setFile(PYTHONPATH, new File(mVenvDir,
159:             CLog.i("Using existing virtualenv based at %s", mVenvDir.getAbsolutePath());
168:             String virtualEnvPath = mVenvDir.getAbsolutePath();
169:             mRunUtil.runTimedCmd(BASE_TIMEOUT, "virtualenv", virtualEnvPath);
202:         mPip = pipFile.getAbsolutePath();
github.com/google/cloud-cup-android:app/src/main/java/fr/steren/cloudcup/Arrow.java:[master, ]
34:     private Path path;
74:     private void generatePath(){
117:     public Path getPath(){
22: import android.graphics.Path;
42:         this.path = new Path();
77:         Path path = new Path();
78:         path.moveTo(this.tail.x,this.tail.y);
80:             path.quadTo(this.head.x,this.tail.y,this.tail.x,this.tail.y);
83:             path.lineTo(this.head.x,this.head.y);
106:         path.moveTo(this.head.x,this.head.y);
107:         path.lineTo(P.x,P.y);
109:         path.moveTo(this.head.x,this.head.y);
110:         path.lineTo(Q.x,Q.y);
112:         this.path = path;
118:         return this.path;
49:         this.generatePath();
53:         this.generatePath();
60:         this.generatePath();
gerrit.googlesource.com/apps/reviewit:app/src/main/java/com/google/reviewit/UnifiedDiffFragment.java:[master, ]
59:   private static final String PATH =
60:       "com.google.reviewit.UnifiedDiffFragment.PATH";
64:   public static UnifiedDiffFragment create(String path) {
67:     bundle.putString(PATH, path);
83:     String path = getArguments() != null
84:         ? getArguments().getString(PATH)
92:     if (path != null) {
95:       FileInfo file = files.get(path);
96:       checkState(file != null, "File not found: " + path);
97:       init(path, change, files);
98:       displayFile(change, path, file,
99:           (new ArrayList<>(files.keySet())).indexOf(path) + 1, files.size());
181:   private void init(String path, Change change, Map<String, FileInfo> files) {
185:     int i = paths.indexOf(path);
218:       final String path, final int fileNumber,
225:         init(path, change, files);
226:         displayFile(change, path, files.get(path), fileNumber, files.size());
231:   private void displayFile(Change change, String path, FileInfo file,
234:     files.put(path, file);
273:           final Change change, final String path, FileInfo file) {
299:                 String path = paths[0];
301:                   return change.diff(path);
303:                   Log.e(TAG, "Failed to get diff of file " + path
338:             }.executeOnExecutor(getApp().getExecutor(), path);
182:     String prevPath = null;
183:     String nextPath = null;
184:     List<String> paths = new ArrayList<>(files.keySet());
187:       prevPath = paths.get(i - 1);
189:     if (i < paths.size() - 1) {
190:       nextPath = paths.get(i + 1);
194:     if (prevPath != null || nextPath != null) {
195:       if (prevPath != null) {
198:             new File(prevPath).getName());
199:         setNavigationOnClickListener(R.id.navigationPrev, change, prevPath,
204:       if (nextPath != null) {
207:             new File(nextPath).getName());
208:         setNavigationOnClickListener(R.id.navigationNext, change, nextPath,
298:               protected DiffInfo doInBackground(String... paths) {
github.com/google/git-appraise-eclipse:core/src/com/google/appraise/eclipse/core/client/data/ReviewCommentLocation.java:[master, ]
18:   private String path;
29:   public String getPath() {
33:   public void setPath(String path) {
30:     return path;
34:     this.path = path;
android.googlesource.com/platform/external/smack:src/org/jivesoftware/smack/ServerTrustManager.java:[master, ]
272:         private final String path;
286:         public String getPath() {
275:         public KeyStoreOptions(String type, String path, String password) {
278:             this.path = path;
287:             return path;
299:             result = prime * result + ((path == null) ? 0 : path.hashCode());
318:             if (path == null) {
319:                 if (other.path != null)
321:             } else if (!path.equals(other.path))
65:                     configuration.getTruststorePath(), configuration.getTruststorePassword());
71:                     in = new FileInputStream(options.getPath());
github.com/GoogleCloudPlatform/google-cloud-java:google-cloud-contrib/google-cloud-nio/src/main/java/com/google/cloud/storage/contrib/nio/CloudStorageFileAttributeView.java:[master, ]
40:   private final CloudStoragePath path;
42:   CloudStorageFileAttributeView(Storage storage, CloudStoragePath path) {
44:     this.path = checkNotNull(path);
57:     if (path.seemsLikeADirectory() && path.getFileSystem().config().usePseudoDirectories()) {
58:       return new CloudStoragePseudoDirectoryAttributes(path);
60:     BlobInfo blobInfo = storage.get(path.getBlobId());
62:       throw new NoSuchFileException(path.toUri().toString());
81:             && Objects.equals(path, ((CloudStorageFileAttributeView) other).path);
86:     return Objects.hash(storage, path);
91:     return MoreObjects.toStringHelper(this).add("storage", storage).add("path", path).toString();
android.googlesource.com/platform/external/pdfium:fpdfsdk/src/javascript/Document.cpp:[master, ]
1099: FX_BOOL Document::path(IJS_Context* cc,
86: JS_STATIC_PROP_ENTRY(path)
1085:   CFX_WideString wsFilePath = m_pDocument->GetPath();
1086:   int32_t i = wsFilePath.GetLength() - 1;
1088:     if (wsFilePath.GetAt(i) == L'\\' || wsFilePath.GetAt(i) == L'/')
1091:   if (i >= 0 && i < wsFilePath.GetLength() - 1) {
1092:     vp << (wsFilePath.GetBuffer(wsFilePath.GetLength()) + i + 1);
1107:   vp << app::SysPathToPDFPath(m_pDocument->GetPath());
android.googlesource.com/platform/tools/swt:ddms/ddmuilib/src/main/java/com/android/ddmuilib/ImageLoader.java:[master, ]
49:     private static final String PATH = "/images/"; //$NON-NLS-1$
80:      * Since all images are loaded using the path /images/<var>filename</var>, any class from the
122:         URL url = mClass.getResource(PATH + filename);
138:             String tmp = PATH + filename;
github.com/google/iosched:android/src/main/java/com/google/samples/apps/iosched/provider/ScheduleUriEnum.java:[master, ]
69:     public String path;
12:  * because the {@code UriMatcher} will follow the path of the first  and will fail at the third
66:      * The path to the {@link android.content.UriMatcher} will use to match. * may be used as a
75:     ScheduleUriEnum(int code, String path, String contentTypeId, boolean item, String table) {
77:         this.path = path;
github.com/google/wear-displaylock:common/src/main/java/net/waynepiekarski/displaylockwear/GetFirstDataItem.java:[master, ]
49:     public String path;
39:         path = uri.getPath();
47:     public String toString() { return "path=" + path + " timestamp=" + timestamp + " state=" + state; }
64:     public static void callProcessDataItem(GoogleApiClient mGoogleApiClient, final String path, final ProcessDataItemAble callback) {
65:         Wearable.DataApi.getDataItems(mGoogleApiClient, Uri.parse("wear:" + Const.LOCK_PATH)).setResultCallback(new ResultCallback<DataItemBuffer>() {
74:                         if (item.path.contains(path)) {
github.com/google/google-authenticator-android:AuthenticatorApp/src/main/java/com/google/android/apps/authenticator/AccountDb.java:[master, ]
62:   static final String PATH = "databases";
125:         return context.openOrCreateDatabase(PATH, Context.MODE_PRIVATE, null);
139:     String databaseDirPathname = context.getDatabasePath(PATH).getParent();
140:     String databasePathname = context.getDatabasePath(PATH).getAbsolutePath();
141:     String[] dirsToStat = new String[] {dataPackageDir, databaseDirPathname, databasePathname};