tango.io.Path

if (exists ("some/file/path"))
    ...

import Path = tango.io.Path;

if (Path.exists ("some/file/path"))
    ...

auto p = Path.parse ("some/file/path");
auto path = p.path;
auto name = p.name;
auto suffix = p.suffix;
...

struct FS;

Wraps the O/S specific calls with a D API. Note that these accept null-terminated strings only, which is why it's not public. We need this declared first to avoid forward-reference issues.

struct Stamps;

TimeStamp information. Accurate to whatever the F/S supports.

Time created;

Time created.

Time accessed;

Last time accessed.

Time modified;

Last time modified.

struct Listing;

Some fruct glue for directory listings.

static void exception(const(char)[] filename);

Throw an exception using the last known error.

static void exception(const(char)[] prefix, const(char)[] error);

Throw an IO exception.

static inout(char)[] padded(inout(char)[] path, char c = '/');

Return an adjusted path such that non-empty instances always have a trailing separator.

Note:
Allocates memory where path is not already terminated.

static inout(char)[] paddedLeading(inout(char)[] path, char c = '/');

Return an adjusted path such that non-empty instances always have a leading separator.

Note:
Allocates memory where path is not already terminated.

static inout(char)[] stripped(inout(char)[] path, char c = '/');

Return an adjusted path such that non-empty instances do not have a trailing separator.

static char[] join(const(char[])[] paths...);

Join a set of path specs together. A path separator is potentially inserted between each of the segments.

Note:
Allocates memory.

static char[] strz(const(char)[] src, char[] dst);

Append a terminating null onto a string, cheaply where feasible.

Note:
Allocates memory where the dst is too small.

static bool exists(const(char)[] name);

Return whether the file or path exists.

Posix-specific code.

static ulong fileSize(const(char)[] name);

Return the file length (in bytes.)

Posix-specific code.

static bool isWritable(const(char)[] name);

Is this file writable?

Posix-specific code.

static bool isFolder(const(char)[] name);

Is this file actually a folder/directory?

Posix-specific code.

static bool isFile(const(char)[] name);

Is this a normal file?

Posix-specific code.

static Stamps timeStamps(const(char)[] name);

Return timestamp information.

Timestamps are returns in a format dictated by the file-system. For example NTFS keeps UTC time, while FAT timestamps are based on the local time.





Posix-specific code.

static void timeStamps(const(char)[] name, Time accessed, Time modified);

Set the accessed and modified timestamps of the specified file.

Posix-specific code.

static void copy(const(char)[] source, const(char)[] dest);

Transfer the content of another file to this one. Returns a reference to this class on success, or throws an IOException upon failure.

Note:
Allocates a memory buffer.





Posix-specific code.

static bool remove(const(char)[] name);

Remove the file/directory from the file-system. Returns true on success - false otherwise.

Posix-specific code.

static void rename(const(char)[] src, const(char)[] dst);

Change the name or location of a file/directory.

Posix-specific code.

static void createFile(const(char)[] name);

Create a new file.

Posix-specific code.

static void createFolder(const(char)[] name);

Create a new directory.

Posix-specific code.

static int list(const(char)[] folder, scope int delegate(ref FileInfo) dg, bool all = false);

List the set of filenames within this folder.

Each path and filename is passed to the provided delegate, along with the path prefix and whether the entry is a folder or not.

Note:
Allocates and reuses a small memory buffer.





Posix-specific code.

struct PathParser(char_t = char);

Parses a file path.

File paths containing non-ansi characters should be UTF-8 encoded. Supporting Unicode in this manner was deemed to be more suitable than providing a wchar version of PathParser, and is both consistent & compatible with the approach taken with the Uri class.

Note that patterns of adjacent '.' separators are treated specially in that they will be assigned to the name where there is no distinct suffix. In addition, a '.' at the start of a name signifies it does not belong to the suffix i.e. ".file" is a name rather than a suffix. Patterns of intermediate '.' characters will otherwise be assigned to the suffix, such that "file....suffix" includes the dots within the suffix itself. See method ext() for a suffix without dots.

Note also that normalization of path-separators does *not* occur by default. This means that usage of '\' characters should be explicitly converted beforehand into '/' instead (an exception is thrown in those cases where '\' is present). On-the-fly conversion is avoided because (a) the provided path is considered immutable and (b) we avoid taking a copy of the original path. Module FilePath exists at a higher level, without such contraints.

PathParser parse(char_t[] path);

Parse the path spec.

const PathParser dup();

Duplicate this path.

Note:
Allocates memory for the path content.

inout inout(char_t)[] dString();

Return the complete text of this filepath.

inout inout(char_t)[] root();

Return the root of this path. Roots are constructs such as "C:".

inout inout(char_t)[] folder();

