Changeset 1835

Timestamp:

03/03/07 15:45:02 (2 years ago)

Author:

kris

Message:

- folded FileProxy? into FilePath?, to make life easier for everyone
- PathView? is now an interface, for possible use with the VFS
- File, UnicodeFile? and FileConduit? support PathView?
- all repo code updated to reflect this change

Files:

• trunk/example/conduits/fileops.d (modified) (1 diff)
• trunk/example/conduits/filescanregex.d (modified) (1 diff)
• trunk/install/windows/switch.d (modified) (5 diffs)
• trunk/tango/io/File.d (modified) (5 diffs)
• trunk/tango/io/FileConduit.d (modified) (1 diff)
• trunk/tango/io/FilePath.d (modified) (26 diffs)
• trunk/tango/io/FileProxy.d (deleted)
• trunk/tango/io/FileScan.d (modified) (11 diffs)
• trunk/tango/io/UnicodeFile.d (modified) (7 diffs)
• trunk/tango/sys/Environment.d (modified) (3 diffs)
• trunk/tango/util/log/RollingFileAppender.d (modified) (2 diffs)

trunk/example/conduits/fileops.d

@@ -9 +9 @@
-import tango.io.Stdout;
-
-roxy
+ath
-
-void main (char[][] args) 
-{
-    auto src = args[0] ~ ".d";
-roxy
+ath
-
-    Stdout.formatln ("copy file {} to {}", src, dst);

trunk/example/conduits/filescanregex.d

@@ -21 +21 @@
-    scope regex =  Regex(r"\.(d|obj)$");
-
-roxy
+ath
-         return isDir || regex.test(fp.toUtf8); 
-    });

trunk/install/windows/switch.d

