Found 393495 results in 56365 files, showing top 50 files (show more).
android.googlesource.com/platform/tools/gpu:service/path/path_binary.go: [ master, ]
6: package path
76: 		o.Array = obj.(Path)
113: 	Package: "path",
116: 		{Declared: "Array", Type: &schema.Interface{Name: "Path"}},
163: 	Package: "path",
218: 	Package: "path",
284: 	Package: "path",
334: 	Package: "path",
383: 	Package: "path",
412: 		o.Struct = obj.(Path)
449: 	Package: "path",
452: 		{Declared: "Struct", Type: &schema.Interface{Name: "Path"}},
505: 	Package: "path",
554: 	Package: "path",
592: 		o.Map = obj.(Path)
633: 	Package: "path",
636: 		{Declared: "Map", Type: &schema.Interface{Name: "Path"}},
722: 	Package: "path",
780: 	Package: "path",
812: 		o.Array = obj.(Path)
857: 	Package: "path",
860: 		{Declared: "Array", Type: &schema.Interface{Name: "Path"}},
914: 	Package: "path",
963: 	Package: "path",
github.com/google/go-cmp:cmp/path.go: [ master, ]
24: type Path []PathStep
32: type PathStep interface {
149: type pathStep struct {
170: 	pathStep
208: 	pathStep
252: 	pathStep
266: 	pathStep
276: 	pathStep
286: 	pathStep
15: // Path is a list of PathSteps describing the sequence of operations to get
17: // The first Path element is always an operation-less PathStep that exists
35: 	// Type is the resulting type after performing the path step.
38: 	// Values is the resulting values after performing the path step.
63: func (pa *Path) push(s PathStep) {
67: func (pa *Path) pop() {
71: // Last returns the last PathStep in the Path.
72: // If the path is empty, this returns a non-nil PathStep that reports a nil Type.
73: func (pa Path) Last() PathStep {
77: // Index returns the ith step in the Path and supports negative indexing.
78: // A negative index starts counting from the tail of the Path such that -1
81: func (pa Path) Index(i int) PathStep {
91: // String returns the simplified path to a node.
92: // The simplified path only contains struct field accesses.
96: func (pa Path) String() string {
106: // GoString returns the path to a specific node using Go syntax.
110: func (pa Path) GoString() string {
26: // PathStep is a union-type for specific operations to traverse
55: 	_ PathStep = StructField{}
56: 	_ PathStep = SliceIndex{}
57: 	_ PathStep = MapIndex{}
58: 	_ PathStep = Indirect{}
59: 	_ PathStep = TypeAssertion{}
60: 	_ PathStep = Transform{}
80: // If index is invalid, this returns a non-nil PathStep that reports a nil Type.
86: 		return pathStep{}
114: 		var nextStep PathStep
154: func (ps pathStep) Type() reflect.Type             { return ps.typ }
155: func (ps pathStep) Values() (vx, vy reflect.Value) { return ps.vx, ps.vy }
156: func (ps pathStep) String() string {
github.com/yeoman/doctor:lib/rules/node-path.js: [ master, ]
3: const path = require('path');
14:   pathMismatch(npmRoot) {
29: function fixPath(filepath) {
48:   const nodePaths = (process.env.NODE_PATH || '').split(path.delimiter).map(fixPath);
7: exports.description = 'NODE_PATH matches the npm root';
11:     return message.get('node-path-npm-failure', {});
15:     let msgPath = 'node-path-path-mismatch';
22:       path: process.env.NODE_PATH,
30:   let fixedPath = path.resolve(path.normalize(filepath.trim()));
44:   if (process.env.NODE_PATH === undefined) {
18:       msgPath += '-windows';
21:     return message.get(msgPath, {
33:     fixedPath = fs.realpathSync(fixedPath);
40:   return fixedPath;
52:     const npmRoot = fixPath(stdout);
55:       return errors.pathMismatch(npmRoot);
54:     if (nodePaths.indexOf(npmRoot) < 0) {
android.googlesource.com/platform/external/swiftshader:third_party/llvm-subzero/lib/Support/Path.cpp: [ master, ]
231: namespace path {
1172: namespace path {
360: StringRef root_path(StringRef path) {
443: StringRef relative_path(StringRef path) {
493: StringRef parent_path(StringRef path) {
634: bool has_root_path(const Twine &path) {
641: bool has_relative_path(const Twine &path) {
655: bool has_parent_path(const Twine &path) {
135:   size_t parent_path_end(StringRef path) {
525: void replace_path_prefix(SmallVectorImpl<char> &Path,
1: //===-- Path.cpp - Implement OS Path Concept ------------------------------===//
10: //  This file implements the operating system Path API.
20: #include "llvm/Support/Path.h"
36:   using llvm::sys::path::is_separator;
46:   StringRef find_first_component(StringRef path) {
53:     if (path.empty())
54:       return path;
58:     if (path.size() >= 2 && std::isalpha(static_cast<unsigned char>(path[0])) &&
59:         path[1] == ':')
60:       return path.substr(0, 2);
64:     if ((path.size() > 2) &&
65:         is_separator(path[0]) &&
66:         path[0] == path[1] &&
67:         !is_separator(path[2])) {
69:       size_t end = path.find_first_of(separators, 2);
70:       return path.substr(0, end);
74:     if (is_separator(path[0]))
75:       return path.substr(0, 1);
78:     size_t end = path.find_first_of(separators);
79:     return path.substr(0, end);
136:     size_t end_pos = filename_pos(path);
138:     bool filename_was_sep = path.size() > 0 && is_separator(path[end_pos]);
141:     size_t root_dir_pos = root_dir_start(path.substr(0, end_pos));
145:           is_separator(path[end_pos - 1]))
170:     if (!sys::path::is_absolute(Twine(ModelStorage))) {
172:       sys::path::system_temp_directory(true, TDir);
173:       sys::path::append(TDir, Twine(ModelStorage));
179:   // path already exists.
185: retry_random_path:
199:         goto retry_random_path;
213:     goto retry_random_path;
220:         goto retry_random_path;
233: const_iterator begin(StringRef path) {
235:   i.Path      = path;
236:   i.Component = find_first_component(path);
241: const_iterator end(StringRef path) {
243:   i.Path      = path;
244:   i.Position  = path.size();
249:   assert(Position < Path.size() && "Tried to increment past end!");
255:   if (Position == Path.size()) {
268:   if (is_separator(Path[Position])) {
276:       Component = Path.substr(Position, 1);
281:     while (Position != Path.size() &&
282:            is_separator(Path[Position])) {
287:     if (Position == Path.size()) {
295:   size_t end_pos = Path.find_first_of(separators, Position);
296:   Component = Path.slice(Position, end_pos);
302:   return Path.begin() == RHS.Path.begin() && Position == RHS.Position;
309: reverse_iterator rbegin(StringRef Path) {
311:   I.Path = Path;
312:   I.Position = Path.size();
316: reverse_iterator rend(StringRef Path) {
318:   I.Path = Path;
319:   I.Component = Path.substr(0, 0);
326:   // we are the root path.
327:   size_t root_dir_pos = root_dir_start(Path);
328:   if (Position == Path.size() &&
329:       Path.size() > root_dir_pos + 1 &&
330:       is_separator(Path[Position - 1])) {
341:         is_separator(Path[end_pos - 1]))
345:   size_t start_pos = filename_pos(Path.substr(0, end_pos));
346:   Component = Path.slice(start_pos, end_pos);
352:   return Path.begin() == RHS.Path.begin() && Component == RHS.Component &&
361:   const_iterator b = begin(path),
363:                  e = end(path);
376:         return path.substr(0, b->size() + pos->size());
392: StringRef root_name(StringRef path) {
393:   const_iterator b = begin(path),
394:                  e = end(path);
410:   // No path or no name.
414: StringRef root_directory(StringRef path) {
415:   const_iterator b = begin(path),
417:                  e = end(path);
439:   // No path or no root.
444:   StringRef root = root_path(path);
445:   return path.substr(root.size());
448: void append(SmallVectorImpl<char> &path, const Twine &a,
464:     bool path_has_sep = !path.empty() && is_separator(path[path.size() - 1]);
468:     if (path_has_sep) {
474:       path.append(c.begin(), c.end());
478:     if (!component_has_sep && !(path.empty() || is_root_name)) {
480:       path.push_back(preferred_separator);
483:     path.append(component.begin(), component.end());
487: void append(SmallVectorImpl<char> &path,
490:     path::append(path, *begin);
494:   size_t end_pos = parent_path_end(path);
498:     return path.substr(0, end_pos);
501: void remove_filename(SmallVectorImpl<char> &path) {
502:   size_t end_pos = parent_path_end(StringRef(path.begin(), path.size()));
504:     path.set_size(end_pos);
507: void replace_extension(SmallVectorImpl<char> &path, const Twine &extension) {
508:   StringRef p(path.begin(), path.size());
515:     path.set_size(pos);
519:     path.push_back('.');
522:   path.append(ext.begin(), ext.end());
531:   StringRef OrigPath(Path.begin(), Path.size());
537:     std::copy(NewPrefix.begin(), NewPrefix.end(), Path.begin());
543:   path::append(NewPath, NewPrefix);
544:   path::append(NewPath, RelPath);
545:   Path.swap(NewPath);
548: void native(const Twine &path, SmallVectorImpl<char> &result) {
549:   assert((!path.isSingleStringRef() ||
550:           path.getSingleStringRef().data() != result.data()) &&
551:          "path and result are not allowed to overlap!");
554:   path.toVector(result);
558: void native(SmallVectorImpl<char> &Path) {
560:   std::replace(Path.begin(), Path.end(), '/', '\\');
562:   for (auto PI = Path.begin(), PE = Path.end(); PI < PE; ++PI) {
574: StringRef filename(StringRef path) {
575:   return *rbegin(path);
578: StringRef stem(StringRef path) {
579:   StringRef fname = filename(path);
591: StringRef extension(StringRef path) {
592:   StringRef fname = filename(path);
620: bool has_root_name(const Twine &path) {
621:   SmallString<128> path_storage;
622:   StringRef p = path.toStringRef(path_storage);
627: bool has_root_directory(const Twine &path) {
628:   SmallString<128> path_storage;
629:   StringRef p = path.toStringRef(path_storage);
635:   SmallString<128> path_storage;
636:   StringRef p = path.toStringRef(path_storage);
638:   return !root_path(p).empty();
642:   SmallString<128> path_storage;
643:   StringRef p = path.toStringRef(path_storage);
645:   return !relative_path(p).empty();
648: bool has_filename(const Twine &path) {
649:   SmallString<128> path_storage;
650:   StringRef p = path.toStringRef(path_storage);
656:   SmallString<128> path_storage;
657:   StringRef p = path.toStringRef(path_storage);
659:   return !parent_path(p).empty();
662: bool has_stem(const Twine &path) {
663:   SmallString<128> path_storage;
664:   StringRef p = path.toStringRef(path_storage);
669: bool has_extension(const Twine &path) {
670:   SmallString<128> path_storage;
671:   StringRef p = path.toStringRef(path_storage);
676: bool is_absolute(const Twine &path) {
677:   SmallString<128> path_storage;
678:   StringRef p = path.toStringRef(path_storage);
690: bool is_relative(const Twine &path) { return !is_absolute(path); }
692: StringRef remove_leading_dotslash(StringRef Path) {
694:   while (Path.size() > 2 && Path[0] == '.' && is_separator(Path[1])) {
695:     Path = Path.substr(2);
696:     while (Path.size() > 0 && is_separator(Path[0]))
697:       Path = Path.substr(1);
699:   return Path;
702: static SmallString<256> remove_dots(StringRef path, bool remove_dot_dot) {
705:   // Skip the root path, then look for traversal in the components.
706:   StringRef rel = path::relative_path(path);
707:   for (StringRef C : llvm::make_range(path::begin(rel), path::end(rel))) {
710:     // Leading ".." will remain in the path unless it's at the root.
716:       if (path::is_absolute(path))
722:   SmallString<256> buffer = path::root_path(path);
724:     path::append(buffer, C);
728: bool remove_dots(SmallVectorImpl<char> &path, bool remove_dot_dot) {
729:   StringRef p(path.data(), path.size());
732:   if (result == path)
735:   path.swap(result);
739: } // end namespace path
743: std::error_code getUniqueID(const Twine Path, UniqueID &Result) {
745:   std::error_code EC = status(Path, Status);
807:                                      SmallVectorImpl<char> &path,
809:   StringRef p(path.data(), path.size());
811:   bool rootDirectory = path::has_root_directory(p),
813:        rootName = path::has_root_name(p);
826:   else if (std::error_code ec = current_path(current_dir))
829:   // Relative path. Prepend the current directory.
831:     // Append path to the current directory.
832:     path::append(current_dir, p);
833:     // Set path to the result.
834:     path.swap(current_dir);
839:     StringRef cdrn = path::root_name(current_dir);
841:     path::append(curDirRootName, p);
842:     // Set path to the result.
843:     path.swap(curDirRootName);
848:     StringRef pRootName      = path::root_name(p);
849:     StringRef bRootDirectory = path::root_directory(current_dir);
850:     StringRef bRelativePath  = path::relative_path(current_dir);
851:     StringRef pRelativePath  = path::relative_path(p);
854:     path::append(res, pRootName, bRootDirectory, bRelativePath, pRelativePath);
855:     path.swap(res);
864:                               SmallVectorImpl<char> &path) {
865:   return make_absolute(current_directory, path, true);
868: std::error_code make_absolute(SmallVectorImpl<char> &path) {
869:   return make_absolute(Twine(), path, false);
872: std::error_code create_directories(const Twine &Path, bool IgnoreExisting,
875:   StringRef P = Path.toStringRef(PathStorage);
886:   StringRef Parent = path::parent_path(P);
942: std::error_code is_directory(const Twine &path, bool &result) {
944:   if (std::error_code ec = status(path, st))
954: std::error_code is_regular_file(const Twine &path, bool &result) {
956:   if (std::error_code ec = status(path, st))
968: std::error_code is_other(const Twine &Path, bool &Result) {
970:   if (std::error_code EC = status(Path, FileStatus))
977:   SmallString<128> path = path::parent_path(Path);
978:   path::append(path, filename);
979:   Path = path.str();
1140: std::error_code identify_magic(const Twine &Path, file_magic &Result) {
1142:   if (std::error_code EC = openFileForRead(Path, FD))
1155:   return fs::status(Path, result);
1164: #include "Unix/Path.inc"
1167: #include "Windows/Path.inc"
1174: bool user_cache_directory(SmallVectorImpl<char> &Result, const Twine &Path1,
1175:                           const Twine &Path2, const Twine &Path3) {
1177:     append(Result, Path1, Path2, Path3);
1183: } // end namespace path
162:                                           SmallVectorImpl<char> &ResultPath,
180:   ResultPath = ModelStorage;
182:   ResultPath.push_back(0);
183:   ResultPath.pop_back();
189:       ResultPath[i] = "0123456789abcdef"[sys::Process::GetRandomNumber() & 15];
196:             sys::fs::openFileForWrite(Twine(ResultPath.begin()), ResultFD,
208:         sys::fs::access(ResultPath.begin(), sys::fs::AccessMode::Exist);
218:             sys::fs::create_directory(ResultPath.begin(), false)) {
260:   // Both POSIX and Windows treat paths that begin with exactly two separators
532:   if (!OrigPath.startswith(OldPrefix))
541:   StringRef RelPath = OrigPath.substr(OldPrefix.size());
542:   SmallString<256> NewPath;
753:                                  SmallVectorImpl<char> &ResultPath,
755:   return createUniqueEntity(Model, ResultFd, ResultPath, false, Mode, FS_File);
759:                                  SmallVectorImpl<char> &ResultPath) {
761:   return createUniqueEntity(Model, Dummy, ResultPath, false, 0, FS_Name);
766:                     llvm::SmallVectorImpl<char> &ResultPath, FSEntity Type) {
772:   return createUniqueEntity(P.begin(), ResultFD, ResultPath,
778:                     llvm::SmallVectorImpl<char> &ResultPath, FSEntity Type) {
780:   return createTemporaryFile(Prefix + Middle + Suffix, ResultFD, ResultPath,
786:                                     SmallVectorImpl<char> &ResultPath) {
787:   return createTemporaryFile(Prefix, Suffix, ResultFD, ResultPath, FS_File);
791:                                     SmallVectorImpl<char> &ResultPath) {
793:   return createTemporaryFile(Prefix, Suffix, Dummy, ResultPath, FS_Name);
800:                                       SmallVectorImpl<char> &ResultPath) {
802:   return createUniqueEntity(Prefix + "-%%%%%%", Dummy, ResultPath,
874:   SmallString<128> PathStorage;
android.googlesource.com/platform/external/perf_data_converter:src/quipper/scoped_temp_path.h: [ master, ]
22:   const string& path() const { return path_; }
25:   string path_;
17: class ScopedTempPath {
19:   ScopedTempPath() {}
6: #define CHROMIUMOS_WIDE_PROFILING_SCOPED_TEMP_PATH_H_
5: #ifndef CHROMIUMOS_WIDE_PROFILING_SCOPED_TEMP_PATH_H_
20:   // The temporary path will be removed when the object is destroyed.
33:   // Create a temporary file.  If successful, the path will be stored in
34:   // |path_|.  If not, |path_| will be an empty string.
43:   // Create a temporary directory.  If successful, the path will be stored in
44:   // |path_|.  If not, |path_| will be an empty string.
53: #endif  // CHROMIUMOS_WIDE_PROFILING_SCOPED_TEMP_PATH_H_
21:   virtual ~ScopedTempPath();
28:   DISALLOW_COPY_AND_ASSIGN(ScopedTempPath);
31: class ScopedTempFile : public ScopedTempPath {
41: class ScopedTempDir : public ScopedTempPath {
github.com/apache/brooklyn:brooklyn-client/cli/vendor/github.com/NodePrime/jsonpath/eval.go: [ master, ]
11: 	Path
1: package jsonpath
190: func pathMatchOp(q *query, e *Eval, i *Item) queryStateFn {
242: func pathEndValue(q *query, e *Eval, i *Item) queryStateFn {
46: func newEvaluation(tr tokenReader, paths ...*Path) *Eval {
73: func newQuery(p *Path) *query {
75: 		Path:        *p,
99: 	// run path function for each path
300: 			values[q.Path.stringValue] = i
59: 	for _, p := range paths {
76: 		state:       pathMatchOp,
232: 		return pathEndValue
238: 		return pathMatchOp
282: 		return pathMatchOp
284: 	return pathEndValue
208: 							queries:     make([]*query, len(nextOp.dependentPaths)),
212: 						for i, p := range nextOp.dependentPaths {
github.com/sourcegraph/srclib-javascript:lib/define-path-info.js: [ master, ]
3: var path = require("path");
453:                 path: scope,
522:                 path: "",
62: function resolveScopeCountPath(scope) {
142: var pathVisitor = walk.make({
557: module.exports.mapLinesPathToScopePath = function(ternServer, defInfo) {
607: module.exports.getPath = function(node) {
47: function getFilePathName(fileName) {
19:  * @property {string} scope - scope path
28:  * @property {string} path - path to class
36:  * @return {string} path to given node in given file
100:  * required parent properties and adjusting path
102:  * @param {string} scope new scope (path)
316:             if (def && def.path) {
317:                 pathMap[formPathForScope(fileName, node.object)] = def.path;
318:                 newScope = def.path;
326:                 if (def && def.path) {
327:                     pathMap[formPathForScope(fileName, node.object)] = def.path;
328:                     newScope = def.path;
341:                     newScope = util.formPath(def.path, "fn", '+' + node.property.name);
344:                     newScope = util.formPath(def.path, "fn", '-' + node.property.name);
347:                     newScope = util.formPath(def.path, "fn", node.property.name);
350:                     newScope = util.formPath(classDefinitions[currentClass].path, "prop", node.property.name);
438:             // append /class/NAME to path being built
443:                 classDefinitions[currentClass].path = scope;
605:  * @returns {string} computed path to given node
39:     return util.formPath(fileName, data.start, data.end);
48:     fileName = util.normalizePath(fileName);
69:         return util.formPath(scope, scopeCountRes);
73: module.exports.pathMap = pathMap = {};
154:             var newScope = util.formPath(scopeInfo.scope, "obj_def_prop");
158:                 newScope = util.formPath(newScope, obj.name);
160:                 newScope = util.formPath(newScope, property.value);
164:             pathMap[key] = resolveScopeCountPath(newScope);
179:         var newScope = util.formPath(scopeInfo.scope, "import");
185:                     newScope = resolveScopeCountPath(util.formPath(newScope, id.name));
186:                     pathMap[key] = newScope;
204:         var newScope = util.formPath(scopeInfo.scope, "fn");
223:             newScope = resolveScopeCountPath(util.formPath(newScope, name));
224:             pathMap[formPathForScope(fileName, identNode)] = newScope;
228:             newScope = resolveScopeCountPath(newScope);
240:             var paramScope = resolveScopeCountPath(util.formPath(newScope, "param", param.name));
241:             pathMap[formPathForScope(fileName, param)] = paramScope;
267:                 var newScope = resolveScopeCountPath(util.formPath(scopeInfo.scope, "var", decl.name));
268:                 pathMap[key] = newScope;
309:             newScope = resolveScopeCountPath(util.formPath(scopeInfo.scope, "obj", node.object.name));
310:             pathMap[formPathForScope(fileName, node.object)] = newScope;
353:                 newScope = resolveScopeCountPath(util.formPath(newScope, "prop", node.property.name));
356:             pathMap[keyProp] = newScope;
371:         var newScope = util.formPath(scopeInfo.scope, "obj");
375:                 objScope = util.formPath(objScope, "objType", node.objType.name);
378:             var keyScope = util.formPath(objScope, "obj_key");
382:                 keyScope = resolveScopeCountPath(util.formPath(keyScope, node.properties[i].key.name));
383:                 pathMap[keyKey] = keyScope;
387:                 keyScope = resolveScopeCountPath(util.formPath(keyScope, node.properties[i].key.value));
388:                 pathMap[keyKey] = keyScope;
395:                 valScope = resolveScopeCountPath(util.formPath(valScope, "obj_val", node.properties[i].value.name));
396:                 pathMap[key_val] = valScope;
436:         var scope = util.formPath(scopeInfo.scope, "class");
439:             scope = resolveScopeCountPath(util.formPath(scope, node.id.name));
440:             pathMap[formPathForScope(node.sourceFile.name, node.id)] = scope;
446:             scope = resolveScopeCountPath(scope);
457:             pathMap[util.formPath(node.sourceFile.name, node.start, node.start + "class".length)] = scope;
513:     var visitor = extend({}, pathVisitor);
530:         pathVisitor.ClassDeclaration(node, state, cb);
543:         pathVisitor.MethodDefinition(node, state, cb);
562:     var mapRes = pathMap[key];
577:                     methods: pathVisitor
578:                 }, null, pathVisitor);
608:     return pathMap[formPathForScope(node.sourceFile.name, node)];
38: module.exports.formPathForScope = formPathForScope = function(fileName, data) {
163:             var key = formPathForScope(fileName, property);
184:                     var key = formPathForScope(fileName, id);
266:                 var key = formPathForScope(fileName, decl);
355:             keyProp = formPathForScope(fileName, node.property);
381:                 keyKey = formPathForScope(fileName, node.properties[i].key);
386:                 keyKey = formPathForScope(fileName, node.properties[i].key);
394:                 var key_val = formPathForScope(fileName, node.properties[i].value);
508: module.exports.initLocalFilesScopePaths = function(ternServer, localFiles) {
550:                 scope: getFilePathName(file.name),
558:     var key = formPathForScope(defInfo.file, {
575:                     scope: getFilePathName(file.name),
github.com/google/perf_data_converter:src/quipper/scoped_temp_path.h: [ master, ] Duplicate result
github.com/google/capture-thread:example/paths.cc: [ current, ]
60: class Path : public ThreadCapture<Path> {
56:   std::ostringstream path_;
34: class PathBuilder {
85:   static std::string DelegateRootPath(const Path& path) {
89:   static void DelegateLocalPath(const Path& path, PathBuilder* builder) {
95: class InRootPath : public Path {
97:   InRootPath(const std::string& root_path)
101:   std::string RootPath() const override { return root_path_; }
103:   void AppendLocalPath(PathBuilder* builder) const override {
116: class InLocalPath : public Path {
118:   InLocalPath(const std::string& local_path)
122:   std::string RootPath() const override {
127:   void AppendLocalPath(PathBuilder* builder) const override {
111:   const std::string root_path_;
137:   const std::string local_path_;
36:   std::string String() const { return path_.str(); }
41:         path_.str("");
42:         path_ << component;
45:           path_ << '/';
47:         path_ << component;
86:     return path.RootPath();
90:     path.AppendLocalPath(builder);
94: // Sets the root path, which persists while the instance is in scope.
98:       : root_path_(root_path), capture_to_(this) {}
115: // Sets the local path relative to the current root + local path.
119:       : local_path_(local_path), capture_to_(this) {}
133:     builder->Add(local_path_);
143:   InLocalPath path("bin");
146:     std::cerr << "Installing binary " << Path::Working() << std::endl;
152:   InLocalPath path("lib");
155:     std::cerr << "Installing library " << Path::Working() << std::endl;
160: void InstallProjectIn(const std::string& path) {
161:   InRootPath root(path);
162:   std::cerr << "Installing project in " << Path::Root() << std::endl;
33: // A helper class for building paths from components.
38:   PathBuilder& Add(const std::string& component) {
59: // Tracks persistent root and local paths.
64:       return GetCurrent()->RootPath();
72:       PathBuilder builder;
74:       GetCurrent()->AppendLocalPath(&builder);
82:   virtual std::string RootPath() const = 0;
83:   virtual void AppendLocalPath(PathBuilder* builder) const = 0;
106:       DelegateLocalPath(*previous, builder);
124:     return previous ? DelegateRootPath(*previous) : "";
131:       DelegateLocalPath(*previous, builder);
145:     InLocalPath file(target);
154:     InLocalPath file(target);
github.com/google/go-structeditor:structeditor/path.go: [ master, ]
24: type Path struct {
39: func StringToPath(s string) (*Path, error) {
49: func sliceToPath(slice []string) (*Path, error) {
69: func encodePath(s string) (*Path, error) {
23: // Path to a specific variable
29: 	// Name of struct field in path
33: 	// if nil, this Path refers to the top-level element
34: 	Next *Path
37: // Converts a string to a Path pointer. If the pointer is nil,
38: // the Path refers to the top-level ("current") element.
47: // Converts a string slice to a Path pointer. If the pointer is nil,
48: // the Path refers to the top-level ("current") element.
50: 	var first *Path
51: 	var cur *Path
68: // Encodes path part
75: 		return &Path{
80: 	return &Path{
85: // Appends the specified newElement to the path and
86: // returns the new root of the path.
87: func (p *Path) Append(newElement *Path) *Path {
88: 	var prevEl *Path
89: 	var curEl *Path
100: // Removes the last element from the path and returns
101: // the new root of the path
102: func (p *Path) RemoveLast() *Path {
106: 	var prevEl *Path
107: 	var curEl *Path
114: type VisitingFunc func(updatedPath *Path)
116: // Attaches the specified element to the path, runs the specified function, and
119: func (p *Path) Visiting(element *Path, doing VisitingFunc) {
125: func (p *Path) String() string {
44: 	return sliceToPath(sliced)
53: 		pathEl, err := encodePath(elt)
58: 			first = pathEl
60: 			cur.Next = pathEl
62: 		cur = pathEl
129: 	subpath := p.Next.String()
134: 	if subpath == "" {
137: 		return elt + "." + subpath
github.com/apache/incubator-retired-hdt:site/lib/path.pm: [ master, ]
1: package path;
github.com/Polymer/polymer-css-build:lib/pathresolver.js: [ master, ]
13: const path = require('path').posix;
35:       const pathname = path.relative(
36:         path.dirname(parsedFrom.pathname), parsedTo.pathname);
54:       let path = match.replace(/["']/g, "").slice(4, -1);
55:       path = this.rewriteRelPath(importUrl, mainDocUrl, path);
56:       return 'url("' + path + '")';
12: // Adapted from vulcanize's pathResolver, but only used for css text
26:   rewriteRelPath: function rewriteRelPath(importUrl, mainDocUrl, relUrl) {
38:         pathname,
github.com/kythe/llvmbzlgen:path/path.go: [ master, ]
18: package path
26: type Path []string
44: func ToPaths(paths []string) []Path {
17: // Package path implements path manipulation routines used by cmaketobzl.
21: 	"path/filepath"
25: // Path is a slice of string segments, representing a filesystem path.
28: // Split cleans and splits the system-delimited filesystem path.
29: func New(s string) Path {
35: 		return Path{"/"}
37: 		return append(Path{"/"}, strings.Split(s[1:], "/")...)
45: 	split := make([]Path, len(paths))
53: func (p Path) LessThan(o Path) bool {
66: // String returns the properly platform-delimited form of the path.
67: func (p Path) String() string {
71: // Append appends additional elements to the end of path, disregarding
73: func Append(p Path, ps ...Path) Path {
84: // AppendString appends additional string elements to the end of path.
85: func AppendString(p Path, elem ...string) Path {
90: func Join(p Path, ps ...Path) Path {
97: // JoinString joins path and any number of additional string elements, returning the result.
98: func JoinString(p Path, elem ...string) Path {
103: // path and returns that along with each path stripped of that prefix.
104: func SplitCommonRoot(paths []Path) (Path, []Path) {
109: 	result := make([]Path, len(paths))
117: // path and returns that along with each path stripped of that prefix as /-delimited strings.
127: // LongestCommonPrefix returns the longest shared Path prefix of all of the paths.
128: func LongestCommonPrefix(paths []Path) Path {
30: 	s = filepath.ToSlash(filepath.Clean(s))
43: // ToPaths cleans and splits each of the system-delimited filesystem paths.
46: 	for i, p := range paths {
52: // LessThan provides lexicographic ordering of Paths.
68: 	return filepath.Join([]string(p)...)
75: 		// Drop the leading '/' when appending/joining fully qualified paths.
89: // Join joins any number of paths and returns the result.
105: 	root := LongestCommonPrefix(paths)
107: 		return root, paths
110: 	for i, p := range paths {
118: func SplitCommonRootString(paths []string) (string, []string) {
119: 	root, stripped := SplitCommonRoot(ToPaths(paths))
129: 	switch len(paths) {
133: 		return paths[0]
135: 	min, max := paths[0], paths[0]
136: 	for _, p := range paths[1:] {
86: 	return Append(p, ToPaths(elem)...)
99: 	return Join(p, ToPaths(elem)...)
github.com/tensorflow/metadata:tensorflow_metadata/proto/v0/path.proto: [ master, ]
39: message Path {
24: // A path is a more general substitute for the name of a field or feature that
32: // Thus, here the path {step:["parent", "age"]} in statistics would refer to the
github.com/apache/sling-org-apache-sling-jcr-js-nodetypes:src/test/resources/expectedNTJSON/testCompletePathPropertyDefinition.json: [ master, ]
7:             "path": "/myapp:myName/myapp:myChildNode/aSubChildNode",
8:             "type": "Path"
11:         "requiredType": "Path",
20:         "name": "pathPropertyDef"
github.com/git/git:Makefile: [ master, ]
1257: PATH := $(SANE_TOOL_PATH):${PATH}
561: TCL_PATH = tclsh
562: TCLTK_PATH = wish
798: 	SHELL_PATH = /bin/sh
801: 	PERL_PATH = /usr/bin/perl
804: 	PYTHON_PATH = /usr/bin/python
810: TEST_SHELL_PATH = $(SHELL_PATH)
541: pathsep = :
1175: CC_LD_DYNPATH = -Wl,-rpath,
1255: SANE_TOOL_PATH_SQ = $(subst ','\'',$(SANE_TOOL_PATH))
1256: BROKEN_PATH_FIX = 's|^\# @@BROKEN_PATH_FIX@@$$|git_broken_path_fix "$(SANE_TOOL_PATH_SQ)"|'
1259: BROKEN_PATH_FIX = '/^\# @@BROKEN_PATH_FIX@@$$/d'
1827: 	procfs_executable_path_SQ = $(subst ','\'',$(PROCFS_EXECUTABLE_PATH))
1943: SHELL_PATH_SQ = $(subst ','\'',$(SHELL_PATH))
1944: TEST_SHELL_PATH_SQ = $(subst ','\'',$(TEST_SHELL_PATH))
1945: PERL_PATH_SQ = $(subst ','\'',$(PERL_PATH))
1946: PYTHON_PATH_SQ = $(subst ','\'',$(PYTHON_PATH))
1947: TCLTK_PATH_SQ = $(subst ','\'',$(TCLTK_PATH))
2006: SHELL_PATH_CQ = "$(subst ",\",$(subst \,\\,$(SHELL_PATH)))"
2007: SHELL_PATH_CQ_SQ = $(subst ','\'',$(SHELL_PATH_CQ))
2073: please_set_SHELL_PATH_to_a_more_modern_shell:
6: # Define SHELL_PATH to a POSIX shell if your /bin/sh is broken.
8: # Define SANE_TOOL_PATH to a colon-separated list of paths to prepend
9: # to PATH if your tools in /usr/bin are broken.
96: # Define HAVE_PATHS_H if you have paths.h and want to use the default PATH
301: # Define PERL_PATH to the path of your Perl binary (usually /usr/bin/perl).
311: # Define PYTHON_PATH to the path of your Python binary (often /usr/bin/python
321: # The TCL_PATH variable governs the location of the Tcl interpreter
325: # The TCLTK_PATH variable governs the location of the Tcl/Tk interpreter.
444: # Define TEST_SHELL_PATH if you want to use a shell besides SHELL_PATH for
461: # When using RUNTIME_PREFIX, define PROCFS_EXECUTABLE_PATH if your platform
462: # mounts a "procfs" filesystem capable of resolving the path of the current
463: # executable. If defined, this must be the canonical path for the "procfs"
464: # current executable path.
466: # When using RUNTIME_PREFIX, define HAVE_NS_GET_EXECUTABLE_PATH if your platform
467: # supports calling _NSGetExecutablePath to retrieve the path of the running
471: # the global variable _wpgmptr containing the absolute path of the current
504: 	@$(SHELL_PATH) ./GIT-VERSION-GEN
513: # can be specified as a relative path some/where/else;
515: # runtime figures out where they are based on the path to the executable.
570: export TCL_PATH TCLTK_PATH
724: TEST_BUILTINS_OBJS += test-path-utils.o
797: ifndef SHELL_PATH
800: ifndef PERL_PATH
803: ifndef PYTHON_PATH
807: export PERL_PATH
808: export PYTHON_PATH
940: LIB_OBJS += path.o
1254: ifdef SANE_TOOL_PATH
1402: ifdef ZLIB_PATH
1403: 	BASIC_CFLAGS += -I$(ZLIB_PATH)/include
1404: 	EXTLIBS += -L$(ZLIB_PATH)/$(lib) $(CC_LD_DYNPATH)$(ZLIB_PATH)/$(lib)
1826: ifneq ($(PROCFS_EXECUTABLE_PATH),)
1828: 	BASIC_CFLAGS += '-DPROCFS_EXECUTABLE_PATH="$(procfs_executable_path_SQ)"'
1831: ifdef HAVE_NS_GET_EXECUTABLE_PATH
1832: 	BASIC_CFLAGS += -DHAVE_NS_GET_EXECUTABLE_PATH
1849: ifeq ($(TCLTK_PATH),)
1853: ifeq ($(PERL_PATH),)
1857: ifeq ($(PYTHON_PATH),)
1952: # relative to each other and share an installation path.
2005: ifdef SHELL_PATH
2009: BASIC_CFLAGS += -DSHELL_PATH='$(SHELL_PATH_CQ_SQ)'
2032: export DIFF TAR INSTALL DESTDIR SHELL_PATH
2037: SHELL = $(SHELL_PATH)
2071: 	$(QUIET_SUBDIR0)templates $(QUIET_SUBDIR1) SHELL_PATH='$(SHELL_PATH_SQ)' PERL_PATH='$(PERL_PATH_SQ)'
2076: shell_compatibility_test: please_set_SHELL_PATH_to_a_more_modern_shell
2116: 	'-DGIT_HTML_PATH="$(htmldir_relative_SQ)"' \
2117: 	'-DGIT_MAN_PATH="$(mandir_relative_SQ)"' \
2118: 	'-DGIT_INFO_PATH="$(infodir_relative_SQ)"'
2128: 	'-DGIT_HTML_PATH="$(htmldir_relative_SQ)"' \
2129: 	'-DGIT_MAN_PATH="$(mandir_relative_SQ)"' \
2130: 	'-DGIT_INFO_PATH="$(infodir_relative_SQ)"'
2149: 	$(QUIET_GEN)$(SHELL_PATH) ./generate-cmdlist.sh \
2153: SCRIPT_DEFINES = $(SHELL_PATH_SQ):$(DIFF_SQ):$(GIT_VERSION):\
2154: 	$(localedir_SQ):$(NO_CURL):$(USE_GETTEXT_SCHEME):$(SANE_TOOL_PATH_SQ):\
2155: 	$(gitwebdir_SQ):$(PERL_PATH_SQ):$(SANE_TEXT_GREP):$(PAGER_ENV):\
2159: sed -e '1s|#!.*/sh|#!$(SHELL_PATH_SQ)|' \
2160:     -e 's|@SHELL_PATH@|$(SHELL_PATH_SQ)|' \
2165:     -e $(BROKEN_PATH_FIX) \
2167:     -e 's|@@PERL@@|$(PERL_PATH_SQ)|g' \
2205: PERL_DEFINES = $(PERL_PATH_SQ):$(PERLLIB_EXTRA_SQ):$(perllibdir_SQ)
2207: PERL_DEFINES := $(PERL_PATH_SQ) $(PERLLIB_EXTRA_SQ) $(perllibdir_SQ)
2216: # Don't export a fixed $(localedir) path; it will be resolved by the Perl header
2227: 	    -e '	s|#!.*perl|#!$(PERL_PATH_SQ)|' \
2272: 	sed -e '1s|#!.*/sh|#!$(SHELL_PATH_SQ)|' \
2286: 	sed -e '1s|#!.*python|#!$(PYTHON_PATH_SQ)|' \
2293: 	sed -e '1s|#!.*/sh|#!$(SHELL_PATH_SQ)|' \
2404: 	'-DGIT_EXEC_PATH="$(gitexecdir_SQ)"' \
2405: 	'-DGIT_LOCALE_PATH="$(localedir_relative_SQ)"' \
2423: 	-DGIT_LOCALE_PATH='"$(localedir_relative_SQ)"'
2662: 	@echo SHELL_PATH=\''$(subst ','\'',$(SHELL_PATH_SQ))'\' >$@+
2663: 	@echo TEST_SHELL_PATH=\''$(subst ','\'',$(TEST_SHELL_PATH_SQ))'\' >>$@+
2664: 	@echo PERL_PATH=\''$(subst ','\'',$(PERL_PATH_SQ))'\' >>$@+
2666: 	@echo PYTHON_PATH=\''$(subst ','\'',$(PYTHON_PATH_SQ))'\' >>$@+
2716: ### Detect Python interpreter path changes
2718: TRACK_PYTHON = $(subst ','\'',-DPYTHON_PATH='$(PYTHON_PATH_SQ)')
2734: 	$(QUIET_GEN)sed -e '1s|#!.*/sh|#!$(SHELL_PATH_SQ)|' \
3053: 		SHELL_PATH='$(SHELL_PATH_SQ)' PERL_PATH='$(PERL_PATH_SQ)'
3139: .PHONY: shell_compatibility_test please_set_SHELL_PATH_to_a_more_modern_shell
600: # scripts to unexpected places.  If you like CDPATH, define it for your
602: unexport CDPATH
796: # Set paths to tools early so that they can be used for version tests.
825: LIB_OBJS += abspath.o
941: LIB_OBJS += pathspec.o
1333: 	EXTLIBS += -L$(LIBPCREDIR)/$(lib) $(CC_LD_DYNPATH)$(LIBPCREDIR)/$(lib)
1351: 		# Try "-Wl,-rpath=$(CURLDIR)/$(lib)" in such a case.
1353: 		CURL_LIBCURL = -L$(CURLDIR)/$(lib) $(CC_LD_DYNPATH)$(CURLDIR)/$(lib)
1391: 			EXPAT_LIBEXPAT = -L$(EXPATDIR)/$(lib) $(CC_LD_DYNPATH)$(EXPATDIR)/$(lib) -lexpat
1412: 		OPENSSL_LINK = -L$(OPENSSLDIR)/$(lib) $(CC_LD_DYNPATH)$(OPENSSLDIR)/$(lib)
1439: 			ICONV_LINK = -L$(ICONVDIR)/$(lib) $(CC_LD_DYNPATH)$(ICONVDIR)/$(lib)
1747: ifdef HAVE_PATHS_H
1748: 	BASIC_CFLAGS += -DHAVE_PATHS_H
1951: # RUNTIME_PREFIX's resolution logic requires resource paths to be expressed
2249: 	sed -e 's=@@PATHSEP@@=$(pathsep)=g' \
3217: GCOVFLAGS = --preserve-paths --branch-probabilities --all-blocks
github.com/git/git:cache.h: [ master, ]
1371: 	char *path;
1663: 	struct strbuf path;
576: #define READ_GITFILE_ERR_NO_PATH 6
1273: static inline int is_absolute_path(const char *path)
1365: 	struct strbuf symlink_path;
1381: #define GET_OID_RECORD_PATH     0200
473: #define EXEC_PATH_ENVIRONMENT "GIT_EXEC_PATH"
488: #define GIT_LITERAL_PATHSPECS_ENVIRONMENT "GIT_LITERAL_PATHSPECS"
489: #define GIT_GLOB_PATHSPECS_ENVIRONMENT "GIT_GLOB_PATHSPECS"
490: #define GIT_NOGLOB_PATHSPECS_ENVIRONMENT "GIT_NOGLOB_PATHSPECS"
491: #define GIT_ICASE_PATHSPECS_ENVIRONMENT "GIT_ICASE_PATHSPECS"
16: #include "path.h"
348: 				     const char *path,
362: 					       const char *path,
402: #define read_cache_from(path) read_index_from(&the_index, (path), (get_git_dir()))
412: #define remove_file_from_cache(path) remove_file_from_index(&the_index, (path))
413: #define add_to_cache(path, st, flags) add_to_index(&the_index, (path), (st), (flags))
414: #define add_file_to_cache(path, flags) add_file_to_index(&the_index, (path), (flags))
426: #define read_blob_data_from_cache(path, sz) read_blob_data_from_index(&the_index, (path), (sz))
492: #define GIT_QUARANTINE_ENVIRONMENT "GIT_QUARANTINE_PATH"
544: void set_git_dir(const char *path);
553:  * Return true if the given path is a git directory; note that this _just_
555:  * is a repository, you must feed that path, not just "foo".
557: int is_git_directory(const char *path);
560:  * Return 1 if the given path is the root of a git repository or
569: int is_nonbare_repository_dir(struct strbuf *path);
579: void read_gitfile_error_die(int error_code, const char *path, const char *dir);
580: const char *read_gitfile_gently(const char *path, int *return_error_code);
581: #define read_gitfile(path) read_gitfile_gently((path), NULL)
583: #define resolve_gitdir(path) resolve_gitdir_gently((path), NULL)
602: char *prefix_path(const char *prefix, int len, const char *path);
603: char *prefix_path_gently(const char *prefix, int len, int *remaining, const char *path);
606:  * Concatenate "prefix" (if len is non-zero) and "path", with no
608:  * Unlike prefix_path, this should be used if the named file does
615: char *prefix_filename(const char *prefix, const char *path);
622: int path_inside_repo(const char *prefix, const char *path);
680: int do_read_index(struct index_state *istate, const char *path,
682: int read_index_from(struct index_state *, const char *path,
726: int verify_path(const char *path, unsigned mode);
778: int remove_file_from_index(struct index_state *, const char *path);
785:  * These two are used to add the contents of the file at path
788:  * that has already run lstat(2) on the path can call
793: int add_to_index(struct index_state *, const char *path, struct stat *, int flags);
794: int add_file_to_index(struct index_state *, const char *path, int flags);
822: ...(24 bytes skipped)...x_state *istate, struct object_id *oid, int fd, struct stat *st, enum object_type type, const char *path, unsigned flags);
823: int index_path(struct index_state *istate, struct object_id *oid, const char *path, struct stat *st, unsigned flags);
879: extern int quote_path_fully;
890: extern const char *git_hooks_path;
1024:  * Read the repository format characteristics from the config file "path" into
1031: int read_repository_format(struct repository_format *format, const char *path);
1048:  * Check the repository format version in the path found in get_git_dir(),
1197: int adjust_shared_perm(const char *path);
1200:  * Create the directory containing the named path, using care to be
1206:  * path existed at one point during the function call and then
1212:  * safe_create_leading_directories() temporarily changes path while it
1214:  * safe_create_leading_directories_const() doesn't modify path, even
1224: enum scld_error safe_create_leading_directories(char *path);
1225: enum scld_error safe_create_leading_directories_const(const char *path);
1229:  * expected to do something that makes dirname(path) permanent despite
1232:  * path, but alternatively it could create another file in that
1238:  * - ENOENT -- dirname(path) does not exist. In this case,
1239:  *             raceproof_create_file() tries creating dirname(path)
1255: typedef int create_file_fn(const char *path, void *cb);
1258:  * Create a file in dirname(path) by calling fn, creating leading
1261:  * contains path. See the documentation for create_file_fn for more
1268: int raceproof_create_file(const char *path, create_file_fn fn, void *cb);
1270: int mkdir_in_gitdir(const char *path);
1271: char *expand_user_path(const char *path, int real_home);
1272: const char *enter_repo(const char *path, int strict);
1275: 	return is_dir_sep(path[0]) || has_dos_drive_prefix(path);
1278: char *strbuf_realpath(struct strbuf *resolved, const char *path,
1280: const char *real_path(const char *path);
1281: const char *real_path_if_valid(const char *path);
1282: char *real_pathdup(const char *path, int die_on_error);
1283: const char *absolute_path(const char *path);
1284: char *absolute_pathdup(const char *path);
1285: const char *remove_leading_path(const char *in, const char *prefix);
1286: const char *relative_path(const char *in, const char *prefix, struct strbuf *sb);
1287: int normalize_path_copy_len(char *dst, const char *src, int *prefix_len);
1288: int normalize_path_copy(char *dst, const char *src);
1289: int longest_ancestor_length(const char *path, struct string_list *prefixes);
1290: char *strip_path_suffix(const char *path, const char *suffix);
1291: int daemon_avoid_alias(const char *path);
1362: 	 * symlink_path is only used by get_tree_entry_follow_symlinks,
1367: 	 * If GET_OID_RECORD_PATH is set, this will record path (if any)
1401: 		       * Somewhere along the symlink chain, a path is
1671: 	strbuf_release(&cache->path);
1674: int has_symlink_leading_path(const char *name, int len);
1675: int threaded_has_symlink_leading_path(struct cache_def *, const char *, int);
1676: int check_leading_path(const char *name, int len);
1677: int has_dirs_only_path(const char *name, int len, int prefix_len);
1763:  * Open (and truncate) the file at path, write the contents of buf to it,
1766: void write_file_buf(const char *path, const char *buf, size_t len);
1773:  *   write_file(path, "counter: %d", ctr);
1776: void write_file(const char *path, const char *fmt, ...);
1876:  * Returns 1 if the path is a regular file (or a symlink to a regular
1881: int stat_validity_check(struct stat_validity *sv, const char *path);
181: /* used to temporarily mark paths matched by pathspecs */
208: struct pathspec;
403: #define read_cache_preload(pathspec) repo_read_index_preload(the_repository, (pathspec), 0)
425: #define unmerge_cache(pathspec) unmerge_index(&the_index, pathspec)
678: 		   const struct pathspec *pathspec,
850: int refresh_index(struct index_state *, unsigned int flags, const struct pathspec *pathspec, char *seen, const char *header_msg);
866: ...(32 bytes skipped)...(struct repository*, unsigned int refresh_flags, unsigned int write_flags, int gentle, const struct pathspec *, char *seen, const char *header_msg);
1653: int checkout_entry(struct cache_entry *ce, const struct checkout *state, char *topath, int *nr_checkouts);
1804: int add_files_to_cache(const char *prefix, const struct pathspec *pathspec, int flags);
github.com/angular/angular-cli:etc/api/angular_devkit/core/src/_golden-api.d.ts: [ master, ]
17:     readonly path: Path;
61:     path: string;
198:     path: Path;
204:     path: Path;
332:     readonly path: Path;
704: export declare const path: TemplateTag<Path>;
706: export declare type Path = string & {
79: export declare function asPosixPath(path: Path): PosixPath;
710: export declare class PathCannotBeFragmentException extends BaseException {
722: export declare class PathIsFileException extends BaseException {
748: export declare type PosixPath = string & {
16: export declare class AmbiguousProjectPathException extends BaseException {
11:     protected _aliases: Map<Path, Path>;
12:     readonly aliases: Map<Path, Path>;
13:     protected _resolve(path: Path): Path;
19:     constructor(path: Path, projects: ReadonlyArray<string>);
25:     pageview(path: string, options?: PageviewOptions): void;
81: export declare function asWindowsPath(path: Path): WindowsPath;
87: export declare function basename(path: Path): PathFragment;
155:     constructor(path: string);
160:     protected _filesToCreate: Set<Path>;
161:     protected _filesToDelete: Set<Path>;
162:     protected _filesToOverwrite: Set<Path>;
163:     protected _filesToRename: Map<Path, Path>;
164:     protected _filesToRenameRevert: Map<Path, Path>;
170:     create(path: Path, content: FileBuffer): Observable<void>;
171:     delete(path: Path): Observable<void>;
172:     exists(path: Path): Observable<boolean>;
173:     isDirectory(path: Path): Observable<boolean>;
174:     isFile(path: Path): Observable<boolean>;
175:     list(path: Path): Observable<PathFragment[]>;
176:     overwrite(path: Path, content: FileBuffer): Observable<void>;
177:     read(path: Path): Observable<FileBuffer>;
179:     rename(from: Path, to: Path): Observable<void>;
180:     stat(path: Path): Observable<Stats | null> | null;
181:     watch(path: Path, options?: HostWatchOptions): null;
182:     willCreate(path: Path): boolean;
183:     willDelete(path: Path): boolean;
184:     willOverwrite(path: Path): boolean;
185:     willRename(path: Path): boolean;
186:     willRenameTo(path: Path, to: Path): boolean;
187:     write(path: Path, content: FileBuffer): Observable<void>;
193:     path: Path;
210:     from: Path;
212:     to: Path;
254: export declare function dirname(path: Path): Path;
258:     exists(path: Path): Observable<boolean>;
259:     isDirectory(path: Path): Observable<boolean>;
260:     isFile(path: Path): Observable<boolean>;
261:     list(path: Path): Observable<PathFragment[]>;
262:     read(path: Path): Observable<FileBuffer>;
263:     stat(path: Path): Observable<Stats<{}> | null>;
271: export declare function extname(path: Path): string;
274:     constructor(path: string);
286:     constructor(path: string);
301:     pageview(path: string, options?: PageviewOptions): void;
306: export declare function fragment(path: string): PathFragment;
308: export declare function getSystemPath(path: Path): string;
321:     delete(path: Path): Observable<void>;
322:     rename(from: Path, to: Path): Observable<void>;
323:     watch(path: Path, options?: HostWatchOptions): Observable<HostWatchEvent> | null;
324:     write(path: Path, content: FileBufferLike): Observable<void>;
364:     constructor(path: string);
373: export declare function isAbsolute(p: Path): boolean;
385: export declare function join(p1: Path, ...others: string[]): Path;
576:     path: string[];
584:     pageview(path: string, options?: PageviewOptions): void;
600:     constructor(path: string);
608:     pageview(path: string, options?: PageviewOptions): void;
651: export declare function noCacheNormalize(path: string): Path;
661: export declare function normalize(path: string): Path;
663: export declare const NormalizedRoot: Path;
665: export declare const NormalizedSep: Path;
684:     path?: string;
707:     __PRIVATE_DEVKIT_PATH: void;
711:     constructor(path: string);
714: export declare type PathFragment = Path & {
715:     __PRIVATE_DEVKIT_PATH_FRAGMENT: void;
719:     constructor(path: string);
723:     constructor(path: string);
727:     constructor(path: string);
732:     path: string;
733:     constructor(path: string, exception: JsonException);
738:     protected _resolve(path: Path): Path;
749:     __PRIVATE_DEVKIT_POSIX_PATH: void;
811:     exists(path: Path): Observable<boolean>;
812:     isDirectory(path: Path): Observable<boolean>;
813:     isFile(path: Path): Observable<boolean>;
814:     list(path: Path): Observable<PathFragment[]>;
815:     read(path: Path): Observable<FileBuffer>;
816:     stat(path: Path): Observable<Stats<StatsT> | null> | null;
819: export declare function readWorkspace(path: string, host: WorkspaceHost, format?: WorkspaceFormat): Promise<{
839: export declare function relative(from: Path, to: Path): Path;
841: export declare type ReplacementFunction = (path: Path) => Path;
854: export declare function resolve(p1: Path, p2: Path): Path;
860:     protected abstract _resolve(path: Path): Path;
861:     delete(path: Path): Observable<void>;
862:     exists(path: Path): Observable<boolean>;
863:     isDirectory(path: Path): Observable<boolean>;
864:     isFile(path: Path): Observable<boolean>;
865:     list(path: Path): Observable<PathFragment[]>;
866:     read(path: Path): Observable<FileBuffer>;
867:     rename(from: Path, to: Path): Observable<void>;
868:     stat(path: Path): Observable<Stats<T> | null> | null;
869:     watch(path: Path, options?: HostWatchOptions): Observable<HostWatchEvent> | null;
870:     write(path: Path, content: FileBuffer): Observable<void>;
876:     exists(path: Path): Observable<boolean>;
877:     isDirectory(path: Path): Observable<boolean>;
878:     isFile(path: Path): Observable<boolean>;
879:     list(path: Path): Observable<PathFragment[]>;
880:     read(path: Path): Observable<FileBuffer>;
881:     stat(path: Path): Observable<Stats<StatsT> | null> | null;
940:     protected _root: Path;
941:     constructor(delegate: Host<T>, _root?: Path);
942:     protected _resolve(path: Path): Path;
952:     protected _cache: Map<Path, Stats<SimpleMemoryHostStats>>;
955:     protected _delete(path: Path): void;
956:     protected _exists(path: Path): boolean;
957:     protected _isDirectory(path: Path): boolean;
958:     protected _isFile(path: Path): boolean;
959:     protected _list(path: Path): PathFragment[];
982:     protected _read(path: Path): FileBuffer;
983:     protected _rename(from: Path, to: Path): void;
984:     protected _stat(path: Path): Stats<SimpleMemoryHostStats> | null;
985:     protected _toAbsolute(path: Path): Path;
986:     protected _updateWatchers(path: Path, type: HostWatchEventType): void;
987:     protected _watch(path: Path, options?: HostWatchOptions): Observable<HostWatchEvent>;
988:     protected _write(path: Path, content: FileBuffer): void;
989:     delete(path: Path): Observable<void>;
990:     exists(path: Path): Observable<boolean>;
991:     isDirectory(path: Path): Observable<boolean>;
992:     isFile(path: Path): Observable<boolean>;
993:     list(path: Path): Observable<PathFragment[]>;
994:     read(path: Path): Observable<FileBuffer>;
995:     rename(from: Path, to: Path): Observable<void>;
997:     stat(path: Path): Observable<Stats<{}> | null> | null;
998:     watch(path: Path, options?: HostWatchOptions): Observable<HostWatchEvent> | null;
999:     write(path: Path, content: FileBuffer): Observable<void>;
1010: export declare function split(path: Path): PathFragment[];
1036:     delete(path: Path): void;
1037:     exists(path: Path): boolean;
1038:     isDirectory(path: Path): boolean;
1039:     isFile(path: Path): boolean;
1040:     list(path: Path): PathFragment[];
1041:     read(path: Path): FileBuffer;
1042:     rename(from: Path, to: Path): void;
1043:     stat(path: Path): Stats<T> | null;
1044:     watch(path: Path, options?: HostWatchOptions): Observable<HostWatchEvent> | null;
1045:     write(path: Path, content: FileBufferLike): void;
1125:         path: Path;
1128:         from: Path;
1129:         to: Path;
1134:         readonly files: Path[];
1138:             [path: string]: string;
1140:         $exists(path: string): boolean;
1141:         $isDirectory(path: string): boolean;
1142:         $isFile(path: string): boolean;
1143:         $list(path: string): PathFragment[];
1144:         $read(path: string): string;
1145:         $write(path: string, content: string): void;
1146:         protected _delete(path: Path): void;
1147:         protected _exists(path: Path): boolean;
1148:         protected _isDirectory(path: Path): boolean;
1149:         protected _isFile(path: Path): boolean;
1150:         protected _list(path: Path): PathFragment[];
1151:         protected _read(path: Path): ArrayBuffer;
1152:         protected _rename(from: Path, to: Path): void;
1153:         protected _stat(path: Path): Stats<SimpleMemoryHostStats> | null;
1154:         protected _watch(path: Path, options?: HostWatchOptions): Observable<HostWatchEvent>;
1155:         protected _write(path: Path, content: FileBuffer): void;
1200:     __PRIVATE_DEVKIT_WINDOWS_PATH: void;
1206:     readonly root: Path;
1208:     constructor(_root: Path, _host: virtualFs.Host<{}>, registry?: schema.CoreSchemaRegistry);
1212:     getProjectByPath(path: Path): string | null;
1219:     loadWorkspaceFromHost(workspacePath: Path): Observable<this>;
1223:     static findWorkspaceFile(host: virtualFs.Host<{}>, path: Path): Promise<Path | null>;
1224:     static fromPath(host: virtualFs.Host<{}>, path: Path, registry: schema.CoreSchemaRegistry): Promise<Workspace>;
1233:     constructor(path: Path);
1241:     isDirectory(path: string): Promise<boolean>;
1242:     isFile(path: string): Promise<boolean>;
1243:     readFile(path: string): Promise<string>;
1244:     writeFile(path: string, data: string): Promise<void>;
1291: export declare function writeWorkspace(workspace: WorkspaceDefinition, host: WorkspaceHost, path?: string, format?: WorkspaceFormat): Promise<void>;
718: export declare class PathIsDirectoryException extends BaseException {
726: export declare class PathMustBeAbsoluteException extends BaseException {
730: export declare class PathSpecificJsonException extends JsonException {
922:     dataPath: string;
1199: export declare type WindowsPath = string & {
363: export declare class InvalidPathException extends BaseException {
github.com/angular/angular.js:package.json: [ master, ]
113:       "path": "node_modules/cz-conventional-changelog"
26:     "canonical-path": "0.0.2",
github.com/apache/hadoop:hadoop-ozone/common/src/main/proto/OzoneManagerProtocol.proto: [ trunk, ]
532:   required string path = 3;
296:     INVALID_PATH_IN_ACL_REQUEST = 53; // Invalid path name in acl request.
github.com/apache/hadoop:hadoop-hdfs-project/hadoop-hdfs-client/src/main/proto/ClientNamenodeProtocol.proto: [ trunk, ]
129:   required string path = 1;
487:   required string path = 1;
529:   optional string path = 2;
653:   required string path = 1;
661:   required string path = 1;
669:   required string path = 1;
708:   required string path = 1;
789:   required string path = 1;
819:   optional string path = 3;
824:   required string path = 2;
711:   optional string targetPath = 1;
754:   required string snapshotPath = 1;
1014:   rpc getEZForPath(GetEZForPathRequestProto)
1015:       returns(GetEZForPathResponseProto);
github.com/google/cadvisor:vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go: [ master, ]
215: 	Path   [108]int8
816: 	AT_EMPTY_PATH   = 0x1000
14: 	PathMax        = 0x1000
566: 	RTA_MULTIPATH           = 0x9
github.com/Polymer/polymer:interfaces.d.ts: [ master, ]
59:   path: string;
54:  * @template B The object matching the non-wildcard portion of the path.
55:  * @template V Additional types that could be set at the path.
58:   /** Path to the property that changed. */
60:   /** The object matching the non-wildcard portion of the path. */
62:   /** New value of the path that changed. */
github.com/google/gvisor:pkg/abi/linux/socket.go: [ master, ]
267: 	Path   [UnixPathMax]int8
262: const UnixPathMax = 108
259: // UnixPathMax is the maximum length of the path in an AF_UNIX socket.
github.com/google/closure-compiler:contrib/externs/maps/google_maps_api_v3_32.js: [ master, ]
1343: google.maps.DirectionsStep.prototype.path;
3872: google.maps.PathElevationRequest.prototype.path;
3942: google.maps.PolyMouseEvent.prototype.path;
4209: google.maps.PolylineOptions.prototype.path;
5044: google.maps.Symbol.prototype.path;
1272: google.maps.DirectionsRoute.prototype.overview_path;
1604: google.maps.ElevationService.prototype.getElevationAlongPath = function(request, callback) {};
3867: google.maps.PathElevationRequest = function() {};
3974: google.maps.Polygon.prototype.getPath = function() {};
4014: google.maps.Polygon.prototype.setPath = function(path) {};
4071: google.maps.PolygonOptions.prototype.paths;
4128: google.maps.Polyline.prototype.getPath = function() {};
4163: google.maps.Polyline.prototype.setPath = function(path) {};
5630: google.maps.geometry.encoding.decodePath = function(encodedPath) {};
5636: google.maps.geometry.encoding.encodePath = function(path) {};
3979: google.maps.Polygon.prototype.getPaths = function() {};
4020: google.maps.Polygon.prototype.setPaths = function(paths) {};
4011: ...(5 bytes skipped)...aram {google.maps.MVCArray<google.maps.LatLng>|Array<google.maps.LatLng|google.maps.LatLngLiteral>} path
4160: ...(5 bytes skipped)...aram {google.maps.MVCArray<google.maps.LatLng>|Array<google.maps.LatLng|google.maps.LatLngLiteral>} path
5633:  * @param {Array<google.maps.LatLng>|google.maps.MVCArray<google.maps.LatLng>} path
5660:  * @param {Array<google.maps.LatLng>|google.maps.MVCArray<google.maps.LatLng>} path
5664: google.maps.geometry.spherical.computeArea = function(path, radius) {};
5682:  * @param {Array<google.maps.LatLng>|google.maps.MVCArray<google.maps.LatLng>} path
5686: google.maps.geometry.spherical.computeLength = function(path, radius) {};
1600:  * @param {!google.maps.PathElevationRequest} request
3877: google.maps.PathElevationRequest.prototype.samples;
4017: ...(127 bytes skipped)...google.maps.LatLng|google.maps.LatLngLiteral>>|Array<google.maps.LatLng|google.maps.LatLngLiteral>} paths
5042:  * @type {google.maps.SymbolPath|string}
5074: google.maps.SymbolPath = {
5627:  * @param {string} encodedPath
github.com/GoogleChrome/puppeteer:lib/Page.js: [ master, ]
18: const path = require('path');
1104:   waitForXPath(xpath, options = {}) {
420:    * @param {!{url?: string, path?: string, content?: string, type?: string}} options
428:    * @param {!{url?: string, path?: string, content?: string}} options
859:     // options.type takes precedence over inferring the type from options.path
864:     } else if (options.path) {
865:       const mimeType = mime.getType(options.path);
930:     if (options.path)
931:       await writeFileAsync(options.path, buffer);
958:       path = null
995:     return await helper.readProtocolStream(this._client, result.stream, path);
1133:  * @property {string=} path
1156:  * @property {string=} path
1240:  * @property {string} path
1256:  * @property {string=} path
1338:     const files = filePaths.map(filePath => path.resolve(filePath));
1100:    * @param {string} xpath
1105:     return this.mainFrame().waitForXPath(xpath, options);
1332:    * @param {!Array<string>} filePaths
1335:   async accept(filePaths) {
github.com/google/gvisor:pkg/p9/p9.go: [ master, ]
430: 	Path uint64
429: 	// Path is a unique server identifier for this path (e.g. inode).
435: 	return fmt.Sprintf("QID{Type: %d, Version: %d, Path: %d}", q.Type, q.Version, q.Path)
442: 	q.Path = b.Read64()
449: 	b.Write64(q.Path)
452: // QIDGenerator is a simple generator for QIDs that atomically increments Path
456: 	// to provide unique Path values for QIDs.
460: // Get returns a new 9P unique ID with a unique Path given a QID type.
469: 		Path:    atomic.AddUint64(&q.uids, 1),
github.com/google/WebFundamentals:gulp-tasks/build.js: [ master, ]
11: const path = require('path');
114:     outputPath: baseOutputPath,
137:     outputPath: baseOutputPath,
257:     outputPath: baseOutputPath,
285:     outputPath: baseOutputPath,
305:     outputPath: baseOutputPath,
326:     outputPath: baseOutputPath,
350:     outputPath: baseOutputPath,
369:     outputPath: global.WF.src.content,
46:         outputPath: path.join(opts.outputPath, year),
107:   const baseOutputPath = path.join(global.WF.src.content, section);
116:   const startPath = path.join(global.WF.src.content, section);
130:   const baseOutputPath = path.join(global.WF.src.content, section);
139:   const startPath = path.join(global.WF.src.content, 'showcase');
145:   options.template = path.join(global.WF.src.templates, 'showcase/index.yaml');
153:   options.template = path.join(global.WF.src.templates, 'showcase/region.md');
154:   options.outputPath = path.join(baseOutputPath, 'region');
159:   options.template = path.join(global.WF.src.templates, 'showcase/vertical.md');
160:   options.outputPath = path.join(baseOutputPath, 'vertical');
165:   options.outputPath = path.join(baseOutputPath, 'tags');
173:     options.outputPath = path.join(baseOutputPath, year);
200:     let template = path.join(global.WF.src.templates, 'shows', 'index.md');
201:     let outputFile = path.join(global.WF.src.content, 'shows', 'index.md');
206:     template = path.join(global.WF.src.templates, 'shows', 'latest.html');
207:     outputFile = path.join(
213:     template = path.join(
215:     outputFile = path.join(global.WF.src.content, '_index-latest-show.html');
233:           outputPath: path.join(global.WF.src.content, 'shows', year),
245:   const baseOutputPath = path.join(global.WF.src.content, src);
272:   const baseOutputPath = path.join(global.WF.src.content, src);
300:   const baseOutputPath = path.join(global.WF.src.content, section);
307:   const startPath = path.join(global.WF.src.content, section);
321:   const baseOutputPath = path.join(global.WF.src.content, section);
328:   const startPath = path.join(global.WF.src.content, section);
343:   const baseOutputPath = path.join(global.WF.src.content, section);
352:   const startPath = path.join(global.WF.src.content, section);
358:   options.outputPath = path.join(baseOutputPath, 'tags');
362:     options.outputPath = path.join(baseOutputPath, year);
375:   const template = path.join(
383:   const outFile = path.join(
117:   const files = wfHelper.getFileList(startPath, ['**/*.md']);
141:   let files = wfHelper.getFileList(startPath, patterns);
182:   options.outputPath = baseOutputPath;
260:   let files = wfHelper.getFileList(baseOutputPath, ['*.md', '!index.md']);
288:   let files = wfHelper.getFileList(baseOutputPath, ['*.md', '!index.md']);
308:   let files = wfHelper.getFileList(startPath, ['**/*.md']);
329:   let files = wfHelper.getFileList(startPath, ['**/*.md']);
354:   let files = wfHelper.getFileList(startPath, patterns);
392:     outputPath: baseOutputPath,
github.com/google/filament:third_party/glslang/glslang/Include/intermediate.h: [ master, ]
1707:     TVector<TIntermNode *> path;
51:     #pragma warning(disable : 4464) // relative include path contains '..'
1681:         path.push_back(current);
1687:         path.pop_back();
1692:         return path.size() == 0 ? NULL : path.back();
github.com/google/code-prettify:src/node_prettify.js: [ master, ]
1705: var path = require('path');
1711:   includePaths: [
36:  *   {@code <script type="text/javascript" src="/path/to/prettify.js"></script>}
1713:     path.resolve(__dirname, '../styles')
1710:   // include paths for css preprocessor support
github.com/google/closure-compiler:contrib/externs/maps/google_maps_api_v3_25.js: [ master, ]
1406: google.maps.DirectionsStep.prototype.path;
4039: google.maps.PathElevationRequest.prototype.path;
4109: google.maps.PolyMouseEvent.prototype.path;
4387: google.maps.PolylineOptions.prototype.path;
5258: google.maps.Symbol.prototype.path;
1335: google.maps.DirectionsRoute.prototype.overview_path;
1667: google.maps.ElevationService.prototype.getElevationAlongPath = function(request, callback) {};
4034: google.maps.PathElevationRequest = function() {};
4145: google.maps.Polygon.prototype.getPath = function() {};
4187: google.maps.Polygon.prototype.setPath = function(path) {};
4244: google.maps.PolygonOptions.prototype.paths;
4305: google.maps.Polyline.prototype.getPath = function() {};
4341: google.maps.Polyline.prototype.setPath = function(path) {};
5815: google.maps.geometry.encoding.decodePath = function(encodedPath) {};
5821: google.maps.geometry.encoding.encodePath = function(path) {};
4151: google.maps.Polygon.prototype.getPaths = function() {};
4193: google.maps.Polygon.prototype.setPaths = function(paths) {};
4184: ...(5 bytes skipped)...aram {google.maps.MVCArray<google.maps.LatLng>|Array<google.maps.LatLng|google.maps.LatLngLiteral>} path
4338: ...(5 bytes skipped)...aram {google.maps.MVCArray<google.maps.LatLng>|Array<google.maps.LatLng|google.maps.LatLngLiteral>} path
5818:  * @param {Array<google.maps.LatLng>|google.maps.MVCArray<google.maps.LatLng>} path
5845:  * @param {Array<google.maps.LatLng>|google.maps.MVCArray<google.maps.LatLng>} path
5849: google.maps.geometry.spherical.computeArea = function(path, opt_radius) {};
5867:  * @param {Array<google.maps.LatLng>|google.maps.MVCArray<google.maps.LatLng>} path
5871: google.maps.geometry.spherical.computeLength = function(path, opt_radius) {};
1663:  * @param {google.maps.PathElevationRequest|Object.<string>} request
4044: google.maps.PathElevationRequest.prototype.samples;
4190: ...(127 bytes skipped)...google.maps.LatLng|google.maps.LatLngLiteral>>|Array<google.maps.LatLng|google.maps.LatLngLiteral>} paths
5256:  * @type {google.maps.SymbolPath|string}
5288: google.maps.SymbolPath = {
5812:  * @param {string} encodedPath
github.com/llvm-mirror/llvm:include/llvm/BinaryFormat/MachO.h: [ master, ]
787:   uint32_t path;
784: struct rpath_command {
1202:   sys::swapByteOrder(r.path);
1199: inline void swapStruct(rpath_command &r) {
github.com/kubernetes/dashboard:src/app/frontend/typings/backendapi.d.ts: [ master, ]
863:   path: string;
868:   path: string;
874:   path: string;
911:   path: string;
1134:   path: string;
1085:   hostPath: HostPathVolumeSource;
862: export interface HostPathVolumeSource {
github.com/GoogleChrome/chrome-app-samples:samples/gdrive/js/angular-1.1.0.min.js: [ master, ]
53: function va(b,a){var c=Gb.exec(b),c={protocol:c[1],host:c[3],port:G(c[5])||Hb[c[1]]||null,path...(120 bytes skipped)...,c){return b+"://"+a+(c==Hb[b]?"":":"+c)}function Fc(b,a,c){var d=va(b);return decodeURIComponent(d.path...(80 bytes skipped)...,a.lastIndexOf("/"))+d.hash.substr(c.length)}function Gc(b,a,c){var d=va(b);if(decodeURIComponent(d.path)==
122: ...(57 bytes skipped)...ce:!1,absUrl:Ka("$$absUrl"),url:function(a,c){if(v(a))return this.$$url;var d=ac.exec(a);d[1]&&this.path...(60 bytes skipped)...");this.hash(d[5]||"",c);return this},protocol:Ka("$$protocol"),host:Ka("$$host"),port:Ka("$$port"),path:Jb("$$path",function(a){return a.charAt(0)=="/"?a:"/"+a}),search:function(a,c){if(v(a))return this.$$search;x(...(69 bytes skipped)...
32: ...(64 bytes skipped)...ar V={},z="",M=f.baseHref();f.cookies=function(a,b){var d,e,f,g;if(a)if(b===s)i.cookie=escape(a)+"=;path="+M+";expires=Thu, 01 Jan 1970 00:00:00 GMT";else{if(F(b))d=(i.cookie=escape(a)+"="+escape(b)+";path="+M).length+1,d>4096&&c.warn("Cookie '"+a+"' possibly not set or overflowed because it was too larg...(138 bytes skipped)...
54: ...(11 bytes skipped)...else{var e=d.search&&"?"+d.search||"",g=d.hash&&"#"+d.hash||"",h=a.substr(0,a.lastIndexOf("/")),f=d.path.substr(h.length);if(d.path.indexOf(h)!==0)throw y('Invalid url "'+b+'", missing path...(45 bytes skipped)...st,d.port)+a+"#"+c+f+e+g}}function hb(b,a,c){a=a||"";this.$$parse=function(b){var c=va(b,this);if(c.path.indexOf(a)!==0)throw y('Invalid url "'+b+'", missing path prefix "'+a+'" !');this.$$path=decodeURIComponent(c.path.substr(a.length));this.$$search=Ya(c.search);
55: ...(77 bytes skipped)...ompose=function(){var b=pb(this.$$search),c=this.$$hash?"#"+$a(this.$$hash):"";this.$$url=Fb(this.$$path)+(b?"?"+b:"")+c;this.$$absUrl=ka(this.$$protocol,this.$$host,this.$$port)+a+this.$$url};this.$$rewr...(220 bytes skipped)...
56: a+'" !');d=c.path+(c.search?"?"+c.search:"");c=Hc.exec((c.hash||"").substr(a.length));this.$$path...(159 bytes skipped)...ompose=function(){var b=pb(this.$$search),c=this.$$hash?"#"+$a(this.$$hash):"";this.$$url=Fb(this.$$path)+(b?"?"+b:"")+c;this.$$absUrl=ka(this.$$protocol,this.$$host,this.$$port)+d+(this.$$url?"#"+a+this....(61 bytes skipped)...
58: ...(218 bytes skipped)...ew hb(Fc(k,i,b),j,l):new Ib(Gc(k,i,b),b,l,i.substr(j.length+1))):(l=ka(l.protocol,l.host,l.port)+(l.path||"")+(l.search?"?"+l.search:"")+"#"+b+"/",f=new Ja(k,b,l));g.bind("click",function(a){if(!a.ctrlKey...(84 bytes skipped)...
79: ...(7 bytes skipped)... if(b||i)n=!1,a.$broadcast("$routeChangeStart",b,i),(p.current=b)&&b.redirectTo&&(F(b.redirectTo)?c.path(k(b.redirectTo,b.params)).search(b.params).replace():c.url(b.redirectTo(b.pathParams,c.path(),c.search())).replace()),e.when(b).then(function(){if(b){var a=[],c=[],d;m(b.resolve||{},function(...(224 bytes skipped)...
80: ...(174 bytes skipped)...ent&&a.$broadcast("$routeChangeError",b,i,c)})}function j(){var a,d;m(b,function(b,e){if(!d&&(a=l(c.path(),e)))d=ya(b,{params:D({},c.search(),a),pathParams:a}),d.$route=b});return d||b[null]&&ya(b[null],{params:{},pathParams:{}})}function k(a,b){var c=[];m((a||"").split(":"),function(a,d){if(d==0)c.push(a);else{var e...(22 bytes skipped)...
78: ...(315 bytes skipped)...ache",function(a,c,d,e,g,h,f){function i(){var b=j(),i=p.current;if(b&&i&&b.$route===i.$route&&ga(b.pathParams,i.pathParams)&&!b.reloadOnSearch&&!n)i.params=b.params,U(i.params,d),a.$broadcast("$routeUpdate",
github.com/kubernetes/ingress-nginx:vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go: [ master, ]
215: 	Path   [108]int8
816: 	AT_EMPTY_PATH   = 0x1000
14: 	PathMax        = 0x1000
566: 	RTA_MULTIPATH           = 0x9
github.com/kubernetes/ingress-nginx:vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go: [ master, ]
214: 	Path   [108]int8
810: 	AT_EMPTY_PATH   = 0x1000
14: 	PathMax        = 0x1000
565: 	RTA_MULTIPATH           = 0x9
github.com/google/end-to-end:lib/closure-compiler/contrib/externs/maps/google_maps_api_v3.js: [ master, ]
1344: google.maps.DirectionsStep.prototype.path;
3974: google.maps.PathElevationRequest.prototype.path;
4043: google.maps.PolyMouseEvent.prototype.path;
4321: google.maps.PolylineOptions.prototype.path;
5174: google.maps.Symbol.prototype.path;
1273: google.maps.DirectionsRoute.prototype.overview_path;
1605: google.maps.ElevationService.prototype.getElevationAlongPath = function(request, callback) {};
3969: google.maps.PathElevationRequest = function() {};
4079: google.maps.Polygon.prototype.getPath = function() {};
4121: google.maps.Polygon.prototype.setPath = function(path) {};
4178: google.maps.PolygonOptions.prototype.paths;
4239: google.maps.Polyline.prototype.getPath = function() {};
4275: google.maps.Polyline.prototype.setPath = function(path) {};
5723: google.maps.geometry.encoding.decodePath = function(encodedPath) {};
5729: google.maps.geometry.encoding.encodePath = function(path) {};
4085: google.maps.Polygon.prototype.getPaths = function() {};
4127: google.maps.Polygon.prototype.setPaths = function(paths) {};
4118: ...(5 bytes skipped)...aram {google.maps.MVCArray<google.maps.LatLng>|Array<google.maps.LatLng|google.maps.LatLngLiteral>} path
4272: ...(5 bytes skipped)...aram {google.maps.MVCArray<google.maps.LatLng>|Array<google.maps.LatLng|google.maps.LatLngLiteral>} path
5726:  * @param {Array<google.maps.LatLng>|google.maps.MVCArray<google.maps.LatLng>} path
5753:  * @param {Array<google.maps.LatLng>|google.maps.MVCArray<google.maps.LatLng>} path
5757: google.maps.geometry.spherical.computeArea = function(path, opt_radius) {};
5775:  * @param {Array<google.maps.LatLng>|google.maps.MVCArray<google.maps.LatLng>} path
5779: google.maps.geometry.spherical.computeLength = function(path, opt_radius) {};
1601:  * @param {google.maps.PathElevationRequest|Object.<string>} request
3979: google.maps.PathElevationRequest.prototype.samples;
4124: ...(127 bytes skipped)...google.maps.LatLng|google.maps.LatLngLiteral>>|Array<google.maps.LatLng|google.maps.LatLngLiteral>} paths
5172:  * @type {google.maps.SymbolPath|string}
5204: google.maps.SymbolPath = {
5720:  * @param {string} encodedPath
github.com/google/end-to-end:lib/closure-compiler/contrib/externs/maps/google_maps_api_v3_23.js: [ master, ] Duplicate result
github.com/google/or-tools:ortools/constraint_solver/constraint_solveri.h: [ master, ]
1296:   int64 Path(int64 node_index) const {
1313:   const std::vector<int64>& path_starts() const { return path_starts_; }
1429:   std::vector<int64> path_starts_;
1436:   std::vector<int> path_basis_;
1261: class PathOperator : public IntVarLocalSearchOperator {
1315:   int PathClass(int i) const {
1354:   int64 OldPath(int64 node_index) const {
1442: class PathWithPreviousNodesOperator : public PathOperator {
1395:   const bool ignore_path_vars_;
1398:   std::vector<int64> start_to_path_;
1433:   std::function<int(int64)> start_empty_path_class_;
1280:   ~PathOperator() override {}
1397:   int num_paths_ = 0;
1428:   std::vector<int> base_paths_;
1434:   bool skip_locally_optimal_paths_;
1435:   bool optimal_paths_enabled_;
1437:   std::vector<bool> optimal_paths_;
1448:   ~PathWithPreviousNodesOperator() override {}
1328:   virtual bool RestartAtPathStartOnSynchronize() { return false; }
1334:   virtual bool OnSamePathAsPreviousBase(int64 base_index) { return false; }
1381:   bool IsPathEnd(int64 i) const { return i >= number_of_nexts_; }
1450:   bool IsPathStart(int64 node_index) const { return prevs_[node_index] == -1; }
1248: /// Base class of the local search operators dedicated to path modifications
1249: /// (a path is a set of nodes linked together by arcs).
1252: /// a path).
1255: /// - path inspectors (Next(), IsPathEnd())
1256: /// - path iterators: operators need a given number of nodes to define a
1263:   /// Builds an instance of PathOperator from next and path variables.
1265:   /// neighbor. 'start_empty_path_class' is a callback returning an index such
1267:   /// c1 = start_empty_path_class(StartNode(p1)),
1268:   /// c2 = start_empty_path_class(StartNode(p2)),
1269:   /// p1 and p2 are path indices,
1272:   /// for instance if a node cannot be moved to an empty path, then all moves
1274:   /// 'start_empty_path_class' can be nullptr in which case no symmetries will
1277:                const std::vector<IntVar*>& path_vars, int number_of_base_nodes,
1279:                std::function<int(int64)> start_empty_path_class);
1294:   /// Returns the index of the path to which the node of index node_index
1297:     return ignore_path_vars_ ? 0LL : Value(node_index + number_of_nexts_);
1309:   /// Returns the index of the variable corresponding to the current path
1311:   int64 StartNode(int i) const { return path_starts_[base_paths_[i]]; }
1312:   /// Returns the vector of path start nodes.
1314:   /// Returns the class of the current path of the ith base node.
1316:     return start_empty_path_class_ != nullptr
1317:                ? start_empty_path_class_(StartNode(i))
1329:   /// Returns true if a base node has to be on the same path as the "previous"
1331:   /// Useful to limit neighborhood exploration to nodes on the same path.
1336:   /// must be set to when it reaches the end of a path.
1337:   /// By default, it is set to the start of the current path.
1355:     return ignore_path_vars_ ? 0LL : OldValue(node_index + number_of_nexts_);
1370:   void SetNext(int64 from, int64 to, int64 path) {
1373:     if (!ignore_path_vars_) {
1375:       SetValue(from + number_of_nexts_, path);
1379:   /// Returns true if i is the last node on the path; defined by the fact that
1406:   /// Returns true if two nodes are on the same path in the current assignment.
1447:       std::function<int(int64)> start_empty_path_class);
1473:     std::function<int(int64)> start_empty_path_class);
32: ///     PathOperator, to create new local search operators.
1271:   /// This is used to remove neighborhood symmetries on equivalent empty paths;
1273:   /// moving the same node to equivalent empty paths will be skipped.
1276:   PathOperator(const std::vector<IntVar*>& next_vars,
1278:                bool skip_locally_optimal_paths,
1323:   /// from the start of the last paths explored; returns false to restart the
1325:   /// This is used to avoid restarting on base nodes which have changed paths,
1332:   // TODO(user): ideally this should be OnSamePath(int64 node1, int64 node2);
1391:   /// the paths.
1403:   /// overridden instead of OnStart() to avoid calling PathOperator::OnStart
1407:   bool OnSamePath(int64 node1, int64 node2) const;
1440: /// Simple PathOperator wrapper that also stores the current previous nodes,
1444:   PathWithPreviousNodesOperator(
1458:     return "PathWithPreviousNodesOperator";
1290:     DCHECK(!IsPathEnd(node_index));
1350:     DCHECK(!IsPathEnd(node_index));
1384:   bool IsInactive(int64 i) const { return !IsPathEnd(i) && inactives_[i]; }
1419:   void InitializePathStarts();
1441: /// and is thus able to provide the "Prev" and "IsPathStart" functions.
1453:     DCHECK(!IsPathStart(node_index));
github.com/apache/couchdb:src/chttpd/src/chttpd.erl: [ master, ]
587: path(#httpd{mochi_req=MochiReq}) ->
23:     qs_value/3, qs/1, qs_json_value/3, path/1, absolute_uri/2, body_length/1,
169:     % for the path, use the raw path with the query string and fragment
171:     RawUri = MochiReq:get(raw_path),
172:     {"/" ++ Path, _, _} = mochiweb_util:urlsplit_path(RawUri),
174:     % get requested path
175:     RequestedPath = case MochiReq:get_header_value("x-couchdb-vhost-path") of
177:             case MochiReq:get_header_value("x-couchdb-requested-path") of
228:         path_parts = [list_to_binary(chttpd:unquote(Part))
229:                 || Part <- string:tokens(Path, "/")],
230:         requested_path_parts = [?l2b(unquote(Part))
290:         case HttpReq#httpd.path_parts of
295:     RawUri = MochiReq:get(raw_path),
342:         MochiReq:get(raw_path),
398:     RawUri = MochiReq:get(raw_path),
411: possibly_hack(#httpd{path_parts=[<<"_replicate">>]}=Req) ->
547: partition(Path) ->
548:     mochiweb_util:partition(Path, "/").
588:     MochiReq:get(path).
590: absolute_uri(#httpd{mochi_req=MochiReq, absolute_uri = undefined}, Path) ->
624:     Scheme ++ "://" ++ Host ++ Path;
625: absolute_uri(#httpd{absolute_uri = URI}, Path) ->
626:     URI ++ Path.
928:         <<"At least one path segment of `", DbName/binary, "` is too long.">>};
1000:                                 % Redirect to the path the user requested, not
1002:                                 UrlReturnRaw = case MochiReq:get_header_value("x-couchdb-vhost-path") of
1004:                                     MochiReq:get(path);
1058: update_timeout_stats(<<"timeout">>, #httpd{requested_path_parts = PathParts}) ->
1060: update_timeout_stats(timeout, #httpd{requested_path_parts = PathParts}) ->
1102: send_redirect(Req, Path) ->
1103:     Headers = [{"Location", chttpd:absolute_uri(Req, Path)}],
231:                 || Part <- string:tokens(RequestedPath, "/")]
562: serve_file(Req, RelativePath, DocumentRoot) ->
563:     serve_file(Req, RelativePath, DocumentRoot, []).
565: serve_file(Req0, RelativePath0, DocumentRoot0, ExtraHeaders) ->
566:     couch_httpd:serve_file(Req0, RelativePath0, DocumentRoot0, ExtraHeaders).
1005:                                 VHostPath ->
1006:                                     VHostPath
1059:     update_timeout_stats(PathParts);
1061:     update_timeout_stats(PathParts);
1282: test_log_request(RawPath, UserCtx) ->
1284:     MochiReq = mochiweb_request:new(socket, [], 'POST', RawPath, version, Headers),
github.com/google/roboto:third_party/spiro/x3/x3.h: [ master, ]
106:     CGMutablePathRef path;
273: void x3closepath(x3dc *dc);
github.com/flutter/flutter_web:packages/flutter_web_ui/lib/assets/houdini_painter.js: [ master, ]
821: class Path {
212:   _drawRRectPath(ctx, rrect, startNewPath) {
367:   _clipPath(ctx, geom, command) {
400:   _drawPath(ctx, geom, command) {
444:   _runPath(ctx, path) {
578:   scanPath() {
864: class Subpath {
290:   _drawRRectPathReverse(ctx, rrect, startNewPath) {
360:     let path = new Path([]);
362:     path.subpaths.push(new Subpath(commands));
363:     this._runPath(ctx, path);
369:     let path = scanner.scanPath();
370:     this._runPath(ctx, path);
402:     let path = scanner.scanPath();
405:     this._runPath(ctx, path);
412:     let path = scanner.scanPath();
437:       this._runPath(ctx, path, true);
446:     for (let i = 0; i < path.subpaths.length; i++) {
447:       let subpath = path.subpaths[i];
482:             throw new Error(`Unknown path command ${command.type()}`);
580:     return new Path(subpaths);
855:             throw new Error(`Unsupported path command: ${pathCommand}`);
73:           this._clipPath(ctx, geom, command);
100:           this._drawPath(ctx, geom, command);
186:     ctx.beginPath();
197:     this._drawRRectPath(ctx, rrect, true);
207:     this._drawRRectPath(ctx, outer, true);
231:     if (startNewPath) {
232:       ctx.beginPath();
294:     if (startNewPath) {
295:       ctx.beginPath();
354:     ctx.beginPath();
382:     ctx.beginPath();
393:     ctx.beginPath();
445:     ctx.beginPath();
448:       for (let j = 0; j < subpath.commands.length; j++) {
449:         let command = subpath.commands[j];
451:           case PathCommandType.bezierCurveTo:
456:           case PathCommandType.close:
457:             ctx.closePath();
459:           case PathCommandType.ellipse:
465:           case PathCommandType.lineTo:
468:           case PathCommandType.moveTo:
471:           case PathCommandType.rrect:
472:             this._drawRRectPath(ctx, command.rrect, false);
474:           case PathCommandType.rect:
477:           case PathCommandType.quadraticCurveTo:
508:     ctx.beginPath();
519:     ctx.beginPath();
825:       let subpath = serializedSubpaths[i];
826:       let pathCommands = [];
827:       for (let j = 0; j < subpath.length; j++) {
828:         let pathCommand = subpath[j];
829:         switch (pathCommand[0]) {
831:             pathCommands.push(new MoveTo(pathCommand));
834:             pathCommands.push(new LineTo(pathCommand));
837:             pathCommands.push(new Ellipse(pathCommand));
840:             pathCommands.push(new QuadraticCurveTo(pathCommand));
843:             pathCommands.push(new BezierCurveTo(pathCommand));
846:             pathCommands.push(new RectCommand(pathCommand));
849:             pathCommands.push(new RRectCommand(pathCommand));
852:             pathCommands.push(new CloseCommand());
859:       this.subpaths.push(new Subpath(pathCommands));
877:     return PathCommandType.moveTo;
888:     return PathCommandType.lineTo;
905:     return PathCommandType.ellipse;
918:     return PathCommandType.quadraticCurveTo;
933:     return PathCommandType.bezierCurveTo;
946:     return PathCommandType.rect;
957:     return PathCommandType.rrect;
963:     return PathCommandType.close;
1045: const PathCommandType = {
208:     this._drawRRectPathReverse(ctx, inner, false);
579:     let subpaths = this.command[this.index++];
822:   constructor(serializedSubpaths) {
823:     this.subpaths = [];
824:     for (let i = 0; i < serializedSubpaths.length; i++) {
github.com/google/grr:grr/proto/grr_response_proto/jobs.proto: [ master, ]
583:   optional string path = 2;
591:   optional PathSpec nested_path = 5;
606:   optional Options path_options = 7
679:   repeated string path_list = 1
1110:   optional string write_path = 2;      // Path to write the binary to.
1271:   optional string path_glob = 13 [(sem_type) = {
1276:   optional string path_regex = 3 [(sem_type) = {
450:   optional PathSpec pathspec = 6;
572: message PathSpec {
573:   enum PathType {
581:   optional PathType pathtype = 1 [default = UNSET];
668:   optional PathSpec pathspec = 1;
673:   optional PathSpec pathspec = 1;
681:   optional PathSpec.PathType pathtype = 2 [
768:   optional PathSpec pathspec = 18 [(sem_type) = {
1036:   optional PathSpec pathspec = 1;
1050:   optional PathSpec pathspec = 3;
1145:   optional PathSpec pathspec = 1 [(sem_type) = {
1267:   optional PathSpec pathspec = 2 [(sem_type) = {
1356:   optional PathSpec pathspec = 1 [(sem_type) = {
1972:   optional PathSpec pathspec = 1;
570: // A message to encode a filesystem path (maybe for raw access)
600:     // The path component is a regular expression.
618:   // file - instead of the path.
666: // Ask the ListDir action to list all files in path (returns StatEntry)
683:       description: "Type of path to call statfs on.",
689: // A stat() record for a given path
693:   // optional string aff4path = 1;
769:     description: "The path specification to this file on the client."
1268:     description: "The base path to recursive search from ",
1278:     description: "This matches the filename. Overrides the path_glob.",
1361:     description: "A path into the plist to base the filter on",
1447:   // optional string path = 1;
1507:   // optional string path = 1;
435: //     - pathspec will be set to the desired file to read
603:     // Indicates that this pathspec represents any subdirectory recursively.
661:     description: "Indicates that this pathspec already contains a "
680:       [(sem_type) = { description: "List of paths for statfs." }];
767:   // The pathspec which the client can use to re-reach this file.
1146:     description: "The pathspec for the file to retrieve.",
1182:   optional PathSpec target = 1
1357:     description: "The pathspec for the plist file to query.",
github.com/apache/hive:standalone-metastore/metastore-server/src/main/sql/oracle/hive-schema-4.0.0.oracle.sql: [ master, ]
666:     PATH VARCHAR2(1024) NOT NULL,
946: CREATE UNIQUE INDEX UNIQUE_WM_POOL ON WM_POOL (RP_ID, PATH);
github.com/google/grr:grr/proto/grr_response_proto/flows.proto: [ master, ]
862:   optional string path = 1 [
1255:   optional string path = 1 [(sem_type) = {
605:   optional string blob_path = 1 [(sem_type) = {
897:   optional string history_path = 5 [(sem_type) = {
976:   optional PathSpec root_path = 3 [(sem_type) = {
1055:   optional string history_path = 5 [(sem_type) = {
1973:   repeated string path_list = 1 [(sem_type) = {
548:   optional PathSpec pathspec = 1 [(sem_type) = {
834:   optional PathSpec pathspec = 1 [(sem_type) = {
852:   optional PathSpec.PathType pathtype = 1 [
879:   optional PathSpec.PathType pathtype = 1 [
908:   optional PathSpec.PathType pathtype = 2 [
939:   optional PathSpec pathspec = 1
945:   optional PathSpec pathspec = 1
963:   repeated string paths = 1 [(sem_type) = {
969:   optional PathSpec.PathType pathtype = 2 [
1009:   optional PathSpec pathspec = 1
1040:   optional PathSpec.PathType pathtype = 1 [
1245:   optional PathSpec.PathType pathtype = 3 [
1260:   optional PathSpec.PathType pathtype = 2 [
1297:   repeated PathSpec pathspecs = 2 [(sem_type) = {
1781:   repeated string paths = 1 [(sem_type) = {
1787:   optional PathSpec.PathType pathtype = 2 [
1874:   repeated PathSpec pathspecs = 2 [(sem_type) = {
1977:   optional PathSpec.PathType pathtype = 2 [
2388:   repeated PathSpec paths = 2;
813:   optional PathSpec found_pathspec = 3 [
1906:   repeated string keys_paths = 1 [(sem_type) = {
550:                  "If path is a directory, look in the top level for filenames "
551:                  "beginning with Client.tempfile_prefix, and delete them. If path "
572:       [(sem_type) = { description: "Relative path to the hack to execute." }];
607:     description: "An aff4 path to a GRRSignedBlob of a new client version.",
835:     description: "The file path to fingerprint.",
854:       description: "The requested path type.",
864:       description: "An AFF path (relative to the client area of the VFS).",
880:     (sem_type) = { description: "Type of path access to use." },
892:     description: "The user to get history for. If history_path is "
893:                  "not set this will be used to guess the path to the "
898:     description: "Path to a profile directory that contains a History file.",
909:     (sem_type) = { description: "Type of path access to use." },
965:     description: "A list of paths to glob that supports: ** path recursion,"
977:     description: "The root path to begin the glob.  Users should almost never"
978:                  " need to change this. root_path.pathtype is unused in"
1041:     (sem_type) = { description: "Type of path access to use." },
1050:     description: "The user to get Chrome history for. If history_path is "
1051:                  "not set this will be used to guess the path to the "
1056:     description: "Path to a profile directory that contains a History "
1256:     description: "A path to a Chrome Extensions directory. If not set, "
1257:                  "the path is guessed from the username."
1373:                    "applied to the full path and not only to the filename.",
1783:     description: "A path to glob that can contain %% "
1789:       description: "Path type to glob in.",
1803:                  " the path arguments.",
1913:                  " the keys path arguments.",
1979:       description: "Type of path. Only OS is currently supported.",
549:     description: "The pathspec target for deletion."
762:                    " multiple artifacts or paths and want to report partial results.",
814:     (sem_type) = { description: "Pathspecs found in the collected artifacts." }
818:                  "pathspecs."
940:       [(sem_type) = { description: "The pathspec for the directory to list." }];
946:       [(sem_type) = { description: "The pathspec for the directory to list." }];
979:                  " favor of pathtype to allow it to be modified by users.",
1010:       [(sem_type) = { description: "The pathspec for the file to retrieve." }];
1298:     description: "Pathspecs of files to be retrieved.",
1367:   // TODO: Rename to filepath_regex.
1371:       friendly_name: "Filepath Regex",
1875:     description: "The paths to the files.",
1974:     description: "List of paths.",
2341:   optional PathSpec file = 3 [(sem_type) = {
2361:   repeated PathSpec dump_files = 2 [(sem_type) = {
github.com/GoogleChrome/puppeteer:experimental/puppeteer-firefox/lib/Page.js: [ master, ]
105:         path: cookie.path,
649:   async waitForXPath(xpath, options = {}) {
533: ...(15 bytes skipped)...ullPage?: boolean, clip?: {width: number, height: number, x: number, y: number}, encoding?: string, path?: string}} options
543:     if (options.path)
544:       await writeFileAsync(options.path, buffer);
563:    * @param {!{content?: string, path?: string, type?: string, url?: string}} options
571:    * @param {!{content?: string, path?: string, url?: string}} options
792:   // options.type takes precedence over inferring the type from options.path
801:   if (options.path) {
802:     const fileType = mime.getType(options.path);
645:    * @param {string} xpath
650:     return await this._frameManager.mainFrame().waitForXPath(xpath, options);
github.com/apache/hive:standalone-metastore/metastore-server/src/main/sql/mssql/hive-schema-4.0.0.mssql.sql: [ master, ]
662:     PATH nvarchar(1024) NOT NULL,
978: CREATE UNIQUE INDEX UNIQUE_WM_POOL ON WM_POOL (RP_ID, PATH);
github.com/apache/jmeter:src/core/org/apache/jmeter/resources/messages.properties: [ trunk, ]
782: path=Path\:
480: include_path=Include Test Plan
596: json_assertion_path=Assert JSON Path exists\:
783: path_extension_choice=Path Extension (use ";" as separator)
784: path_extension_dont_use_equals=Do not use equals in path extension (Intershop Enfinity compatibility)
785: path_extension_dont_use_questionmark=Do not use questionmark in path extension (Intershop Enfinity compatibility)
1403: view_results_table_request_http_path=Path
603: jsonpp_json_path_expressions=JSON Path expressions\:
589: jsonpath_renderer=JSON Path Tester
590: jsonpath_tester_title=JSON Path Tester
591: jsonpath_tester_field=JSON Path Expression
592: jsonpath_tester_button_test=Test
593: jsonpath_render_no_text=No Text
1208: string_to_file_pathname=Path to file (absolute) 
1266: test_plan_classpath_browse=Add directory or jar to classpath
1455: xpath_assertion_button=Validate
1456: xpath_assertion_check=Check XPath Expression
1457: xpath_assertion_error=Error with XPath
1458: xpath_assertion_failed=Invalid XPath Expression
1459: xpath_assertion_label=XPath
1460: xpath_assertion_negate=True if nothing matches
1461: xpath_assertion_option=XML Parsing Options
1462: xpath_assertion_test=XPath Assertion 
1463: xpath_assertion_tidy=Try and tidy up the input
1464: xpath_assertion_title=XPath Assertion
1465: xpath_assertion_valid=Valid XPath Expression
1466: xpath_assertion_validation=Validate the XML against the DTD
1467: xpath_assertion_whitespace=Ignore whitespace
1468: xpath_expression=XPath expression to match against
1469: xpath_extractor_fragment=Return entire XPath fragment instead of text content?
1470: xpath_extractor_query=XPath query:
1471: xpath_extractor_user_namespaces=<html>Namespaces aliases list <br>(prefix=full namespace, 1 per line) :</...(5 bytes skipped)...
1472: xpath_extractor_title=XPath Extractor
1473: xpath_file_file_name=XML file to get values from 
1474: xpath_tester=XPath Tester
1475: xpath2_tester=XPath2 Tester
1476: xpath_namespaces=Show namespaces aliases
1477: xpath_tester_button_test=Test
1478: xpath_tester_field=XPath query \:
1479: xpath_tester_fragment=Return entire XPath fragment instead of text content?
1480: xpath_tester_no_text=Data response result isn't text.
1481: xpath_tester_title=XPath Tester
1482: xpath_tidy_quiet=Quiet
1483: xpath_tidy_report_errors=Report errors
1484: xpath_tidy_show_warnings=Show warnings
1485: xpath2_extractor_title=XPath2 Extractor
1486: xpath2_extractor_empty_query=Empty XPath expression !
1487: xpath2_extractor_match_number_failure=MatchNumber out of bonds \:
548: jms_random_file=Path of folder containing random files suffixed with .dat for bytes messages, .txt or .obj for text and ...(15 bytes skipped)...
1094: send_file_filename_label=File Path
1205: string_from_file_file_name=Enter path (absolute or relative) to file
150: ...(7 bytes skipped)...castle_unavailable_message=The jars for bouncy castle are unavailable, please add them to your classpath.
502: java_request_warning=<html>Classname not found in classpath, ensure you add the required jar and restart. <br/> If you modify "Classname" before you may lose t...(46 bytes skipped)...
1171: smtp_truststore_tooltip=<html>The pathname of the truststore.<br />Relative paths are resolved against the current directory.<br />Failing that, against the directory containing th...(31 bytes skipped)...
1379: view_results_response_missing_tika=Missing tika-app.jar in classpath. Unable to convert to plain text this kind of document.\nDownload the tika-app-x.x.jar file from ht...(79 bytes skipped)...
github.com/googleapis/google-api-nodejs-client:src/apis/blogger/v3.ts: [ master, ]
3372:     path?: string;
2722:     getByPath(
3355:   export interface Params$Resource$Posts$Getbypath extends StandardParameters {
2709:      * @desc Retrieve a Post by Path.
2716:      * @param {string} params.path Path of the Post to retrieve.
2770:         requiredParams: ['blogId', 'path'],
3370:      * Path of the Post to retrieve.
658:         pathParams: ['blogId'],
730:         pathParams: [],
805:         pathParams: ['userId'],
949:         pathParams: ['blogId', 'userId'],
1050:         pathParams: ['blogId', 'commentId', 'postId'],
1123:         pathParams: ['blogId', 'commentId', 'postId'],
1197:         pathParams: ['blogId', 'commentId', 'postId'],
1277:         pathParams: ['blogId', 'postId'],
1357:         pathParams: ['blogId'],
1431:         pathParams: ['blogId', 'commentId', 'postId'],
1505:         pathParams: ['blogId', 'commentId', 'postId'],
1764:         pathParams: ['blogId', 'pageId'],
1836:         pathParams: ['blogId', 'pageId'],
1909:         pathParams: ['blogId'],
1985:         pathParams: ['blogId'],
2059:         pathParams: ['blogId', 'pageId'],
2130:         pathParams: ['blogId', 'pageId'],
2201:         pathParams: ['blogId', 'pageId'],
2275:         pathParams: ['blogId', 'pageId'],
2528:         pathParams: ['blogId'],
2622:         pathParams: ['blogId', 'postId'],
2697:         pathParams: ['blogId', 'postId'],
2708:      * blogger.posts.getByPath
2710:      * @alias blogger.posts.getByPath
2723:       params?: Params$Resource$Posts$Getbypath,
2726:     getByPath(
2727:       params: Params$Resource$Posts$Getbypath,
2731:     getByPath(
2732:       params: Params$Resource$Posts$Getbypath,
2735:     getByPath(callback: BodyResponseCallback<Schema$Post>): void;
2736:     getByPath(
2738:         | Params$Resource$Posts$Getbypath
2743:       let params = (paramsOrCallback || {}) as Params$Resource$Posts$Getbypath;
2748:         params = {} as Params$Resource$Posts$Getbypath;
2761:             url: (rootUrl + '/blogger/v3/blogs/{blogId}/posts/bypath').replace(
2771:         pathParams: ['blogId'],
2846:         pathParams: ['blogId'],
2927:         pathParams: ['blogId'],
3004:         pathParams: ['blogId', 'postId'],
3076:         pathParams: ['blogId', 'postId'],
3147:         pathParams: ['blogId', 'postId'],
3221:         pathParams: ['blogId'],
3298:         pathParams: ['blogId', 'postId'],
3668:         pathParams: ['blogId', 'postId', 'userId'],
3751:         pathParams: ['blogId', 'userId'],
3906:         pathParams: ['userId'],
github.com/apache/ignite:modules/web-console/frontend/app/configuration/generator/generator/defaults/Cluster.service.js: [ master, ]
54:             path: 'disco/tcp'
57:             basePath: '/services',
339:         storagePath: 'db',
367:         walPath: 'db/wal',
368:         walArchivePath: 'db/wal/archive',