The Wayback Machine - https://web.archive.org/web/20140908203040/http://dlang.org/phobos/std_path.html

std.path

This module is used to manipulate path strings.

All functions, with the exception ofexpandTilde (and in some casesabsolutePath andrelativePath), are pure string manipulation functions; they don't depend on any state outside the program, nor do they perform any actual file system actions. This has the consequence that the module does not make any distinction between a path that points to a directory and a path that points to a file, and it does not know whether or not the object pointed to by the path actually exists in the file system. To differentiate between these cases, usestd.file.isDir andstd.file.exists.

Note that on Windows, both the backslash (`\`) and the slash (`/`) are in principle valid directory separators. This module treats them both on equal footing, but in cases where anew separator is added, a backslash will be used. Furthermore, thebuildNormalizedPath function will replace all slashes with backslashes on that platform.

In general, the functions in this module assume that the input paths are well-formed. (That is, they should not contain invalid characters, they should follow the file system's path format, etc.) The result of calling a function on an ill-formed path is undefined. When there is a chance that a path or a file name is invalid (for instance, when it has been input by the user), it may sometimes be desirable to use theisValidFilename andisValidPath functions to check this.

Most functions do not perform any memory allocations, and if a string is returned, it is usually a slice of an input string. If a function allocates, this is explicitly mentioned in the documentation.

Authors:
Lars Tandle Kyllingstad,Walter Bright, Grzegorz Adam Hankiewicz, Thomas Kühne,Andrei Alexandrescu

License:
Boost License 1.0

Source:
std/path.d

stringdirSeparator;

String used to separate directory names in a path. Under POSIX this is a slash, under Windows a backslash.

stringpathSeparator;

Path separator string. A colon under POSIX, a semicolon under Windows.

pure nothrow @nogc @safe boolisDirSeparator(dcharc);

Determines whether the given character is a directory separator.

On Windows, this includes both`\` and`/`. On POSIX, it's just`/`.

enumCaseSensitive: bool;

Thisenum is used as a template argument to functions which compare file names, and determines whether the comparison is case sensitive or not.

no

File names are case insensitive

yes

File names are case sensitive

osDefault

The default (or most common) setting for the current platform. That is,no on Windows and Mac OS X, andyes on all POSIX systems except OS X (Linux, *BSD, etc.).

autobaseName(R)(Rpath) if (isRandomAccessRange!R && hasSlicing!R && isSomeChar!(ElementType!R) || is(StringTypeOf!R));
pure @safe inout(C)[]baseName(CaseSensitive cs = CaseSensitive.osDefault, C, C1)(inout(C)[]path, in C1[]suffix) if (isSomeChar!C && isSomeChar!C1);

Returns the name of a file, without any leading directory and with an optional suffix chopped off.

Ifsuffix is specified, it will be compared topath usingfilenameCmp!cs, wherecs is an optional template parameter determining whether the comparison is case sensitive or not. See thefilenameCmp documentation for details.

Examples:

assert (baseName("dir/file.ext")         =="file.ext");assert (baseName("dir/file.ext",".ext") =="file");assert (baseName("dir/file.ext",".xyz") =="file.ext");assert (baseName("dir/filename","name") =="file");assert (baseName("dir/subdir/")          =="subdir");version (Windows){assert (baseName(`d:file.ext`)      =="file.ext");assert (baseName(`d:\dir\file.ext`) =="file.ext");}

Note:
This functiononly strips away the specified suffix, which doesn't necessarily have to represent an extension. To remove the extension from a path, regardless of what the extension is, usestripExtension. To obtain the filename without leading directories and without an extension, combine the functions like this:

assert (baseName(stripExtension("dir/file.ext")) =="file");

Standards:
This function complies with the POSIX requirements for the 'basename' shell utility (with suitable adaptations for Windows paths).

C[]dirName(C)(C[]path) if (isSomeChar!C);

Returns the directory part of a path. On Windows, this includes the drive letter if present.

This function performs a memory allocation if and only ifpath is mutable and does not have a directory (in which case a new mutable string is needed to hold the returned current-directory symbol,".").

Examples:

assert (dirName("file")        ==".");assert (dirName("dir/file")    =="dir");assert (dirName("/file")       =="/");assert (dirName("dir/subdir/") =="dir");version (Windows){assert (dirName("d:file")      =="d:");assert (dirName(`d:\dir\file`) ==`d:\dir`);assert (dirName(`d:\file`)     ==`d:\`);assert (dirName(`dir\subdir\`) ==`dir`);}

Standards:
This function complies with the POSIX requirements for the 'dirname' shell utility (with suitable adaptations for Windows paths).

pure nothrow @nogc @safe inout(C)[]rootName(C)(inout(C)[]path) if (isSomeChar!C);

Returns the root directory of the specified path, ornull if the path is not rooted.

Examples:

assert (rootName("foo")isnull);assert (rootName("/foo") =="/");version (Windows){assert (rootName(`\foo`) ==`\`);assert (rootName(`c:\foo`) ==`c:\`);assert (rootName(`\\server\share\foo`) ==`\\server\share`);}

pure nothrow @nogc @safe inout(C)[]driveName(C)(inout(C)[]path) if (isSomeChar!C);

Returns the drive of a path, ornull if the drive is not specified. In the case of UNC paths, the network share is returned.

Always returnsnull on POSIX.

Examples:

version (Windows){assert (driveName(`d:\file`) =="d:");assert (driveName(`\\server\share\file`) ==`\\server\share`);assert (driveName(`dir\file`).empty);}

autostripDrive(R)(inout Rpath) if (isRandomAccessRange!R && hasSlicing!R && isSomeChar!(ElementType!R) || is(StringTypeOf!R));

Strips the drive from a Windows path. On POSIX, the path is returned unaltered.

Example:

version (Windows){assert (stripDrive(`d:\dir\file`) ==`\dir\file`);assert (stripDrive(`\\server\share\dir\file`) ==`\dir\file`);}

autoextension(R)(Rpath) if (isRandomAccessRange!R && hasSlicing!R && isSomeChar!(ElementType!R) || is(StringTypeOf!R));

Returns the extension part of a file name, including the dot.

If there is no extension,null is returned.

Examples:

assert (extension("file").empty);assert (extension("file.ext")       ==".ext");assert (extension("file.ext1.ext2") ==".ext2");assert (extension("file.")          ==".");assert (extension(".file").empty);assert (extension(".file.ext")      ==".ext");

pure nothrow @nogc @safe inout(C)[]stripExtension(C)(inout(C)[]path) if (isSomeChar!C);

Returns slice of path[] with the extension stripped off.

Examples:

assert (stripExtension("file")           =="file");assert (stripExtension("file.ext")       =="file");assert (stripExtension("file.ext1.ext2") =="file.ext1");assert (stripExtension("file.")          =="file");assert (stripExtension(".file")          ==".file");assert (stripExtension(".file.ext")      ==".file");assert (stripExtension("dir/file.ext")   =="dir/file");

pure nothrow @trusted immutable(Unqual!C1)[]setExtension(C1, C2)(in C1[]path, in C2[]ext) if (isSomeChar!C1 && !is(C1 == immutable) && is(Unqual!C1 == Unqual!C2));
pure nothrow @trusted immutable(C1)[]setExtension(C1, C2)(immutable(C1)[]path, const(C2)[]ext) if (isSomeChar!C1 && is(Unqual!C1 == Unqual!C2));

Returns a string containing the path given bypath, but where the extension has been set toext.

If the filename already has an extension, it is replaced. If not, the extension is simply appended to the filename. Including a leading dot inext is optional.

If the extension is empty, this function is equivalent tostripExtension.

This function normally allocates a new string (the possible exception being the case when path is immutable and doesn't already have an extension).

Examples:

assert (setExtension("file","ext")      =="file.ext");assert (setExtension("file",".ext")     =="file.ext");assert (setExtension("file.old","")     =="file");assert (setExtension("file.old","new")  =="file.new");assert (setExtension("file.old",".new") =="file.new");

pure @trusted immutable(Unqual!C1)[]defaultExtension(C1, C2)(in C1[]path, in C2[]ext) if (isSomeChar!C1 && is(Unqual!C1 == Unqual!C2));

Returns the path given bypath, with the extension given byext appended if the path doesn't already have one.

Including the dot in the extension is optional.

This function always allocates a new string, except in the case when path is immutable and already has an extension.

Examples:

assert (defaultExtension("file","ext")      =="file.ext");assert (defaultExtension("file",".ext")     =="file.ext");assert (defaultExtension("file.","ext")     =="file.");assert (defaultExtension("file.old","new")  =="file.old");assert (defaultExtension("file.old",".new") =="file.old");

immutable(ElementEncodingType!(ElementType!Range))[]buildPath(Range)(Rangesegments) if (isInputRange!Range && isSomeString!(ElementType!Range));
pure nothrow @safe immutable(C)[]buildPath(C)(const(C[])[]paths...) if (isSomeChar!C);

Combines one or more path segments.

This function takes a set of path segments, given as an input range of string elements or as a set of string arguments, and concatenates them with each other. Directory separators are inserted between segments if necessary. If any of the path segments are absolute (as defined byisAbsolute), the preceding segments will be dropped.

On Windows, if one of the path segments are rooted, but not absolute (e.g.`\foo`), all preceding path segments down to the previous root will be dropped. (See below for an example.)

This function always allocates memory to hold the resulting path. The variadic overload is guaranteed to only perform a single allocation, as is the range version ifpaths is a forward range.

Examples:

version (Posix){assert (buildPath("foo","bar","baz") =="foo/bar/baz");assert (buildPath("/foo/","bar/baz")  =="/foo/bar/baz");assert (buildPath("/foo","/bar")      =="/bar");}version (Windows){assert (buildPath("foo","bar","baz") ==`foo\bar\baz`);assert (buildPath(`c:\foo`,`bar\baz`) ==`c:\foo\bar\baz`);assert (buildPath("foo",`d:\bar`)     ==`d:\bar`);assert (buildPath("foo",`\bar`)       ==`\bar`);assert (buildPath(`c:\foo`,`\bar`)    ==`c:\bar`);}

pure nothrow @trusted immutable(C)[]buildNormalizedPath(C)(const(C[])[]paths...) if (isSomeChar!C);

Performs the same task asbuildPath, while at the same time resolving current/parent directory symbols ("." and"..") and removing superfluous directory separators. On Windows, slashes are replaced with backslashes.

Note that this function does not resolve symbolic links.

This function always allocates memory to hold the resulting path.

Examples:

version (Posix){assert (buildNormalizedPath("/foo/./bar/..//baz/") =="/foo/baz");assert (buildNormalizedPath("../foo/.") =="../foo");assert (buildNormalizedPath("/foo","bar/baz/") =="/foo/bar/baz");assert (buildNormalizedPath("/foo","/bar/..","baz") =="/baz");assert (buildNormalizedPath("foo/./bar","../../","../baz") =="../baz");assert (buildNormalizedPath("/foo/./bar","../../baz") =="/baz");}version (Windows){assert (buildNormalizedPath(`c:\foo\.\bar/..\\baz\`) ==`c:\foo\baz`);assert (buildNormalizedPath(`..\foo\.`) ==`..\foo`);assert (buildNormalizedPath(`c:\foo`,`bar\baz\`) ==`c:\foo\bar\baz`);assert (buildNormalizedPath(`c:\foo`,`bar/..`) ==`c:\foo`);assert (buildNormalizedPath(`\\server\share\foo`,`..\bar`) ==`\\server\share\bar`);}

pure nothrow @safe autopathSplitter(C)(const(C)[]path) if (isSomeChar!C);

Returns a bidirectional range that iterates over the elements of a path.

Examples:

assert (equal(pathSplitter("/"), ["/"]));assert (equal(pathSplitter("/foo/bar"), ["/","foo","bar"]));assert (equal(pathSplitter("//foo/bar"), ["//foo","bar"]));assert (equal(pathSplitter("foo/../bar//./"), ["foo","..","bar","."]));version (Windows){assert (equal(pathSplitter(`foo\..\bar\/.\`), ["foo","..","bar","."]));assert (equal(pathSplitter("c:"), ["c:"]));assert (equal(pathSplitter(`c:\foo\bar`), [`c:\`,"foo","bar"]));assert (equal(pathSplitter(`c:foo\bar`), ["c:foo","bar"]));}

boolisRooted(R)(inout Rpath) if (isRandomAccessRange!R && isSomeChar!(ElementType!R) || is(StringTypeOf!R));

Determines whether a path starts at a root directory.

On POSIX, this function returnstrue if and only if the path starts with a slash (/).

version (Posix){assert (isRooted("/"));assert (isRooted("/foo"));assert (!isRooted("foo"));assert (!isRooted("../foo"));}

On Windows, this function returnstrue if the path starts at the root directory of the current drive, of some other drive, or of a network drive.

version (Windows){assert (isRooted(`\`));assert (isRooted(`\foo`));assert (isRooted(`d:\foo`));assert (isRooted(`\\foo\bar`));assert (!isRooted("foo"));assert (!isRooted("d:foo"));}

pure nothrow @nogc @safe boolisAbsolute(R)(const Rpath) if (isRandomAccessRange!R && isSomeChar!(ElementType!R) || is(StringTypeOf!R));

Determines whether a path is absolute or not.

Examples:
On POSIX, an absolute path starts at the root directory. (In fact,isAbsolute is just an alias forisRooted.)

version (Posix){assert (isAbsolute("/"));assert (isAbsolute("/foo"));assert (!isAbsolute("foo"));assert (!isAbsolute("../foo"));}

On Windows, an absolute path starts at the root directory of a specific drive. Hence, it must start with`d:\` or`d:/`, whered is the drive letter. Alternatively, it may be a network path, i.e. a path starting with a double (back)slash.

version (Windows){assert (isAbsolute(`d:\`));assert (isAbsolute(`d:\foo`));assert (isAbsolute(`\\foo\bar`));assert (!isAbsolute(`\`));assert (!isAbsolute(`\foo`));assert (!isAbsolute("d:foo"));}

pure @safe stringabsolutePath(stringpath, lazy stringbase = getcwd());

Translatespath into an absolute path.

The following algorithm is used:

1. Ifpath is empty, returnnull.
2. Ifpath is already absolute, return it.
3. Otherwise, appendpath tobase and return the result. Ifbase is not specified, the current working directory is used.

The function allocates memory if and only if it gets to the third stage of this algorithm.

Examples:

version (Posix){assert (absolutePath("some/file","/foo/bar")  =="/foo/bar/some/file");assert (absolutePath("../file","/foo/bar")    =="/foo/bar/../file");assert (absolutePath("/some/file","/foo/bar") =="/some/file");}version (Windows){assert (absolutePath(`some\file`,`c:\foo\bar`)    ==`c:\foo\bar\some\file`);assert (absolutePath(`..\file`,`c:\foo\bar`)      ==`c:\foo\bar\..\file`);assert (absolutePath(`c:\some\file`,`c:\foo\bar`) ==`c:\some\file`);assert (absolutePath(`\file`,`c:\foo\bar`)        ==`c:\file`);}

Throws:
Exception if the specified base directory is not absolute.

stringrelativePath(CaseSensitive cs = CaseSensitive.osDefault)(stringpath, lazy stringbase = getcwd());

Translatespath into a relative path.

The returned path is relative tobase, which is by default taken to be the current working directory. If specified,base must be an absolute path, and it is always assumed to refer to a directory. Ifpath andbase refer to the same directory, the function returns`.`.

The following algorithm is used:

1. Ifpath is a relative directory, return it unaltered.
2. Find a common root betweenpath andbase. If there is no common root, returnpath unaltered.
3. Prepare a string with as many`../` or`..\` as necessary to reach the common root from base path.
4. Append the remaining segments ofpath to the string and return.

In the second step, path components are compared usingfilenameCmp!cs, wherecs is an optional template parameter determining whether the comparison is case sensitive or not. See thefilenameCmp documentation for details.

The function allocates memory if and only if it reaches the third stage of the above algorithm.

Examples:

assert (relativePath("foo") =="foo");version (Posix){assert (relativePath("foo","/bar") =="foo");assert (relativePath("/foo/bar","/foo/bar") ==".");assert (relativePath("/foo/bar","/foo/baz") =="../bar");assert (relativePath("/foo/bar/baz","/foo/woo/wee") =="../../bar/baz");assert (relativePath("/foo/bar/baz","/foo/bar") =="baz");}version (Windows){assert (relativePath("foo",`c:\bar`) =="foo");assert (relativePath(`c:\foo\bar`,`c:\foo\bar`) ==".");assert (relativePath(`c:\foo\bar`,`c:\foo\baz`) ==`..\bar`);assert (relativePath(`c:\foo\bar\baz`,`c:\foo\woo\wee`) ==`..\..\bar\baz`);assert (relativePath(`c:\foo\bar\baz`,`c:\foo\bar`) =="baz");assert (relativePath(`c:\foo\bar`,`d:\foo`) ==`c:\foo\bar`);}

Throws:
Exception if the specified base directory is not absolute.

pure nothrow @safe intfilenameCharCmp(CaseSensitive cs = CaseSensitive.osDefault)(dchara, dcharb);

Compares filename characters and return< 0 ifa < b,0 ifa == b and> 0 ifa > b.

This function can perform a case-sensitive or a case-insensitive comparison. This is controlled through thecs template parameter which, if not specified, is given byCaseSensitive.osDefault.

On Windows, the backslash and slash characters (`\` and`/`) are considered equal.

Examples:

assert (filenameCharCmp('a', 'a') == 0);assert (filenameCharCmp('a', 'b') < 0);assert (filenameCharCmp('b', 'a') > 0);version (linux){// Same as calling filenameCharCmp!(CaseSensitive.yes)(a, b)assert (filenameCharCmp('A', 'a') < 0);assert (filenameCharCmp('a', 'A') > 0);}version (Windows){// Same as calling filenameCharCmp!(CaseSensitive.no)(a, b)assert (filenameCharCmp('a', 'A') == 0);assert (filenameCharCmp('a', 'B') < 0);assert (filenameCharCmp('A', 'b') < 0);}

pure @safe intfilenameCmp(CaseSensitive cs = CaseSensitive.osDefault, C1, C2)(const(C1)[]filename1, const(C2)[]filename2) if (isSomeChar!C1 && isSomeChar!C2);

Compares file names and returns< 0 iffilename1 < filename2,0 iffilename1 == filename2 and> 0 iffilename1 > filename2.

Individual characters are compared usingfilenameCharCmp!cs, wherecs is an optional template parameter determining whether the comparison is case sensitive or not. See thefilenameCharCmp documentation for details.

Examples:

assert (filenameCmp("abc","abc") == 0);assert (filenameCmp("abc","abd") < 0);assert (filenameCmp("abc","abb") > 0);assert (filenameCmp("abc","abcd") < 0);assert (filenameCmp("abcd","abc") > 0);version (linux){// Same as calling filenameCmp!(CaseSensitive.yes)(filename1, filename2)assert (filenameCmp("Abc","abc") < 0);assert (filenameCmp("abc","Abc") > 0);}version (Windows){// Same as calling filenameCmp!(CaseSensitive.no)(filename1, filename2)assert (filenameCmp("Abc","abc") == 0);assert (filenameCmp("abc","Abc") == 0);assert (filenameCmp("Abc","abD") < 0);assert (filenameCmp("abc","AbB") > 0);}

pure nothrow @safe boolglobMatch(CaseSensitive cs = CaseSensitive.osDefault, C)(const(C)[]path, const(C)[]pattern) if (isSomeChar!C);

Matches a pattern against a path.

Some characters of pattern have a special meaning (they aremeta-characters) and can't be escaped. These are:

*	Matches 0 or more instances of any character.
?	Matches exactly one instance of any character.
[chars]	Matches one instance of any character that appears between the brackets.
[!chars]	Matches one instance of any character that does not appear between the brackets after the exclamation mark.
{string1,string2,…}	Matches either of the specified strings.

Individual characters are compared usingfilenameCharCmp!cs, wherecs is an optional template parameter determining whether the comparison is case sensitive or not. See thefilenameCharCmp documentation for details.

Note that directory separators and dots don't stop a meta-character from matching further portions of the path.

Returns:
true if pattern matches path,false otherwise.

See Also:
Wikipedia: glob (programming)

Examples:

assert (globMatch("foo.bar","*"));assert (globMatch("foo.bar","*.*"));assert (globMatch(`foo/foo\bar`,"f*b*r"));assert (globMatch("foo.bar","f???bar"));assert (globMatch("foo.bar","[fg]???bar"));assert (globMatch("foo.bar","[!gh]*bar"));assert (globMatch("bar.fooz","bar.{foo,bif}z"));assert (globMatch("bar.bifz","bar.{foo,bif}z"));version (Windows){// Same as calling globMatch!(CaseSensitive.no)(path, pattern)assert (globMatch("foo","Foo"));assert (globMatch("Goo.bar","[fg]???bar"));}version (linux){// Same as calling globMatch!(CaseSensitive.yes)(path, pattern)assert (!globMatch("foo","Foo"));assert (!globMatch("Goo.bar","[fg]???bar"));}

boolisValidFilename(R)(Rfilename) if (isRandomAccessRange!R && isSomeChar!(ElementType!R) || is(StringTypeOf!R));

Checks that the given file or directory name is valid.

This function returnstrue if and only iffilename is not empty, not too long, and does not contain invalid characters.

The maximum length offilename is given by the constantcore.stdc.stdio.FILENAME_MAX. (On Windows, this number is defined as the maximum number of UTF-16 code points, and the test will therefore only yield strictly correct results whenfilename is a string ofwchars.)

On Windows, the following criteria must be satisfied (source):

• filename must not contain any characters whose integer representation is in the range 0-31.
• filename must not contain any of the followingreserved characters: <>:"/\|?*
• filename may not end with a space (' ') or a period ('.').

On POSIX,filename may not contain a forward slash ('/') or thenull character ('\0').

pure nothrow @safe boolisValidPath(C)(in C[]path) if (isSomeChar!C);

Checks whetherpath is a valid path.

Generally, this function checks thatpath is not empty, and that each component of the path either satisfiesisValidFilename or is equal to"." or"..". It doesnot check whether the path points to an existing file or directory; usestd.file.exists for this purpose.

On Windows, some special rules apply:

• If the second character ofpath is a colon (':'), the first character is interpreted as a drive letter, and must be in the range A-Z (case insensitive).
• Ifpath is on the form`\\server\share\...` (UNC path),isValidFilename is applied toserver andshare as well.
• Ifpath starts with`\\?\` (long UNC path), the only requirement for the rest of the string is that it does not contain thenull character.
• Ifpath starts with`\\.\` (Win32 device namespace) this function returnsfalse; such paths are beyond the scope of this module.

stringexpandTilde(stringinputPath);

Performs tilde expansion in paths on POSIX systems. On Windows, this function does nothing.

There are two ways of using tilde expansion in a path. One involves using the tilde alone or followed by a path separator. In this case, the tilde will be expanded with the value of the environment variableHOME. The second way is putting a username after the tilde (i.e.~john/Mail). Here, the username will be searched for in the user database (i.e./etc/passwd on Unix systems) and will expand to whatever path is stored there. The username is considered the string after the tilde ending at the first instance of a path separator.

Note that using the~user syntax may give different values from just~ if the environment variable doesn't match the value stored in the user database.

When the environment variable version is used, the path won't be modified if the environment variable doesn't exist or it is empty. When the database version is used, the path won't be modified if the user doesn't exist in the database or there is not enough memory to perform the query.

This function performs several memory allocations.

Returns:
inputPath with the tilde expanded, or justinputPath if it could not be expanded. For Windows,expandTilde merely returns its argumentinputPath.

Examples:

void processFile(string path){// Allow calling this function with paths such as ~/fooauto fullPath =expandTilde(path);    ...}

Copyright (c) 2000-2014, the authors. All rights reserved. |Page generated byDdoc.

©2009-2025 Movatter.jp