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",

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 {

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 {

1245: PATH := $(SANE_TOOL_PATH):${PATH}

566: TCL_PATH = tclsh

567: TCLTK_PATH = wish

801: 	SHELL_PATH = /bin/sh

804: 	PERL_PATH = /usr/bin/perl

807: 	PYTHON_PATH = /usr/bin/python

813: TEST_SHELL_PATH = $(SHELL_PATH)

546: pathsep = :

1163: CC_LD_DYNPATH = -Wl,-rpath,

1243: SANE_TOOL_PATH_SQ = $(subst ','\'',$(SANE_TOOL_PATH))

1244: BROKEN_PATH_FIX = 's|^\# @@BROKEN_PATH_FIX@@$$|git_broken_path_fix "$(SANE_TOOL_PATH_SQ)"|'

1247: BROKEN_PATH_FIX = '/^\# @@BROKEN_PATH_FIX@@$$/d'

1816: 	procfs_executable_path_SQ = $(subst ','\'',$(PROCFS_EXECUTABLE_PATH))

1932: SHELL_PATH_SQ = $(subst ','\'',$(SHELL_PATH))

1933: TEST_SHELL_PATH_SQ = $(subst ','\'',$(TEST_SHELL_PATH))

1934: PERL_PATH_SQ = $(subst ','\'',$(PERL_PATH))

1935: PYTHON_PATH_SQ = $(subst ','\'',$(PYTHON_PATH))

1936: TCLTK_PATH_SQ = $(subst ','\'',$(TCLTK_PATH))

1995: SHELL_PATH_CQ = "$(subst ",\",$(subst \,\\,$(SHELL_PATH)))"

1996: SHELL_PATH_CQ_SQ = $(subst ','\'',$(SHELL_PATH_CQ))

2062: 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.

101: # Define HAVE_PATHS_H if you have paths.h and want to use the default PATH

306: # Define PERL_PATH to the path of your Perl binary (usually /usr/bin/perl).

316: # Define PYTHON_PATH to the path of your Python binary (often /usr/bin/python

326: # The TCL_PATH variable governs the location of the Tcl interpreter

330: # The TCLTK_PATH variable governs the location of the Tcl/Tk interpreter.

449: # Define TEST_SHELL_PATH if you want to use a shell besides SHELL_PATH for

466: # When using RUNTIME_PREFIX, define PROCFS_EXECUTABLE_PATH if your platform

467: # mounts a "procfs" filesystem capable of resolving the path of the current

468: # executable. If defined, this must be the canonical path for the "procfs"

469: # current executable path.

471: # When using RUNTIME_PREFIX, define HAVE_NS_GET_EXECUTABLE_PATH if your platform

472: # supports calling _NSGetExecutablePath to retrieve the path of the running

476: # the global variable _wpgmptr containing the absolute path of the current

509: 	@$(SHELL_PATH) ./GIT-VERSION-GEN

518: # can be specified as a relative path some/where/else;

520: # runtime figures out where they are based on the path to the executable.

575: export TCL_PATH TCLTK_PATH

728: TEST_BUILTINS_OBJS += test-path-utils.o

800: ifndef SHELL_PATH

803: ifndef PERL_PATH

806: ifndef PYTHON_PATH

810: export PERL_PATH

811: export PYTHON_PATH

944: LIB_OBJS += path.o

1242: ifdef SANE_TOOL_PATH

1390: ifdef ZLIB_PATH

1391: 	BASIC_CFLAGS += -I$(ZLIB_PATH)/include

1392: 	EXTLIBS += -L$(ZLIB_PATH)/$(lib) $(CC_LD_DYNPATH)$(ZLIB_PATH)/$(lib)

1815: ifneq ($(PROCFS_EXECUTABLE_PATH),)

1817: 	BASIC_CFLAGS += '-DPROCFS_EXECUTABLE_PATH="$(procfs_executable_path_SQ)"'

1820: ifdef HAVE_NS_GET_EXECUTABLE_PATH

1821: 	BASIC_CFLAGS += -DHAVE_NS_GET_EXECUTABLE_PATH

1838: ifeq ($(TCLTK_PATH),)

1842: ifeq ($(PERL_PATH),)

1846: ifeq ($(PYTHON_PATH),)

1941: # relative to each other and share an installation path.

1994: ifdef SHELL_PATH

1998: BASIC_CFLAGS += -DSHELL_PATH='$(SHELL_PATH_CQ_SQ)'

2021: export DIFF TAR INSTALL DESTDIR SHELL_PATH

2026: SHELL = $(SHELL_PATH)

2060: 	$(QUIET_SUBDIR0)templates $(QUIET_SUBDIR1) SHELL_PATH='$(SHELL_PATH_SQ)' PERL_PATH='$(PERL_PATH_SQ)'

2065: shell_compatibility_test: please_set_SHELL_PATH_to_a_more_modern_shell

2105: 	'-DGIT_HTML_PATH="$(htmldir_relative_SQ)"' \

2106: 	'-DGIT_MAN_PATH="$(mandir_relative_SQ)"' \

2107: 	'-DGIT_INFO_PATH="$(infodir_relative_SQ)"'

2117: 	'-DGIT_HTML_PATH="$(htmldir_relative_SQ)"' \

2118: 	'-DGIT_MAN_PATH="$(mandir_relative_SQ)"' \

2119: 	'-DGIT_INFO_PATH="$(infodir_relative_SQ)"'

2138: 	$(QUIET_GEN)$(SHELL_PATH) ./generate-cmdlist.sh \

2142: SCRIPT_DEFINES = $(SHELL_PATH_SQ):$(DIFF_SQ):$(GIT_VERSION):\

2143: 	$(localedir_SQ):$(NO_CURL):$(USE_GETTEXT_SCHEME):$(SANE_TOOL_PATH_SQ):\

2144: 	$(gitwebdir_SQ):$(PERL_PATH_SQ):$(SANE_TEXT_GREP):$(PAGER_ENV):\

2148: sed -e '1s|#!.*/sh|#!$(SHELL_PATH_SQ)|' \

2149:     -e 's|@SHELL_PATH@|$(SHELL_PATH_SQ)|' \

2154:     -e $(BROKEN_PATH_FIX) \

2156:     -e 's|@@PERL@@|$(PERL_PATH_SQ)|g' \

2194: PERL_DEFINES = $(PERL_PATH_SQ):$(PERLLIB_EXTRA_SQ):$(perllibdir_SQ)

2196: PERL_DEFINES := $(PERL_PATH_SQ) $(PERLLIB_EXTRA_SQ) $(perllibdir_SQ)

2205: # Don't export a fixed $(localedir) path; it will be resolved by the Perl header

2216: 	    -e '	s|#!.*perl|#!$(PERL_PATH_SQ)|' \

2261: 	sed -e '1s|#!.*/sh|#!$(SHELL_PATH_SQ)|' \

2275: 	sed -e '1s|#!.*python|#!$(PYTHON_PATH_SQ)|' \

2282: 	sed -e '1s|#!.*/sh|#!$(SHELL_PATH_SQ)|' \

2393: 	'-DGIT_EXEC_PATH="$(gitexecdir_SQ)"' \

2394: 	'-DGIT_LOCALE_PATH="$(localedir_relative_SQ)"' \

2412: 	-DGIT_LOCALE_PATH='"$(localedir_relative_SQ)"'

2650: 	@echo SHELL_PATH=\''$(subst ','\'',$(SHELL_PATH_SQ))'\' >$@+

2651: 	@echo TEST_SHELL_PATH=\''$(subst ','\'',$(TEST_SHELL_PATH_SQ))'\' >>$@+

2652: 	@echo PERL_PATH=\''$(subst ','\'',$(PERL_PATH_SQ))'\' >>$@+

2654: 	@echo PYTHON_PATH=\''$(subst ','\'',$(PYTHON_PATH_SQ))'\' >>$@+

2704: ### Detect Python interpreter path changes

2706: TRACK_PYTHON = $(subst ','\'',-DPYTHON_PATH='$(PYTHON_PATH_SQ)')

2722: 	$(QUIET_GEN)sed -e '1s|#!.*/sh|#!$(SHELL_PATH_SQ)|' \

3036: 		SHELL_PATH='$(SHELL_PATH_SQ)' PERL_PATH='$(PERL_PATH_SQ)'

3121: .PHONY: shell_compatibility_test please_set_SHELL_PATH_to_a_more_modern_shell

604: # scripts to unexpected places.  If you like CDPATH, define it for your

606: unexport CDPATH

799: # Set paths to tools early so that they can be used for version tests.

828: LIB_OBJS += abspath.o

945: LIB_OBJS += pathspec.o

1321: 	EXTLIBS += -L$(LIBPCREDIR)/$(lib) $(CC_LD_DYNPATH)$(LIBPCREDIR)/$(lib)

1339: 		# Try "-Wl,-rpath=$(CURLDIR)/$(lib)" in such a case.

1341: 		CURL_LIBCURL = -L$(CURLDIR)/$(lib) $(CC_LD_DYNPATH)$(CURLDIR)/$(lib)

1379: 			EXPAT_LIBEXPAT = -L$(EXPATDIR)/$(lib) $(CC_LD_DYNPATH)$(EXPATDIR)/$(lib) -lexpat

1400: 		OPENSSL_LINK = -L$(OPENSSLDIR)/$(lib) $(CC_LD_DYNPATH)$(OPENSSLDIR)/$(lib)

1427: 			ICONV_LINK = -L$(ICONVDIR)/$(lib) $(CC_LD_DYNPATH)$(ICONVDIR)/$(lib)

1736: ifdef HAVE_PATHS_H

1737: 	BASIC_CFLAGS += -DHAVE_PATHS_H

1940: # RUNTIME_PREFIX's resolution logic requires resource paths to be expressed

2238: 	sed -e 's=@@PATHSEP@@=$(pathsep)=g' \

3199: GCOVFLAGS = --preserve-paths --branch-probabilities --all-blocks

1326: 	char *path;

1619: 	struct strbuf path;

575: #define READ_GITFILE_ERR_NO_PATH 6

1228: static inline int is_absolute_path(const char *path)

1320: 	struct strbuf symlink_path;

1336: #define GET_OID_RECORD_PATH     0200

472: #define EXEC_PATH_ENVIRONMENT "GIT_EXEC_PATH"

487: #define GIT_LITERAL_PATHSPECS_ENVIRONMENT "GIT_LITERAL_PATHSPECS"

488: #define GIT_GLOB_PATHSPECS_ENVIRONMENT "GIT_GLOB_PATHSPECS"

489: #define GIT_NOGLOB_PATHSPECS_ENVIRONMENT "GIT_NOGLOB_PATHSPECS"

490: #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))

425: #define read_blob_data_from_cache(path, sz) read_blob_data_from_index(&the_index, (path), (sz))

491: #define GIT_QUARANTINE_ENVIRONMENT "GIT_QUARANTINE_PATH"

543: void set_git_dir(const char *path);

552:  * Return true if the given path is a git directory; note that this _just_

554:  * is a repository, you must feed that path, not just "foo".

556: int is_git_directory(const char *path);

559:  * Return 1 if the given path is the root of a git repository or

568: int is_nonbare_repository_dir(struct strbuf *path);

578: void read_gitfile_error_die(int error_code, const char *path, const char *dir);

579: const char *read_gitfile_gently(const char *path, int *return_error_code);

580: #define read_gitfile(path) read_gitfile_gently((path), NULL)

582: #define resolve_gitdir(path) resolve_gitdir_gently((path), NULL)

601: char *prefix_path(const char *prefix, int len, const char *path);

602: char *prefix_path_gently(const char *prefix, int len, int *remaining, const char *path);

605:  * Concatenate "prefix" (if len is non-zero) and "path", with no

607:  * Unlike prefix_path, this should be used if the named file does

614: char *prefix_filename(const char *prefix, const char *path);

621: int path_inside_repo(const char *prefix, const char *path);

657: int do_read_index(struct index_state *istate, const char *path,

659: int read_index_from(struct index_state *, const char *path,

703: int verify_path(const char *path, unsigned mode);

742: int remove_file_from_index(struct index_state *, const char *path);

749:  * These two are used to add the contents of the file at path

752:  * that has already run lstat(2) on the path can call

757: int add_to_index(struct index_state *, const char *path, struct stat *, int flags);

758: int add_file_to_index(struct index_state *, const char *path, int flags);

786: ...(24 bytes skipped)...x_state *istate, struct object_id *oid, int fd, struct stat *st, enum object_type type, const char *path, unsigned flags);

787: int index_path(struct index_state *istate, struct object_id *oid, const char *path, struct stat *st, unsigned flags);

826: extern int quote_path_fully;

837: extern const char *git_hooks_path;

973:  * Read the repository format characteristics from the config file "path" into

980: int read_repository_format(struct repository_format *format, const char *path);

997:  * Check the repository format version in the path found in get_git_dir(),

1152: int adjust_shared_perm(const char *path);

1155:  * Create the directory containing the named path, using care to be

1161:  * path existed at one point during the function call and then

1167:  * safe_create_leading_directories() temporarily changes path while it

1169:  * safe_create_leading_directories_const() doesn't modify path, even

1179: enum scld_error safe_create_leading_directories(char *path);

1180: enum scld_error safe_create_leading_directories_const(const char *path);

1184:  * expected to do something that makes dirname(path) permanent despite

1187:  * path, but alternatively it could create another file in that

1193:  * - ENOENT -- dirname(path) does not exist. In this case,

1194:  *             raceproof_create_file() tries creating dirname(path)

1210: typedef int create_file_fn(const char *path, void *cb);

1213:  * Create a file in dirname(path) by calling fn, creating leading

1216:  * contains path. See the documentation for create_file_fn for more

1223: int raceproof_create_file(const char *path, create_file_fn fn, void *cb);

1225: int mkdir_in_gitdir(const char *path);

1226: char *expand_user_path(const char *path, int real_home);

1227: const char *enter_repo(const char *path, int strict);

1230: 	return is_dir_sep(path[0]) || has_dos_drive_prefix(path);

1233: char *strbuf_realpath(struct strbuf *resolved, const char *path,

1235: const char *real_path(const char *path);

1236: const char *real_path_if_valid(const char *path);

1237: char *real_pathdup(const char *path, int die_on_error);

1238: const char *absolute_path(const char *path);

1239: char *absolute_pathdup(const char *path);

1240: const char *remove_leading_path(const char *in, const char *prefix);

1241: const char *relative_path(const char *in, const char *prefix, struct strbuf *sb);

1242: int normalize_path_copy_len(char *dst, const char *src, int *prefix_len);

1243: int normalize_path_copy(char *dst, const char *src);

1244: int longest_ancestor_length(const char *path, struct string_list *prefixes);

1245: char *strip_path_suffix(const char *path, const char *suffix);

1246: int daemon_avoid_alias(const char *path);

1317: 	 * symlink_path is only used by get_tree_entry_follow_symlinks,

1322: 	 * If GET_OID_RECORD_PATH is set, this will record path (if any)

1356: 		       * Somewhere along the symlink chain, a path is

1627: 	strbuf_release(&cache->path);

1630: int has_symlink_leading_path(const char *name, int len);

1631: int threaded_has_symlink_leading_path(struct cache_def *, const char *, int);

1632: int check_leading_path(const char *name, int len);

1633: int has_dirs_only_path(const char *name, int len, int prefix_len);

1719:  * Open (and truncate) the file at path, write the contents of buf to it,

1722: void write_file_buf(const char *path, const char *buf, size_t len);

1729:  *   write_file(path, "counter: %d", ctr);

1732: void write_file(const char *path, const char *fmt, ...);

1832:  * Returns 1 if the path is a regular file (or a symlink to a regular

1837: 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)

424: #define unmerge_cache(pathspec) unmerge_index(&the_index, pathspec)

655: 		   const struct pathspec *pathspec,

814: int refresh_index(struct index_state *, unsigned int flags, const struct pathspec *pathspec, char *seen, const char *header_msg);

1609: int checkout_entry(struct cache_entry *ce, const struct checkout *state, char *topath, int *nr_checkouts);

1760: int add_files_to_cache(const char *prefix, const struct pathspec *pathspec, int flags);

17:     readonly path: Path;

61:     path: string;

198:     path: Path;

204:     path: Path;

332:     readonly path: Path;

703: export declare const path: TemplateTag<Path>;

705: export declare type Path = string & {

79: export declare function asPosixPath(path: Path): PosixPath;

709: export declare class PathCannotBeFragmentException extends BaseException {

721: export declare class PathIsFileException extends BaseException {

747: 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;

650: export declare function noCacheNormalize(path: string): Path;

660: export declare function normalize(path: string): Path;

662: export declare const NormalizedRoot: Path;

664: export declare const NormalizedSep: Path;

683:     path?: string;

706:     __PRIVATE_DEVKIT_PATH: void;

710:     constructor(path: string);

713: export declare type PathFragment = Path & {

714:     __PRIVATE_DEVKIT_PATH_FRAGMENT: void;

718:     constructor(path: string);

722:     constructor(path: string);

726:     constructor(path: string);

731:     path: string;

732:     constructor(path: string, exception: JsonException);

737:     protected _resolve(path: Path): Path;

748:     __PRIVATE_DEVKIT_POSIX_PATH: void;

810:     exists(path: Path): Observable<boolean>;

811:     isDirectory(path: Path): Observable<boolean>;

812:     isFile(path: Path): Observable<boolean>;

813:     list(path: Path): Observable<PathFragment[]>;

814:     read(path: Path): Observable<FileBuffer>;

815:     stat(path: Path): Observable<Stats<StatsT> | null> | null;

818: export declare function readWorkspace(path: string, host: WorkspaceHost, format?: WorkspaceFormat): Promise<{

838: export declare function relative(from: Path, to: Path): Path;

840: export declare type ReplacementFunction = (path: Path) => Path;

853: export declare function resolve(p1: Path, p2: Path): Path;

859:     protected abstract _resolve(path: Path): Path;

860:     delete(path: Path): Observable<void>;

861:     exists(path: Path): Observable<boolean>;

862:     isDirectory(path: Path): Observable<boolean>;

863:     isFile(path: Path): Observable<boolean>;

864:     list(path: Path): Observable<PathFragment[]>;

865:     read(path: Path): Observable<FileBuffer>;

866:     rename(from: Path, to: Path): Observable<void>;

867:     stat(path: Path): Observable<Stats<T> | null> | null;

868:     watch(path: Path, options?: HostWatchOptions): Observable<HostWatchEvent> | null;

869:     write(path: Path, content: FileBuffer): Observable<void>;

875:     exists(path: Path): Observable<boolean>;

876:     isDirectory(path: Path): Observable<boolean>;

877:     isFile(path: Path): Observable<boolean>;

878:     list(path: Path): Observable<PathFragment[]>;

879:     read(path: Path): Observable<FileBuffer>;

880:     stat(path: Path): Observable<Stats<StatsT> | null> | null;

939:     protected _root: Path;

940:     constructor(delegate: Host<T>, _root?: Path);

941:     protected _resolve(path: Path): Path;

951:     protected _cache: Map<Path, Stats<SimpleMemoryHostStats>>;

954:     protected _delete(path: Path): void;

955:     protected _exists(path: Path): boolean;

956:     protected _isDirectory(path: Path): boolean;

957:     protected _isFile(path: Path): boolean;

958:     protected _list(path: Path): PathFragment[];

981:     protected _read(path: Path): FileBuffer;

982:     protected _rename(from: Path, to: Path): void;

983:     protected _stat(path: Path): Stats<SimpleMemoryHostStats> | null;

984:     protected _toAbsolute(path: Path): Path;

985:     protected _updateWatchers(path: Path, type: HostWatchEventType): void;

986:     protected _watch(path: Path, options?: HostWatchOptions): Observable<HostWatchEvent>;

987:     protected _write(path: Path, content: FileBuffer): void;

988:     delete(path: Path): Observable<void>;

989:     exists(path: Path): Observable<boolean>;

990:     isDirectory(path: Path): Observable<boolean>;

991:     isFile(path: Path): Observable<boolean>;

992:     list(path: Path): Observable<PathFragment[]>;

993:     read(path: Path): Observable<FileBuffer>;

994:     rename(from: Path, to: Path): Observable<void>;

996:     stat(path: Path): Observable<Stats<{}> | null> | null;

997:     watch(path: Path, options?: HostWatchOptions): Observable<HostWatchEvent> | null;

998:     write(path: Path, content: FileBuffer): Observable<void>;

1009: export declare function split(path: Path): PathFragment[];

1035:     delete(path: Path): void;

1036:     exists(path: Path): boolean;

1037:     isDirectory(path: Path): boolean;

1038:     isFile(path: Path): boolean;

1039:     list(path: Path): PathFragment[];

1040:     read(path: Path): FileBuffer;

1041:     rename(from: Path, to: Path): void;

1042:     stat(path: Path): Stats<T> | null;

1043:     watch(path: Path, options?: HostWatchOptions): Observable<HostWatchEvent> | null;

1044:     write(path: Path, content: FileBufferLike): void;

1124:         path: Path;

1127:         from: Path;

1128:         to: Path;

1133:         readonly files: Path[];

1137:             [path: string]: string;

1139:         $exists(path: string): boolean;

1140:         $isDirectory(path: string): boolean;

1141:         $isFile(path: string): boolean;

1142:         $list(path: string): PathFragment[];

1143:         $read(path: string): string;

1144:         $write(path: string, content: string): void;

1145:         protected _delete(path: Path): void;

1146:         protected _exists(path: Path): boolean;

1147:         protected _isDirectory(path: Path): boolean;

1148:         protected _isFile(path: Path): boolean;

1149:         protected _list(path: Path): PathFragment[];

1150:         protected _read(path: Path): ArrayBuffer;

1151:         protected _rename(from: Path, to: Path): void;

1152:         protected _stat(path: Path): Stats<SimpleMemoryHostStats> | null;

1153:         protected _watch(path: Path, options?: HostWatchOptions): Observable<HostWatchEvent>;

1154:         protected _write(path: Path, content: FileBuffer): void;

1199:     __PRIVATE_DEVKIT_WINDOWS_PATH: void;

1205:     readonly root: Path;

1207:     constructor(_root: Path, _host: virtualFs.Host<{}>, registry?: schema.CoreSchemaRegistry);

1211:     getProjectByPath(path: Path): string | null;

1218:     loadWorkspaceFromHost(workspacePath: Path): Observable<this>;

1222:     static findWorkspaceFile(host: virtualFs.Host<{}>, path: Path): Promise<Path | null>;

1223:     static fromPath(host: virtualFs.Host<{}>, path: Path, registry: schema.CoreSchemaRegistry): Promise<Workspace>;

1232:     constructor(path: Path);

1240:     isDirectory(path: string): Promise<boolean>;

1241:     isFile(path: string): Promise<boolean>;

1242:     readFile(path: string): Promise<string>;

1243:     writeFile(path: string, data: string): Promise<void>;

1284: export declare function writeWorkspace(workspace: WorkspaceDefinition, host: WorkspaceHost, path?: string, format?: WorkspaceFormat): Promise<void>;

717: export declare class PathIsDirectoryException extends BaseException {

725: export declare class PathMustBeAbsoluteException extends BaseException {

729: export declare class PathSpecificJsonException extends JsonException {

921:     dataPath: string;

1198: export declare type WindowsPath = string & {

363: export declare class InvalidPathException extends BaseException {

113:       "path": "node_modules/cz-conventional-changelog"

26:     "canonical-path": "0.0.2",

523:   required string path = 3;

291:     INVALID_PATH_IN_ACL_REQUEST = 53; // Invalid path name in acl request.

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);

215: 	Path   [108]int8

816: 	AT_EMPTY_PATH   = 0x1000

14: 	PathMax        = 0x1000

566: 	RTA_MULTIPATH           = 0x9

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,

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. */

267: 	Path   [UnixPathMax]int8

262: const UnixPathMax = 108

259: // UnixPathMax is the maximum length of the path in an AF_UNIX socket.

18: const path = require('path');

1103:   waitForXPath(xpath, options = {}) {

419:    * @param {!{url?: string, path?: string, content?: string, type?: string}} options

427:    * @param {!{url?: string, path?: string, content?: string}} options

858:     // options.type takes precedence over inferring the type from options.path

863:     } else if (options.path) {

864:       const mimeType = mime.getType(options.path);

929:     if (options.path)

930:       await writeFileAsync(options.path, buffer);

957:       path = null

994:     return await helper.readProtocolStream(this._client, result.stream, path);

1132:  * @property {string=} path

1155:  * @property {string=} path

1239:  * @property {string} path

1255:  * @property {string=} path

1337:     const files = filePaths.map(filePath => path.resolve(filePath));

1099:    * @param {string} xpath

1104:     return this.mainFrame().waitForXPath(xpath, options);

1331:    * @param {!Array<string>} filePaths

1334:   async accept(filePaths) {

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

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),

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();

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

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

787:   uint32_t path;

784: struct rpath_command {

1202:   sys::swapByteOrder(r.path);

1199: inline void swapStruct(rpath_command &r) {

863:   path: string;

868:   path: string;

874:   path: string;

911:   path: string;

1134:   path: string;

1085:   hostPath: HostPathVolumeSource;

862: export interface HostPathVolumeSource {

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",

215: 	Path   [108]int8

816: 	AT_EMPTY_PATH   = 0x1000

14: 	PathMax        = 0x1000

566: 	RTA_MULTIPATH           = 0x9

214: 	Path   [108]int8

810: 	AT_EMPTY_PATH   = 0x1000

14: 	PathMax        = 0x1000

565: 	RTA_MULTIPATH           = 0x9

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

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));

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),

106:     CGMutablePathRef path;

273: void x3closepath(x3dc *dc);

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++) {

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.",

666:     PATH VARCHAR2(1024) NOT NULL,

946: CREATE UNIQUE INDEX UNIQUE_WM_POOL ON WM_POOL (RP_ID, PATH);

106:         path: cookie.path,

650:   async waitForXPath(xpath, options = {}) {

534: ...(15 bytes skipped)...ullPage?: boolean, clip?: {width: number, height: number, x: number, y: number}, encoding?: string, path?: string}} options

544:     if (options.path)

545:       await writeFileAsync(options.path, buffer);

564:    * @param {!{content?: string, path?: string, type?: string, url?: string}} options

572:    * @param {!{content?: string, path?: string, url?: string}} options

793:   // options.type takes precedence over inferring the type from options.path

802:   if (options.path) {

803:     const fileType = mime.getType(options.path);

646:    * @param {string} xpath

651:     return await this._frameManager.mainFrame().waitForXPath(xpath, options);

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 [

2371:   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 "