buildPath

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.

  1. immutable(ElementEncodingType!(ElementType!Range))[] buildPath(Range segments)
    immutable(ElementEncodingType!(ElementType!Range))[]
    buildPath
    (
    Range
    )
    (
    scope Range segments
    )
    if (
    isInputRange!Range &&
    !isInfinite!Range
    &&
    isSomeString!(ElementType!Range)
    )
  2. immutable(C)[] buildPath(const(C)[][] paths)

Parameters

segments Range

An input range of segments to assemble the path from.

Return Value

Type: immutable(ElementEncodingType!(ElementType!Range))[]

The assembled path.

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

Meta