std.path - D Programming Language (original) (raw)

This module is used to manipulate path strings.

All functions, with the exception of expandTilde (and in some cases absolutePath and relativePath), 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, use std.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 a new separator is added, a backslash will be used. Furthermore, the buildNormalizedPath 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 and isValidPath 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.

enum string dirSeparator;

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

enum string pathSeparator;

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

pure nothrow @nogc @safe bool isDirSeparator(dchar c);

Determines whether the given character is a directory separator.

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

Examples:

version (Windows) { assert( '/'.isDirSeparator); assert( '\'.isDirSeparator); } else { assert( '/'.isDirSeparator); assert(!'\'.isDirSeparator); }

enum CaseSensitive: bool;

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

Examples:

writeln(baseName!(CaseSensitive.no)("dir/file.EXT", ".ext")); assert(baseName!(CaseSensitive.yes)("dir/file.EXT", ".ext") != "file");

version (Posix) writeln(relativePath!(CaseSensitive.no)("/FOO/bar", "/foo/baz")); else writeln(relativePath!(CaseSensitive.no)(c:\FOO\bar, c:\foo\baz));

File names are case insensitive

File names are case sensitive

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

auto baseName(R)(return scope R path)
if (isRandomAccessRange!R && hasSlicing!R && isSomeChar!(ElementType!R) && !isSomeString!R);

auto baseName(C)(return scope C[] path)
if (isSomeChar!C);

pure @safe inout(C)[] baseName(CaseSensitive cs = CaseSensitive.osDefault, C, C1)(return scope inout(C)[] path, in C1[] suffix)
if (isSomeChar!C && isSomeChar!C1);

Parameters:

Returns:

The name of the file in the path name, without any leading directory and with an optional suffix chopped off.

If suffix is specified, it will be compared to path using filenameCmp!cs, where cs is an optional template parameter determining whether the comparison is case sensitive or not. See thefilenameCmp documentation for details.

Note This function only 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, use stripExtension. To obtain the filename without leading directories and without an extension, combine the functions like this:

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

Examples:

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

auto dirName(R)(return scope R path)
if (isRandomAccessRange!R && hasSlicing!R && hasLength!R && isSomeChar!(ElementType!R) && !isSomeString!R);

auto dirName(C)(return scope C[] path)
if (isSomeChar!C);

Returns the parent directory of path. On Windows, this includes the drive letter if present. If path is a relative path and the parent directory is the current working directory, returns ".".

Returns:

A slice of path or ".".

Examples:

writeln(dirName("")); writeln(dirName("file"w)); writeln(dirName("dir/"d)); writeln(dirName("dir///")); writeln(dirName("dir/file"w.dup)); writeln(dirName("dir///file"d.dup)); writeln(dirName("dir/subdir/")); writeln(dirName("/dir/file"w)); writeln(dirName("/file"d)); writeln(dirName("/")); writeln(dirName("///")); version (Windows) { writeln(dirName(dir\)); writeln(dirName(dir\\\)); writeln(dirName(dir\file)); writeln(dirName(dir\\\file)); writeln(dirName(dir\subdir\)); writeln(dirName(\dir\file)); writeln(dirName(\file)); writeln(dirName(\)); writeln(dirName(\\\)); writeln(dirName(d:)); writeln(dirName(d:file)); writeln(dirName(d:\)); writeln(dirName(d:\file)); writeln(dirName(d:\dir\file)); writeln(dirName(\\server\share\dir\file)); writeln(dirName(\\server\share\file)); writeln(dirName(\\server\share\)); writeln(dirName(\\server\share)); }

auto rootName(R)(R path)
if (isRandomAccessRange!R && hasSlicing!R && hasLength!R && isSomeChar!(ElementType!R) && !isSomeString!R);

auto rootName(C)(C[] path)
if (isSomeChar!C);

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

Examples:

assert(rootName("") is null); assert(rootName("foo") is null); writeln(rootName("/")); writeln(rootName("/foo/bar")); version (Windows) { assert(rootName("d:foo") is null); writeln(rootName(d:\foo)); writeln(rootName(\\server\share\foo)); writeln(rootName(\\server\share)); }

auto driveName(R)(R path)
if (isRandomAccessRange!R && hasSlicing!R && hasLength!R && isSomeChar!(ElementType!R) && !isSomeString!R);

auto driveName(C)(C[] path)
if (isSomeChar!C);

Get the drive portion of a path.

Parameters:

Returns:

A slice of path that is the drive, or an empty range if the drive is not specified. In the case of UNC paths, the network share is returned.

Always returns an empty range on POSIX.

Examples:

import std.range : empty; version (Posix) assert(driveName("c:/foo").empty); version (Windows) { assert(driveName(dir\file).empty); writeln(driveName(d:file)); writeln(driveName(d:\file)); writeln(driveName("d:")); writeln(driveName(\\server\share\file)); writeln(driveName(\\server\share\)); writeln(driveName(\\server\share)); static assert(driveName(d:\file) == "d:"); }

auto stripDrive(R)(R path)
if (isRandomAccessRange!R && hasSlicing!R && isSomeChar!(ElementType!R) && !isSomeString!R);

auto stripDrive(C)(C[] path)
if (isSomeChar!C);

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

Returns:

A slice of path without the drive component.

Examples:

version (Windows) { writeln(stripDrive(d:\dir\file)); writeln(stripDrive(\\server\share\dir\file)); }

auto extension(R)(R path)
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:

import std.range : empty; assert(extension("file").empty); writeln(extension("file.")); writeln(extension("file.ext"w)); writeln(extension("file.ext1.ext2"d)); assert(extension(".foo".dup).empty); writeln(extension(".foo.ext"w.dup)); static assert(extension("file").empty); static assert(extension("file.ext") == ".ext");

auto stripExtension(R)(R path)
if (isRandomAccessRange!R && hasSlicing!R && hasLength!R && isSomeChar!(ElementType!R) && !isSomeString!R);

auto stripExtension(C)(C[] path)
if (isSomeChar!C);

Remove extension from path.

Parameters:

Returns:

slice of path with the extension (if any) stripped off

Examples:

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

immutable(C1)[] setExtension(C1, C2)(in C1[] path, in C2[] ext)
if (isSomeChar!C1 && !is(C1 == immutable) && is(immutable(C1) == immutable(C2)));

immutable(C1)[] setExtension(C1, C2)(immutable(C1)[] path, const(C2)[] ext)
if (isSomeChar!C1 && is(immutable(C1) == immutable(C2)));

Sets or replaces an extension.

If the filename already has an extension, it is replaced. If not, the extension is simply appended to the filename. Including a leading dot in ext 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).

Parameters:

Returns:

A string containing the path given by path, but where the extension has been set to ext.

See Also:

withExtension which does not allocate and returns a lazy range.

Examples:

writeln(setExtension("file", "ext")); writeln(setExtension("file"w, ".ext"w)); writeln(setExtension("file."d, "ext"d)); writeln(setExtension("file.", ".ext")); writeln(setExtension("file.old"w, "new"w)); writeln(setExtension("file.old"d, ".new"d));

auto withExtension(R, C)(R path, C[] ext)
if (isRandomAccessRange!R && hasSlicing!R && hasLength!R && isSomeChar!(ElementType!R) && !isSomeString!R && isSomeChar!C);

auto withExtension(C1, C2)(C1[] path, C2[] ext)
if (isSomeChar!C1 && isSomeChar!C2);

Replace existing extension on filespec with new one.

Parameters:

Returns:

Range with path's extension (if any) replaced with ext. The element encoding type of the returned range will be the same as path's.

Examples:

import std.array; writeln(withExtension("file", "ext").array); writeln(withExtension("file"w, ".ext"w).array); writeln(withExtension("file.ext"w, ".").array); import std.utf : byChar, byWchar; writeln(withExtension("file".byChar, "ext").array); writeln(withExtension("file"w.byWchar, ".ext"w).array); writeln(withExtension("file.ext"w.byWchar, ".").array);

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

Parameters:

Returns:

The path given by path, with the extension given by ext 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:

writeln(defaultExtension("file", "ext")); writeln(defaultExtension("file", ".ext")); writeln(defaultExtension("file.", "ext")); writeln(defaultExtension("file.old", "new")); writeln(defaultExtension("file.old", ".new"));

auto withDefaultExtension(R, C)(R path, C[] ext)
if (isRandomAccessRange!R && hasSlicing!R && hasLength!R && isSomeChar!(ElementType!R) && !isSomeString!R && isSomeChar!C);

auto withDefaultExtension(C1, C2)(C1[] path, C2[] ext)
if (isSomeChar!C1 && isSomeChar!C2);

Set the extension of path to ext if path doesn't have one.

Parameters:

Returns:

range with the result

Examples:

import std.array; writeln(withDefaultExtension("file", "ext").array); writeln(withDefaultExtension("file"w, ".ext").array); writeln(withDefaultExtension("file.", "ext").array); writeln(withDefaultExtension("file", "").array); import std.utf : byChar, byWchar; writeln(withDefaultExtension("file".byChar, "ext").array); writeln(withDefaultExtension("file"w.byWchar, ".ext").array); writeln(withDefaultExtension("file.".byChar, "ext"d).array); writeln(withDefaultExtension("file".byChar, "").array);

immutable(ElementEncodingType!(ElementType!Range))[] buildPath(Range)(scope Range segments)
if (isInputRange!Range && !isInfinite!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 by isAbsolute), 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 if paths is a forward range.

Parameters:

Returns:

The assembled path.

Examples:

version (Posix) { writeln(buildPath("foo", "bar", "baz")); writeln(buildPath("/foo/", "bar/baz")); writeln(buildPath("/foo", "/bar")); }

version (Windows) { writeln(buildPath("foo", "bar", "baz")); writeln(buildPath(c:\foo, bar\baz)); writeln(buildPath("foo", d:\bar)); writeln(buildPath("foo", \bar)); writeln(buildPath(c:\foo, \bar)); }

auto chainPath(R1, R2, Ranges...)(R1 r1, R2 r2, Ranges ranges)
if ((isRandomAccessRange!R1 && hasSlicing!R1 && hasLength!R1 && isSomeChar!(ElementType!R1) || isNarrowString!R1 && !isConvertibleToString!R1) && (isRandomAccessRange!R2 && hasSlicing!R2 && hasLength!R2 && isSomeChar!(ElementType!R2) || isNarrowString!R2 && !isConvertibleToString!R2) && (Ranges.length == 0 || is(typeof(chainPath(r2, ranges)))));

Concatenate path segments together to form one path.

Parameters:

Returns:

Lazy range which is the concatenation of r1, r2 and ranges with path separators. The resulting element type is that of r1.

Examples:

import std.array; version (Posix) { writeln(chainPath("foo", "bar", "baz").array); writeln(chainPath("/foo/", "bar/baz").array); writeln(chainPath("/foo", "/bar").array); }

version (Windows) { writeln(chainPath("foo", "bar", "baz").array); writeln(chainPath(c:\foo, bar\baz).array); writeln(chainPath("foo", d:\bar).array); writeln(chainPath("foo", \bar).array); writeln(chainPath(c:\foo, \bar).array); }

import std.utf : byChar; version (Posix) { writeln(chainPath("foo", "bar", "baz").array); writeln(chainPath("/foo/".byChar, "bar/baz").array); writeln(chainPath("/foo", "/bar".byChar).array); }

version (Windows) { writeln(chainPath("foo", "bar", "baz").array); writeln(chainPath(c:\foo.byChar, bar\baz).array); writeln(chainPath("foo", d:\bar).array); writeln(chainPath("foo", \bar.byChar).array); writeln(chainPath(c:\foo, \barw).array); }

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

Performs the same task as buildPath, while at the same time resolving current/parent directory symbols ("." and "..") and removing superfluous directory separators. It will return "." if the path leads to the starting directory. On Windows, slashes are replaced with backslashes.

Using buildNormalizedPath on null paths will always return null.

Note that this function does not resolve symbolic links.

This function always allocates memory to hold the resulting path. Use asNormalizedPath to not allocate memory.

Parameters:

Returns:

The assembled path.

Examples:

writeln(buildNormalizedPath("foo", "..")); version (Posix) { writeln(buildNormalizedPath("/foo/./bar/..//baz/")); writeln(buildNormalizedPath("../foo/.")); writeln(buildNormalizedPath("/foo", "bar/baz/")); writeln(buildNormalizedPath("/foo", "/bar/..", "baz")); writeln(buildNormalizedPath("foo/./bar", "../../", "../baz")); writeln(buildNormalizedPath("/foo/./bar", "../../baz")); }

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

auto asNormalizedPath(R)(return scope R path)
if (isSomeChar!(ElementEncodingType!R) && (isRandomAccessRange!R && hasSlicing!R && hasLength!R || isNarrowString!R) && !isConvertibleToString!R);

Normalize a path by resolving current/parent directory symbols ("." and "..") and removing superfluous directory separators. It will return "." if the path leads to the starting directory. On Windows, slashes are replaced with backslashes.

Using asNormalizedPath on empty paths will always return an empty path.

Does not resolve symbolic links.

This function always allocates memory to hold the resulting path. Use buildNormalizedPath to allocate memory and return a string.

Parameters:

Returns:

normalized path as a forward range

Examples:

import std.array; writeln(asNormalizedPath("foo/..").array); version (Posix) { writeln(asNormalizedPath("/foo/./bar/..//baz/").array); writeln(asNormalizedPath("../foo/.").array); writeln(asNormalizedPath("/foo/bar/baz/").array); writeln(asNormalizedPath("/foo/./bar/../../baz").array); }

version (Windows) { writeln(asNormalizedPath(c:\foo\.\bar/..\\baz\).array); writeln(asNormalizedPath(..\foo\.).array); writeln(asNormalizedPath(c:\foo\bar\baz\).array); writeln(asNormalizedPath(c:\foo\bar/..).array); assert(asNormalizedPath(\\server\share\foo\..\bar).array == \\server\share\bar); }

auto pathSplitter(R)(R path)
if ((isRandomAccessRange!R && hasSlicing!R || isNarrowString!R) && !isConvertibleToString!R);

Slice up a path into its elements.

Parameters:

Returns:

bidirectional range of slices of path

Examples:

import std.algorithm.comparison : equal; import std.conv : to;

assert(equal(pathSplitter("/"), ["/"])); assert(equal(pathSplitter("/foo/bar"), ["/", "foo", "bar"])); assert(equal(pathSplitter("foo/../bar//./"), ["foo", "..", "bar", "."]));

version (Posix) { 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"])); }

bool isRooted(R)(R path)
if (isRandomAccessRange!R && isSomeChar!(ElementType!R) || is(StringTypeOf!R));

Determines whether a path starts at a root directory.

Returns:

Whether a path starts at a root directory.

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

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

Examples:

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

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

pure nothrow @safe bool isAbsolute(R)(R path)
if (isRandomAccessRange!R && isSomeChar!(ElementType!R) || is(StringTypeOf!R));

Determines whether a path is absolute or not.

Returns:

Whether a path is absolute or not.

Example On POSIX, an absolute path starts at the root directory. (In fact, _isAbsolute is just an alias for isRooted.)

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:/, where d 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 string absolutePath(return scope const string path, lazy string base = getcwd());

Transforms path into an absolute path.

The following algorithm is used:

1. If path is empty, return null.
2. If path is already absolute, return it.
3. Otherwise, append path to base and return the result. If base 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.

Note that absolutePath will not normalize .. segments. Use buildNormalizedPath(absolutePath(path)) if that is desired.

Parameters:

Returns:

string of transformed path

Throws:

Exception if the specified base directory is not absolute.

See Also:

asAbsolutePath which does not allocate

Examples:

version (Posix) { writeln(absolutePath("some/file", "/foo/bar")); writeln(absolutePath("../file", "/foo/bar")); writeln(absolutePath("/some/file", "/foo/bar")); }

version (Windows) { writeln(absolutePath(some\file, c:\foo\bar)); writeln(absolutePath(..\file, c:\foo\bar)); writeln(absolutePath(c:\some\file, c:\foo\bar)); writeln(absolutePath(\, c:\)); writeln(absolutePath(\some\file, c:\foo\bar)); }

auto asAbsolutePath(R)(R path)
if ((isRandomAccessRange!R && isSomeChar!(ElementType!R) || isNarrowString!R) && !isConvertibleToString!R);

Transforms path into an absolute path.

The following algorithm is used:

1. If path is empty, return null.
2. If path is already absolute, return it.
3. Otherwise, append path to the current working directory, which allocates memory.

Note that asAbsolutePath will not normalize .. segments. Use asNormalizedPath(asAbsolutePath(path)) if that is desired.

Parameters:

Returns:

the transformed path as a lazy range

See Also:

absolutePath which returns an allocated string

Examples:

import std.array; writeln(asAbsolutePath(cast(string)null).array); version (Posix) { writeln(asAbsolutePath("/foo").array); } version (Windows) { writeln(asAbsolutePath("c:/foo").array); } asAbsolutePath("foo");

string relativePath(CaseSensitive cs = CaseSensitive.osDefault)(string path, lazy string base = getcwd());

Translates path into a relative path.

The returned path is relative to base, 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. If path and base refer to the same directory, the function returns ..

The following algorithm is used:

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

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

This function allocates memory.

Parameters:

Returns:

The relative path.

See Also:

asRelativePath which does not allocate memory

Throws:

Exception if the specified base directory is not absolute.

Examples:

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

auto asRelativePath(CaseSensitive cs = CaseSensitive.osDefault, R1, R2)(R1 path, R2 base)
if ((isNarrowString!R1 || isRandomAccessRange!R1 && hasSlicing!R1 && isSomeChar!(ElementType!R1) && !isConvertibleToString!R1) && (isNarrowString!R2 || isRandomAccessRange!R2 && hasSlicing!R2 && isSomeChar!(ElementType!R2) && !isConvertibleToString!R2));

Transforms path into a path relative to base.

The returned path is relative to base, which is usually the current working directory.base must be an absolute path, and it is always assumed to refer to a directory. If path and base refer to the same directory, the function returns '.'.

The following algorithm is used:

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

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

Parameters:

Returns:

a random access range of the transformed path

Examples:

import std.array; version (Posix) { writeln(asRelativePath("foo", "/bar").array); writeln(asRelativePath("/foo/bar", "/foo/bar").array); writeln(asRelativePath("/foo/bar", "/foo/baz").array); writeln(asRelativePath("/foo/bar/baz", "/foo/woo/wee").array); writeln(asRelativePath("/foo/bar/baz", "/foo/bar").array); } else version (Windows) { writeln(asRelativePath("foo", c:\bar).array); writeln(asRelativePath(c:\foo\bar, c:\foo\bar).array); writeln(asRelativePath(c:\foo\bar, c:\foo\baz).array); writeln(asRelativePath(c:\foo\bar\baz, c:\foo\woo\wee).array); writeln(asRelativePath(c:/foo/bar/baz, c:\foo\woo\wee).array); writeln(asRelativePath(c:\foo\bar\baz, c:\foo\bar).array); writeln(asRelativePath(c:\foo\bar, d:\foo).array); writeln(asRelativePath(\\foo\bar, c:\foo).array); } else static assert(0);

pure nothrow @safe int filenameCharCmp(CaseSensitive cs = CaseSensitive.osDefault)(dchar a, dchar b);

Compares filename characters.

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

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

Parameters:

Returns:

< 0 if a < b,0 if a == b, and> 0 if a > b.

Examples:

writeln(filenameCharCmp('a', 'a')); assert(filenameCharCmp('a', 'b') < 0); assert(filenameCharCmp('b', 'a') > 0);

version (linux) { assert(filenameCharCmp('A', 'a') < 0); assert(filenameCharCmp('a', 'A') > 0); } version (Windows) { writeln(filenameCharCmp('a', 'A')); assert(filenameCharCmp('a', 'B') < 0); assert(filenameCharCmp('A', 'b') < 0); }

int filenameCmp(CaseSensitive cs = CaseSensitive.osDefault, Range1, Range2)(Range1 filename1, Range2 filename2)
if (isSomeFiniteCharInputRange!Range1 && !isConvertibleToString!Range1 && isSomeFiniteCharInputRange!Range2 && !isConvertibleToString!Range2);

Compares file names and returns

Individual characters are compared using filenameCharCmp!cs, where cs is an optional template parameter determining whether the comparison is case sensitive or not.

Treatment of invalid UTF encodings is implementation defined.

Parameters:

Returns:

< 0 if filename1 < filename2,0 if filename1 == filename2 and> 0 if filename1 > filename2.

Examples:

writeln(filenameCmp("abc", "abc")); assert(filenameCmp("abc", "abd") < 0); assert(filenameCmp("abc", "abb") > 0); assert(filenameCmp("abc", "abcd") < 0); assert(filenameCmp("abcd", "abc") > 0);

version (linux) { assert(filenameCmp("Abc", "abc") < 0); assert(filenameCmp("abc", "Abc") > 0); } version (Windows) { writeln(filenameCmp("Abc", "abc")); writeln(filenameCmp("abc", "Abc")); assert(filenameCmp("Abc", "abD") < 0); assert(filenameCmp("abc", "AbB") > 0); }

pure nothrow @safe bool globMatch(CaseSensitive cs = CaseSensitive.osDefault, C, Range)(Range path, const(C)[] pattern)
if (isForwardRange!Range && !isInfinite!Range && isSomeChar!(ElementEncodingType!Range) && !isConvertibleToString!Range && isSomeChar!C && is(immutable(C) == immutable(ElementEncodingType!Range)));

Matches a pattern against a path.

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

Individual characters are compared using filenameCharCmp!cs, where cs 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.

Parameters:

Returns:

true if pattern matches path, false otherwise.

Examples:

assert(globMatch("foo.bar", "")); assert(globMatch("foo.bar", ".")); assert(globMatch(foo/foo\bar, "fb*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) { assert(globMatch("foo", "Foo")); assert(globMatch("Goo.bar", "[fg]???bar")); } version (linux) { assert(!globMatch("foo", "Foo")); assert(!globMatch("Goo.bar", "[fg]???bar")); }

bool isValidFilename(Range)(Range filename)
if ((isRandomAccessRange!Range && hasLength!Range && hasSlicing!Range && isSomeChar!(ElementEncodingType!Range) || isNarrowString!Range) && !isConvertibleToString!Range);

Checks that the given file or directory name is valid.

The maximum length of filename 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 of wchars.)

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 following reserved characters: <>:"/\|?*
• filename may not end with a space (' ') or a period ('.').

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

Parameters:

Returns:

true if and only if filename is not empty, not too long, and does not contain invalid characters.

Examples:

import std.utf : byCodeUnit;

assert(isValidFilename("hello.exe".byCodeUnit));

bool isValidPath(Range)(Range path)
if ((isRandomAccessRange!Range && hasLength!Range && hasSlicing!Range && isSomeChar!(ElementEncodingType!Range) || isNarrowString!Range) && !isConvertibleToString!Range);

Checks whether path is a valid path.

Generally, this function checks that path is not empty, and that each component of the path either satisfies isValidFilename or is equal to "." or "..".

It does not check whether the path points to an existing file or directory; use std.file.exists for this purpose.

On Windows, some special rules apply:

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

Parameters:

Returns:

true if path is a valid path.

Examples:

assert(isValidPath("/foo/bar")); assert(!isValidPath("/foo\0/bar")); assert(isValidPath("/")); assert(isValidPath("a"));

version (Windows) { assert(isValidPath(c:\)); assert(isValidPath(c:\foo)); assert(isValidPath(c:\foo\.\bar\\\..\)); assert(!isValidPath(!:\foo)); assert(!isValidPath(c::\foo)); assert(!isValidPath(c:\foo?)); assert(!isValidPath(c:\foo.));

assert(isValidPath(`\\server\share`));
assert(isValidPath(`\\server\share\foo`));
assert(isValidPath(`\\server\share\\foo`));
assert(!isValidPath(`\\\server\share\foo`));
assert(!isValidPath(`\\server\\share\foo`));
assert(!isValidPath(`\\ser*er\share\foo`));
assert(!isValidPath(`\\server\sha?e\foo`));
assert(!isValidPath(`\\server\share\|oo`));

assert(isValidPath(`\\?\<>:"?*|/\..\.`));
assert(!isValidPath("\\\\?\\foo\0bar"));

assert(!isValidPath(`\\.\PhysicalDisk1`));
assert(!isValidPath(`\\`));

}

import std.utf : byCodeUnit; assert(isValidPath("/foo/bar".byCodeUnit));

nothrow @safe string expandTilde(return scope const string inputPath);

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 variable HOME. 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.

Parameters:

Returns:

inputPath with the tilde expanded, or just inputPath if it could not be expanded. For Windows, expandTilde merely returns its argument inputPath.

Example

void processFile(string path) { auto fullPath = expandTilde(path); ... }

Examples:

version (Posix) { import std.process : environment;

auto oldHome = environment["HOME"];
scope(exit) environment["HOME"] = oldHome;

environment["HOME"] = "dmd/test";
writeln(expandTilde("~/"));     writeln(expandTilde("~")); }

Copyright © 1999-2025 by the D Language Foundation | Page generated byDdoc on Sun Jun 15 08:05:54 2025