Return the file path. Paths may start and end with a "/". The root path is "/" and an unspecified path is returned as an empty string. Directory paths may be split such that the directory name is placed into the 'name' member; directory paths are treated no differently than file paths.

inout inout(char_t)[] parent();

Returns a path representing the parent of this one. This will typically return the current path component, though with a special case where the name component is empty. In such cases, the path is scanned for a prior segment:

• normal: /x/y/z => /x/y
• special: /x/y/ => /x
• normal: /x => /
• normal: / => [empty]

Note that this returns a path suitable for splitting into path and name components (there's no trailing separator).

inout inout(char_t)[] pop();

Pop the rightmost element off this path, stripping off a trailing '/' as appropriate:

• /x/y/z => /x/y
• /x/y/ => /x/y (note trailing '/' in the original)
• /x/y => /x
• /x => /
• / => [empty]

Note that this returns a path suitable for splitting into path and name components (there's no trailing separator).

inout inout(char_t)[] name();

Return the name of this file, or directory.

char_t[] ext();

Ext is the tail of the filename, rightward of the rightmost '.' separator e.g. path "foo.bar" has ext "bar". Note that patterns of adjacent separators are treated specially - for example, ".." will wind up with no ext at all.

inout inout(char_t)[] suffix();

Suffix is like ext, but includes the separator e.g. path "foo.bar" has suffix ".bar".

inout inout(char_t)[] path();

Return the root + folder combination.

inout inout(char_t)[] file();

Return the name + suffix combination.

bool isAbsolute();

Returns true if this path is *not* relative to the current working directory.

bool isEmpty();

Returns true if this FilePath is empty.

bool isChild();

Returns true if this path has a parent. Note that a parent is defined by the presence of a path-separator in the path. This means 'foo' within "/foo" is considered a child of the root.

bool equals(const(char)[] s);

Does this path equate to the given text? We ignore trailing path-separators when testing equivalence.

PathParser parse(char_t[] path, size_t end);

Parse the path spec with explicit end point. A '\' is considered illegal in the path and should be normalized out before this is invoked (the content managed here is considered immutable, and thus cannot be changed by this function.)

bool exists(const(char)[] name);

Does this path currently exist?

Time modified(const(char)[] name);

Returns the time of the last modification. Accurate to whatever the F/S supports, and in a format dictated by the file-system. For example NTFS keeps UTC time, while FAT timestamps are based on the local time.

Time accessed(const(char)[] name);

Returns the time of the last access. Accurate to whatever the F/S supports, and in a format dictated by the file-system. For example NTFS keeps UTC time, while FAT timestamps are based on the local time.

Time created(const(char)[] name);

Returns the time of file creation. Accurate to whatever the F/S supports, and in a format dictated by the file-system. For example NTFS keeps UTC time, while FAT timestamps are based on the local time.

ulong fileSize(const(char)[] name);

Return the file length (in bytes.)

bool isWritable(const(char)[] name);

Is this file writable?

bool isFolder(const(char)[] name);

Is this file actually a folder/directory?

bool isFile(const(char)[] name);

Is this file actually a normal file? Not a directory or (on unix) a device file or link.

FS.Stamps timeStamps(const(char)[] name);

Return timestamp information.

Timestamps are returns in a format dictated by the file-system. For example NTFS keeps UTC time, while FAT timestamps are based on the local time.

void timeStamps(const(char)[] name, Time accessed, Time modified);

Set the accessed and modified timestamps of the specified file.

Since:
0.99.9

bool remove(const(char)[] name);

Remove the file/directory from the file-system. Returns true if successful, false otherwise.

char[][] remove(char[][] paths);

Remove the files and folders listed in the provided paths. Where folders are listed, they should be preceded by their contained files in order to be successfully removed. Returns a set of paths that failed to be removed (where .length is zero upon success).

The collate() function can be used to provide the input paths:

remove (collate (".", "*.d", true));

Use with great caution.

Note:
May allocate memory.

Since:
0.99.9

void createFile(const(char)[] name);

Create a new file.

void createFolder(const(char)[] name);

Create a new directory.

void createPath(const(char)[] path);

Create an entire path consisting of this folder along with all parent folders. The path should not contain '.' or '..' segments, which can be removed via the normalize() function.

Note that each segment is created as a folder, including the trailing segment.

Throws:
IOException upon system errors.

Throws:
IllegalArgumentException if a segment exists but as a file instead of a folder.

void rename(const(char)[] src, const(char)[] dst);

Change the name or location of a file/directory.

void copy(const(char)[] src, const(char)[] dst);

Transfer the content of one file to another. Throws an IOException upon failure.

FS.Listing children(const(char)[] path, bool all = false);

Provides foreach support via a fruct, as in

foreach (info; children("myfolder"))
    ...

Each path and filename is passed to the foreach delegate, along with the path prefix and whether the entry is a folder or not. The info construct exposes the following attributes:

char[]  path
char[]  name
ulong   bytes
bool    folder

Argument 'all' controls whether hidden and system files are included - these are ignored by default.

char[][] collate(const(char)[] path, const(char)[] pattern, bool recurse = false);

Collate all files and folders from the given path whose name matches the given pattern. Folders will be traversed where recurse is enabled, and a set of matching names is returned as filepaths (including those folders which match the pattern.)

Note:
Allocates memory for returned paths.

Since:
0.99.9

char[] join(const(char[])[] paths...);

Join a set of path specs together. A path separator is potentially inserted between each of the segments.

Note:
May allocate memory.

char[] standard(char[] path);

Convert path separators to a standard format, using '/' as the path separator. This is compatible with Uri and all of the contemporary O/S which Tango supports. Known exceptions include the Windows command-line processor, which considers '/' characters to be switches instead. Use the native() method to support that.

Note:
Mutates the provided path.

char[] native(char[] path);

Convert to native O/S path separators where that is required, such as when dealing with the Windows command-line.

Note:
Mutates the provided path. Use this pattern to obtain a copy instead: native(path.dup);

inout(char)[] parent(inout(char)[] path);

Returns a path representing the parent of this one, with a special case concerning a trailing '/':

• normal: /x/y/z => /x/y
• normal: /x/y/ => /x/y
• special: /x/y/ => /x
• normal: /x => /
• normal: / => empty

The result can be split via parse().

inout(char)[] pop(inout(char)[] path);

Returns a path representing the parent of this one:

• normal: /x/y/z => /x/y
• normal: /x/y/ => /x/y
• normal: /x => /
• normal: / => empty

The result can be split via parse().

inout(char)[] split(inout(char)[] path, out inout(char)[] head, out inout(char)[] tail);

Break a path into "head" and "tail" components. For example:

• "/a/b/c" -> "/a","b/c"
• "a/b/c" -> "a","b/c"

char[] replace(char[] path, char from, char to);

Replace all path 'from' instances with 'to', in place (overwrites the provided path).

PathParser!(char_t) parse(char_t)(char_t[] path);

Parse a path into its constituent components.

Note that the provided path is sliced, not duplicated.

Examples:

auto p = parse ("/foo/bar/file.ext".dup);
assert (p.equals("/foo/bar/file.ext"));
assert (p.folder == "/foo/bar/");
assert (p.path == "/foo/bar/");
assert (p.file == "file.ext");
assert (p.name == "file");
assert (p.suffix == ".ext");
assert (p.ext == "ext");
assert (p.isChild == true);
assert (p.isEmpty == false);
assert (p.isAbsolute == true);

bool patternMatch(const(char)[] filename, const(char)[] pattern);

Matches a pattern against a filename.

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

*	Matches 0 or more instances of any character.
?	Matches exactly one instances of any character.
[]	Matches one instance of any character that appears between the brackets.
[!]	Matches one instance of any character that does not appear between the brackets after the exclamation mark.

Internally individual character comparisons are done calling charMatch(), so its rules apply here too. Note that path separators and dots don't stop a meta-character from matching further portions of the filename.

Returns:
true if pattern matches filename, false otherwise.

Throws:
Nothing.

version (Win32)
{
  patternMatch("foo.bar", "*"); // => true
  patternMatch(r"foo/foo\bar", "f*b*r"); // => true
  patternMatch("foo.bar", "f?bar"); // => false
  patternMatch("Goo.bar", "[fg]???bar"); // => true
  patternMatch(r"d:\foo\bar", "d*foo?bar"); // => true
}
version (Posix)
{
  patternMatch("Go*.bar", "[fg]???bar"); // => false
  patternMatch("/foo*home/bar", "?foo*bar"); // => true
  patternMatch("foobar", "foo?bar"); // => true
}

Examples:

version (Win32)
assert(patternMatch("foo", "Foo"));
version (Posix)
assert(!patternMatch("foo", "Foo"));

assert(patternMatch("foo", "*"));
assert(patternMatch("foo.bar", "*"));
assert(patternMatch("foo.bar", "*.*"));
assert(patternMatch("foo.bar", "foo*"));
assert(patternMatch("foo.bar", "f*bar"));
assert(patternMatch("foo.bar", "f*b*r"));
assert(patternMatch("foo.bar", "f???bar"));
assert(patternMatch("foo.bar", "[fg]???bar"));
assert(patternMatch("foo.bar", "[!gh]*bar"));

assert(!patternMatch("foo", "bar"));
assert(!patternMatch("foo", "*.*"));
assert(!patternMatch("foo.bar", "f*baz"));
assert(!patternMatch("foo.bar", "f*b*x"));
assert(!patternMatch("foo.bar", "[gh]???bar"));
assert(!patternMatch("foo.bar", "[!fg]*bar"));
assert(!patternMatch("foo.bar", "[fg]???baz"));

char[] normalize(const(char)[] in_path, char[] buf = null);

Normalizes a path component.

• . segments are removed
• <segment>/.. are removed

Multiple consecutive forward slashes are replaced with a single forward slash. On Windows, \ will be converted to / prior to any normalization.

Note that any number of .. segments at the front is ignored, unless it is an absolute path, in which case they are removed.

The input path is copied into either the provided buffer, or a heap allocated array if no buffer was provided. Normalization modifies this copy before returning the relevant slice.

normalize("/home/foo/./bar/../../john/doe"); // => "/home/john/doe"

Note:
Allocates memory.

Examples:

assert (normalize ("") == "");
assert (normalize ("/home/../john/../.tango/.htaccess") == "/.tango/.htaccess");
assert (normalize ("/home/../john/../.tango/foo.conf") == "/.tango/foo.conf");
assert (normalize ("/home/john/.tango/foo.conf") == "/home/john/.tango/foo.conf");
assert (normalize ("/foo/bar/.htaccess") == "/foo/bar/.htaccess");
assert (normalize ("foo/bar/././.") == "foo/bar/");
assert (normalize ("././foo/././././bar") == "foo/bar");
assert (normalize ("/foo/../john") == "/john");
assert (normalize ("foo/../john") == "john");
assert (normalize ("foo/bar/..") == "foo/");
assert (normalize ("foo/bar/../john") == "foo/john");
assert (normalize ("foo/bar/doe/../../john") == "foo/john");
assert (normalize ("foo/bar/doe/../../john/../bar") == "foo/bar");
assert (normalize ("./foo/bar/doe") == "foo/bar/doe");
assert (normalize ("./foo/bar/doe/../../john/../bar") == "foo/bar");
assert (normalize ("./foo/bar/../../john/../bar") == "bar");
assert (normalize ("foo/bar/./doe/../../john") == "foo/john");
assert (normalize ("../../foo/bar") == "../../foo/bar");
assert (normalize ("../../../foo/bar") == "../../../foo/bar");
assert (normalize ("d/") == "d/");
assert (normalize ("/home/john/./foo/bar.txt") == "/home/john/foo/bar.txt");
assert (normalize ("/home//john") == "/home/john");

assert (normalize("/../../bar/") == "/bar/");
assert (normalize("/../../bar/../baz/./") == "/baz/");
assert (normalize("/../../bar/boo/../baz/.bar/.") == "/bar/baz/.bar/");
assert (normalize("../..///.///bar/..//..//baz/.//boo/..") == "../../../baz/");
assert (normalize("./bar/./..boo/./..bar././/") == "bar/..boo/..bar./");
assert (normalize("/bar/..") == "/");
assert (normalize("bar/") == "bar/");
assert (normalize(".../") == ".../");
assert (normalize("///../foo") == "/foo");
assert (normalize("./foo") == "foo");
auto buf = new char[100];
auto ret = normalize("foo/bar/./baz", buf);
assert (ret.ptr == buf.ptr);
assert (ret == "foo/bar/baz");

version (Windows)
        {
        assert (normalize ("\\foo\\..\\john") == "/john");
        assert (normalize ("foo\\..\\john") == "john");
        assert (normalize ("foo\\bar\\..") == "foo/");
        assert (normalize ("foo\\bar\\..\\john") == "foo/john");
        assert (normalize ("foo\\bar\\doe\\..\\..\\john") == "foo/john");
        assert (normalize ("foo\\bar\\doe\\..\\..\\john\\..\\bar") == "foo/bar");
        assert (normalize (".\\foo\\bar\\doe") == "foo/bar/doe");
        assert (normalize (".\\foo\\bar\\doe\\..\\..\\john\\..\\bar") == "foo/bar");
        assert (normalize (".\\foo\\bar\\..\\..\\john\\..\\bar") == "bar");
        assert (normalize ("foo\\bar\\.\\doe\\..\\..\\john") == "foo/john");
        assert (normalize ("..\\..\\foo\\bar") == "../../foo/bar");
        assert (normalize ("..\\..\\..\\foo\\bar") == "../../../foo/bar");
        assert (normalize(r"C:") == "C:");
        assert (normalize(r"C") == "C");
        assert (normalize(r"c:\") == "C:/");
        assert (normalize(r"C:\..\.\..\..\") == "C:/");
        assert (normalize(r"c:..\.\boo\") == "C:../boo/");
        assert (normalize(r"C:..\..\boo\foo\..\.\..\..\bar") == "C:../../../bar");
        assert (normalize(r"C:boo\..") == "C:");
        }