@@ -5 +5 @@
-import tango.stdc.stdio;
-import tango.stdc.stdlib;
-roxy
+ath
-import tango.text.Util;
-import tango.text.Ascii;
@@ -42 +42 @@
-    {
-        // attempt to auto-detect library path
-roxy
+ath
-            currentDir = "..\\";
-        else
-roxy
+ath
-            currentDir = ".\\";
-        else
@@ -55 +55 @@
-            {
-                char[] programFolder = commandLine[0..pos+1];
-roxy
+ath
-                    currentDir = programFolder ~ "..\\";
-                else
-roxy
+ath
-                    currentDir = programFolder;
-            }
@@ -88 +88 @@
-        // (see WideCharToMultiByte).
-
-roxy(targetLib)).getSize==(new FileProxy
+ath(targetLib)).getSize==(new FilePath
-        {
-            showMessage("You are already using Phobos.");
@@ -105 +105 @@
-    if ( target == "tango" ) // switch to Tango
-    {
-roxy(targetLib)).getSize==(new FileProxy
+ath(targetLib)).getSize==(new FilePath
-        {
-            showMessage("You are already using Tango.");

trunk/tango/io/File.d

@@ -14 +14 @@
-module tango.io.File;
-
-roxy
+ath
-                tango.io.FileConduit;
-
@@ -37 +37 @@
-class File
-{
-FileProxy proxy
+PathView path
-
-        /***********************************************************************
@@ -47 +47 @@
-        this (char[] path)
-        {
-roxy
+ath
-        }
-
-        /***********************************************************************
-        
-roxy
+ath
-
-        ***********************************************************************/
-                                  
-FileProxy proxy
+PathView path
-        {
-roxy_ = proxy
+ath_ = path
-        }
-
-        /***********************************************************************
-
-roxy
+ath
-
-        ***********************************************************************/
-
-FileProxy proxy
+PathView path
-        {
-roxy
+ath
-        }
-
@@ -80 +80 @@
-        final void[] read ()
-        {
-roxy
+ath
-                scope (exit)
-                       conduit.close;
@@ -123 +123 @@
-        private File write (void[] content, FileConduit.Style style)
-        {      
-roxy
+ath
-                scope (exit)
-                       conduit.close;

trunk/tango/io/FileConduit.d

@@ -116 +116 @@
-
-
-Proxy, File
+
-        additional functionality related to file manipulation. 
-

trunk/tango/io/FilePath.d

@@ -8 +8 @@
-        version:        Nov 2006: Australian version
-        version:        Feb 2007: Mutating version
+        version:        Mar 2007: Folded FileProxy in
-
-        author:         Kris
@@ -15 +16 @@
-module tango.io.FilePath;
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-/*******************************************************************************
@@ -38 +75 @@
-        called PathView, which can be used to provide a view into the
-        content as desired.
+
+        Compile with -version=Win32SansUnicode to enable Win95 & Win32s file
+        support.
-
-*******************************************************************************/
@@ -66 +106 @@
-                will result in an empty name attribute.
-
-                To ascertain if a FilePath exists on a system, or to access
-                various other physical attributes, use methods exposed via
-                tango.io.FileProxy and tango.io.File
-
-                With regard to the filepath copy, we found the common case to
-                be an explicit .dup, whereas aliasing appeared to be rare by
@@ -205 +241 @@
-        {
-                return fp [name_ .. end_];
- 
+
-
-        /***********************************************************************
@@ -259 +295 @@
-        /***********************************************************************
-
- 
+
-                via the constructor or method set()
-
@@ -395 +431 @@
-
-        final FilePath ext (char[] other)
-       
+
-                auto len = ext.length;
-                adjust (end_ - len, end_, len, prefixed (other, '.'));
@@ -423 +459 @@
-        /***********************************************************************
-
- 
+
-                potentially inserted between each of the segments.
-
@@ -433 +469 @@
-
-                foreach (path; paths)
-         
+
-
-                return result.length ? result [0 .. $-1] : null;
@@ -480 +516 @@
-        }
-
+
+        /**********************************************************************/
+        /**************************  proxy methods ****************************/
+        /**********************************************************************/
+
+
+        /***********************************************************************
+
+                Does this path currently exist?
+
+        ***********************************************************************/
+
+        final bool exists ()
+        {
+                try {
+                    fileSize();
+                    return true;
+                    } catch (IOException){}
+                return false;
+        }
+
+        /***********************************************************************
+
+                Returns the time of the last modification. Accurate
+                to whatever the OS supports
+
+        ***********************************************************************/
+
+        final Time modified ()
+        {
+                return timeStamps.modified;
+        }
+
+        /***********************************************************************
+
+                Returns the time of the last access. Accurate to
+                whatever the OS supports
+
+        ***********************************************************************/
+
+        final Time accessed ()
+        {
+                return timeStamps.accessed;
+        }
+
+        /***********************************************************************
+
+                Returns the time of file creation. Accurate to
+                whatever the OS supports
+
+        ***********************************************************************/
+
+        final Time created ()
+        {
+                return timeStamps.created;
+        }
+
+        /***********************************************************************
+
+                Create an entire path consisting of this folder along with
+                all parent folders. The path must not contain '.' or '..'
+                segments. Related methods include PathUtil.normalize() and
+                FileSystem.absolutePath()
+
+                Returns: a chaining reference (this)
+
+                Throws: IOException upon systen errors
+
+                Throws: IllegalArgumentException if the path contains invalid
+                        path segment names (such as '.' or '..') or a segment
+                        exists but as a file instead of a folder
+
+        ***********************************************************************/
+
+        final FilePath create ()
+        {
+                if (this.exists)
+                    if (this.isFolder)
+                        return this;
+                    else
+                       badArg ("FilePath.createPath :: file/folder conflict: ");
+
+                auto parent = new FilePath (this.parent);
+                char[] name = parent.name;
+
+                if (name.length is 0                   ||
+                    name == FileConst.CurrentDirString ||
+                    name == FileConst.ParentDirString)
+                    badArg ("FilePath.createPath :: invalid path: ");
+
+                parent.create;
+                return createFolder;
+        }
+
+        /***********************************************************************
+
+                List the set of filenames within this directory. All
+                filenames are null terminated, though the null itself
+                is hidden at the end of each name (not exposed by the
+                length property)
+
+                Each filename optionally includes the parent prefix,
+                dictated by whether argument prefixed is enabled or
+                not; default behaviour is to eschew the prefix
+
+        ***********************************************************************/
+
+        final char[][] toList (bool prefixed = false)
+        {
+                int      i;
+                char[][] list;
+
+                void add (char[] prefix, char[] name, bool dir)
+                {
+                        if (i >= list.length)
+                            list.length = list.length * 2;
+
+                        // duplicate the path, including the null. Note that
+                        // the saved length *excludes* the terminator
+                        list[i++] = prefixed ? (prefix~name) : name.dup;
+                }
+
+                list = new char[][512];
+                toList (&add);
+                return list [0 .. i];
+        }
+
-        /***********************************************************************
-
@@ -488 +651 @@
-                folder_ = 0;
-                name_ = suffix_ = ext_ = -1;
-
+
-                for (int i=end_; --i >= 0;)
-                     switch (fp[i])
@@ -560 +723 @@
-                return len;
-        }
+
+        /***********************************************************************
+
+                Throw an exception using the last known error
+
+        ***********************************************************************/
+
+        private void exception ()
+        {
+                throw new IOException (toUtf8 ~ ": " ~ SysError.lastMsg);
+        }
+
+        /***********************************************************************
+
+                Throw an exception using the last known error
+
+        ***********************************************************************/
+
+        private void badArg (char[] msg)
+        {
+                throw new IllegalArgumentException (msg ~ toUtf8);
+        }
+
+        /***********************************************************************
+
+        ***********************************************************************/
+
+        version (Win32)
+        {
+                /***************************************************************
+
+                        return a wchar[] instance of the path
+
+                ***************************************************************/
+
+                private wchar[] name16 (wchar[] tmp, bool withNull=true)
+                {
+                        int offset = withNull ? 0 : 1;
+                        return Utf.toUtf16 (this.cString[0..$-offset], tmp);
+                }
+
+                /***************************************************************
+
+                        Get info about this path
+
+                ***************************************************************/
+
+                private DWORD getInfo (inout WIN32_FILE_ATTRIBUTE_DATA info)
+                {
+                        version (Win32SansUnicode)
+                                {
+                                if (! GetFileAttributesExA (this.cString.ptr, GetFileInfoLevelStandard, &info))
+                                      exception;
+                                }
+                             else
+                                {
+                                wchar[MAX_PATH] tmp = void;
+                                if (! GetFileAttributesExW (name16(tmp).ptr, GetFileInfoLevelStandard, &info))
+                                      exception;
+                                }
+
+                        return info.dwFileAttributes;
+                }
+
+                /***************************************************************
+
+                        Get flags for this path
+
+                ***************************************************************/
+
+                private DWORD getFlags ()
+                {
+                        WIN32_FILE_ATTRIBUTE_DATA info = void;
+
+                        return getInfo (info);
+                }
+
+                /***************************************************************
+
+                        Return the file length (in bytes)
+
+                ***************************************************************/
+
+                final ulong fileSize ()
+                {
+                        WIN32_FILE_ATTRIBUTE_DATA info = void;
+
+                        getInfo (info);
+                        return (cast(ulong) info.nFileSizeHigh << 32) +
+                                            info.nFileSizeLow;
+                }
+
+                /***************************************************************
+
+                        Is this file writable?
+
+                ***************************************************************/
+
+                final bool isWritable ()
+                {
+                        return (getFlags & FILE_ATTRIBUTE_READONLY) == 0;
+                }
+
+                /***************************************************************
+
+                        Is this file actually a folder/directory?
+
+                ***************************************************************/
+
+                final bool isFolder ()
+                {
+                        return (getFlags & FILE_ATTRIBUTE_DIRECTORY) != 0;
+                }
+
+                /***************************************************************
+
+                        Return timestamp information
+
+                ***************************************************************/
+
+                final Stamps timeStamps ()
+                {
+                        WIN32_FILE_ATTRIBUTE_DATA info = void;
+                        Stamps                    time = void;
+
+                        getInfo (info);
+                        time.modified = Utc.convert (info.ftLastWriteTime);
+                        time.accessed = Utc.convert (info.ftLastAccessTime);
+                        time.created  = Utc.convert (info.ftCreationTime);
+                        return time;
+                }
+
+                /***********************************************************************
+
+                        Transfer the content of another file to this one. Returns a
+                        reference to this class on success, or throws an IOException
+                        upon failure.
+
+                ***********************************************************************/
+
+                final FilePath copy (char[] source)
+                {
+                        auto src = new FilePath (source);
+
+                        version (Win32SansUnicode)
+                                {
+                                if (! CopyFileA (src.cString.ptr, this.cString.ptr, false))
+                                      exception;
+                                }
+                             else
+                                {
+                                wchar[MAX_PATH+1] tmp1 = void;
+                                wchar[MAX_PATH+1] tmp2 = void;
+
+                                if (! CopyFileW (Utf.toUtf16(src.cString, tmp1).ptr, name16(tmp2).ptr, false))
+                                      exception;
+                                }
+
+                        return this;
+                }
+
+                /***************************************************************
+
+                        Remove the file/directory from the file-system
+
+                ***************************************************************/
+
+                final FilePath remove ()
+                {
+                        if (isFolder)
+                           {
+                           version (Win32SansUnicode)
+                                   {
+                                   if (! RemoveDirectoryA (this.cString.ptr))
+                                         exception;
+                                   }
+                                else
+                                   {
+                                   wchar[MAX_PATH] tmp = void;
+                                   if (! RemoveDirectoryW (name16(tmp).ptr))
+                                         exception;
+                                   }
+                           }
+                        else
+                           version (Win32SansUnicode)
+                                   {
+                                   if (! DeleteFileA (this.cString.ptr))
+                                         exception;
+                                   }
+                                else
+                                   {
+                                   wchar[MAX_PATH] tmp = void;
+                                   if (! DeleteFileW (name16(tmp).ptr))
+                                         exception;
+                                   }
+
+                        return this;
+                }
+
+                /***************************************************************
+
+                       change the name or location of a file/directory, and
+                       adopt the provided Path
+
+                ***************************************************************/
+
+                final FilePath rename (FilePath dst)
+                {
+                        const int Typical = MOVEFILE_REPLACE_EXISTING +
+                                            MOVEFILE_COPY_ALLOWED     +
+                                            MOVEFILE_WRITE_THROUGH;
+
+                        int result;
+
+                        version (Win32SansUnicode)
+                                 result = MoveFileExA (this.cString.ptr, dst.cString.ptr, Typical);
+                             else
+                                {
+                                wchar[MAX_PATH] tmp = void;
+                                result = MoveFileExW (name16(tmp).ptr, Utf.toUtf16(dst.cString).ptr, Typical);
+                                }
+
+                        if (! result)
+                              exception;
+
+                        this.set (dst);
+                        return this;
+                }
+
+                /***************************************************************
+
+                        Create a new file
+
+                ***************************************************************/
+
+                final FilePath createFile ()
+                {
+                        HANDLE h;
+
+                        version (Win32SansUnicode)
+                                 h = CreateFileA (this.cString.ptr, GENERIC_WRITE,
+                                                  0, null, CREATE_ALWAYS,
+                                                  FILE_ATTRIBUTE_NORMAL, cast(HANDLE) 0);
+                             else
+                                {
+                                wchar[MAX_PATH] tmp = void;
+                                h = CreateFileW (name16(tmp).ptr, GENERIC_WRITE,
+                                                 0, null, CREATE_ALWAYS,
+                                                 FILE_ATTRIBUTE_NORMAL, cast(HANDLE) 0);
+                                }
+
+                        if (h == INVALID_HANDLE_VALUE)
+                            exception;
+
+                        if (! CloseHandle (h))
+                              exception;
+
+                        return this;
+                }
+
+                /***************************************************************
+
+                        Create a new directory
+
+                ***************************************************************/
+
+                final FilePath createFolder ()
+                {
+                        version (Win32SansUnicode)
+                                {
+                                if (! CreateDirectoryA (this.cString.ptr, null))
+                                      exception;
+                                }
+                             else
+                                {
+                                wchar[MAX_PATH] tmp = void;
+                                if (! CreateDirectoryW (name16(tmp).ptr, null))
+                                      exception;
+                                }
+                        return this;
+                }
+
+                /***************************************************************
+
+                        List the set of filenames within this directory.
+
+                        All filenames are null terminated and are passed
+                        to the provided delegate as such, along with the
+                        path prefix and whether the entry is a directory
+                        or not.
+
+                ***************************************************************/
+
+                final void toList (void delegate (char[], char[], bool) dg)
+                {
+                        HANDLE                  h;
+                        char[]                  prefix;
+                        char[MAX_PATH+1]        tmp = void;
+                        FIND_DATA               fileinfo = void;
+
+                        int next()
+                        {
+                                version (Win32SansUnicode)
+                                         return FindNextFileA (h, &fileinfo);
+                                   else
+                                      return FindNextFileW (h, &fileinfo);
+                        }
+
+                        static T[] padded (T[] s, T[] ext)
+                        {
+                                if (s.length is 0 || s[$-1] != '\\')
+                                    return s ~ "\\" ~ ext;
+                                return s ~ ext;
+                        }
+
+                        version (Win32SansUnicode)
+                                 h = FindFirstFileA (padded(this.toUtf8, "*\0").ptr, &fileinfo);
+                             else
+                                {
+                                wchar[MAX_PATH] host = void;
+                                h = FindFirstFileW (padded(name16(host, false), "*\0").ptr, &fileinfo);
+                                }
+
+                        if (h is INVALID_HANDLE_VALUE)
+                            exception;
+
+                        scope (exit)
+                               FindClose (h);
+
+                        prefix = FilePath.padded (this.toUtf8);
+                        do {
+                           version (Win32SansUnicode)
+                                   {
+                                   // ensure we include the null
+                                   auto len = strlen (fileinfo.cFileName.ptr);
+                                   auto str = fileinfo.cFileName.ptr [0 .. len];
+                                   }
+                                else
+                                   {
+                                   // ensure we include the null
+                                   auto len = wcslen (fileinfo.cFileName.ptr);
+                                   auto str = Utf.toUtf8 (fileinfo.cFileName [0 .. len], tmp);
+                                   }
+
+                           // skip hidden/system files
+                           if ((fileinfo.dwFileAttributes & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN)) is 0)
+                                dg (prefix, str, (fileinfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0);
+
+                           } while (next);
+                }
+        }
+
+
+        /***********************************************************************
+
+        ***********************************************************************/
+
+        version (Posix)
+        {
+                /***************************************************************
+
+                        Get info about this path
+
+                ***************************************************************/
+
+                private uint getInfo (inout stat_t stats)
+                {
+                        if (posix.stat (this.cString.ptr, &stats))
+                            exception;
+
+                        return stats.st_mode;
+                }
+
+                /***************************************************************
+
+                        Return the file length (in bytes)
+
+                ***************************************************************/
+
+                final ulong fileSize ()
+                {
+                        stat_t stats = void;
+
+                        getInfo (stats);
+                        return cast(ulong) stats.st_size;    // 32 bits only
+                }
+
+                /***************************************************************
+
+                        Is this file writable?
+
+                ***************************************************************/
+
+                final bool isWritable ()
+                {
+                        stat_t stats = void;
+
+                        return (getInfo(stats) & O_RDONLY) == 0;
+                }
+
+                /***************************************************************
+
+                        Is this file actually a folder/directory?
+
+                ***************************************************************/
+
+                final bool isFolder ()
+                {
+                        stat_t stats = void;
+
+                        return (getInfo(stats) & S_IFDIR) != 0;
+                }
+
+                /***************************************************************
+
+                        Return timestamp information
+
+                ***************************************************************/
+
+                final Stamps timeStamps ()
+    &nb