* Mono.Posix.dll.sources: Add new file: Mono.Unix/FileAccessPattern.

  * Mono.Unix/FileAccessPattern.cs: Added
  * Mono.Unix/UnixFile.cs, Mono.Unix/UnixStream.cs: Deprecate all the
    Advise* methods (lots!) and replace with 6 methods which take a
    FileAccessPattern enum.

svn path=/trunk/mcs/; revision=52051

diff --git a/mcs/class/Mono.Posix/ChangeLog b/mcs/class/Mono.Posix/ChangeLog
index 16685e488219a0834e01c08cbed2adbd87d20af0..cb377c7c8fe1de945d350305e99d0d1f15fc16a4 100644 (file)
--- a/mcs/class/Mono.Posix/ChangeLog
+++ b/mcs/class/Mono.Posix/ChangeLog
@@ -1,3 +1,7 @@
+2005-10-21  Jonathan Pryor  <jonpryor@vt.edu>
+
+       * Mono.Posix.dll.sources: Add new file: Mono.Unix/FileAccessPattern.cs
+
 2005-10-19  Jonathan Pryor  <jonpryor@vt.edu>
 
        * Mono.Posix.dll.sources: Add new files: Mono.Unix/FileAccessPermissions.cs,

diff --git a/mcs/class/Mono.Posix/Mono.Posix.dll.sources b/mcs/class/Mono.Posix/Mono.Posix.dll.sources
index d0a912addd2dbea29ce8a7a929c33c66c2c9829f..2c06ac415cc62683ef68c8fe785f53ae4cad6c6e 100644 (file)
--- a/mcs/class/Mono.Posix/Mono.Posix.dll.sources
+++ b/mcs/class/Mono.Posix/Mono.Posix.dll.sources
@@ -4,6 +4,7 @@
 ./Mono.Unix/Catalog.cs
 ./Mono.Unix/CdeclFunction.cs
 ./Mono.Unix/FileAccessPermissions.cs
+./Mono.Unix/FileAccessPattern.cs
 ./Mono.Unix/FileSpecialAttributes.cs
 ./Mono.Unix/FileTypes.cs
 ./Mono.Unix/IncludeAttribute.cs

diff --git a/mcs/class/Mono.Posix/Mono.Unix/ChangeLog b/mcs/class/Mono.Posix/Mono.Unix/ChangeLog
index ee01dc7b529ac761dc950d93a6a3dfd06f761756..fde7dd019c7194dd1e2ff8b55ce393551d94445a 100644 (file)
--- a/mcs/class/Mono.Posix/Mono.Unix/ChangeLog
+++ b/mcs/class/Mono.Posix/Mono.Unix/ChangeLog
@@ -1,3 +1,9 @@
+2005-10-21  Jonathan Pryor <jonpryor@vt.edu>
+
+       * FileAccessPattern.cs: Added
+       * UnixFile.cs, UnixStream.cs: Deprecate all the Advise* methods (lots!)
+         and replace with 6 methods which take a FileAccessPattern enum.
+
 2005-10-19  Jonathan Pryor <jonpryor@vt.edu>
 
        * FileAccessPermissions.cs, FileSpecialAttributes.cs, FileTypes.cs: Added.

diff --git a/mcs/class/Mono.Posix/Mono.Unix/FileAccessPattern.cs b/mcs/class/Mono.Posix/Mono.Unix/FileAccessPattern.cs
new file mode 100644 (file)
index 0000000..3288a76
--- /dev/null
+++ b/mcs/class/Mono.Posix/Mono.Unix/FileAccessPattern.cs
@@ -0,0 +1,43 @@
+//
+// Mono.Unix/FileAccessPattern.cs
+//
+// Authors:
+//   Jonathan Pryor (jonpryor@vt.edu)
+//
+// (C) 2005 Jonathan Pryor
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+using Mono.Unix;
+
+namespace Mono.Unix {
+
+       public enum FileAccessPattern {
+               Normal     = Native.PosixFadviseAdvice.POSIX_FADV_NORMAL,
+               Sequential = Native.PosixFadviseAdvice.POSIX_FADV_SEQUENTIAL,
+               Random     = Native.PosixFadviseAdvice.POSIX_FADV_RANDOM,
+               UseOnce    = Native.PosixFadviseAdvice.POSIX_FADV_NOREUSE,
+               UseSoon    = Native.PosixFadviseAdvice.POSIX_FADV_WILLNEED,
+               WillNotUse = Native.PosixFadviseAdvice.POSIX_FADV_DONTNEED,
+       }
+}
+

diff --git a/mcs/class/Mono.Posix/Mono.Unix/UnixFile.cs b/mcs/class/Mono.Posix/Mono.Unix/UnixFile.cs
index 8d7116b2e2c8deae763e05c0381fba7eabd68527..00d03a919124baf1e08b0f425600122094878ad0 100644 (file)
--- a/mcs/class/Mono.Posix/Mono.Unix/UnixFile.cs
+++ b/mcs/class/Mono.Posix/Mono.Unix/UnixFile.cs
@@ -4,7 +4,7 @@
 // Authors:
 //   Jonathan Pryor (jonpryor@vt.edu)
 //
-// (C) 2004 Jonathan Pryor
+// (C) 2004-2005 Jonathan Pryor
 //
 // Permission is hereby granted, free of charge, to any person obtaining
 // a copy of this software and associated documentation files (the
@@ -352,6 +352,43 @@ namespace Mono.Unix {
                        SetLinkOwner (path, uid, gid);
                }
 
+               public static void AdviseFileAccessPattern (int fd, FileAccessPattern pattern, long offset, long len)
+               {
+                       int r = Syscall.posix_fadvise (fd, offset, len,
+                               (PosixFadviseAdvice) pattern);
+                       UnixMarshal.ThrowExceptionForLastErrorIf (r);
+               }
+
+               public static void AdviseFileAccessPattern (int fd, FileAccessPattern pattern)
+               {
+                       AdviseFileAccessPattern (fd, pattern, 0, 0);
+               }
+
+               public static void AdviseFileAccessPattern (FileStream file, FileAccessPattern pattern, long offset, long len)
+               {
+                       int r = Syscall.posix_fadvise (file.Handle.ToInt32(), offset, len,
+                               (PosixFadviseAdvice) pattern);
+                       UnixMarshal.ThrowExceptionForLastErrorIf (r);
+               }
+
+               public static void AdviseFileAccessPattern (FileStream file, FileAccessPattern pattern)
+               {
+                       AdviseFileAccessPattern (file, pattern, 0, 0);
+               }
+
+               public static void AdviseFileAccessPattern (UnixStream stream, FileAccessPattern pattern, long offset, long len)
+               {
+                       int r = Syscall.posix_fadvise (stream.Handle, offset, len,
+                               (PosixFadviseAdvice) pattern);
+                       UnixMarshal.ThrowExceptionForLastErrorIf (r);
+               }
+
+               public static void AdviseFileAccessPattern (UnixStream stream, FileAccessPattern pattern)
+               {
+                       AdviseFileAccessPattern (stream, pattern, 0, 0);
+               }
+
+               [Obsolete ("Use AdviseFileAccessPattern (fd, FileAccessPattern.Normal, offset, len)")]
                public static void AdviseNormalAccess (int fd, long offset, long len)
                {
                        int r = Syscall.posix_fadvise (fd, offset, len,
@@ -359,31 +396,37 @@ namespace Mono.Unix {
                        UnixMarshal.ThrowExceptionForLastErrorIf (r);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (fd, FileAccessPattern.Normal)")]
                public static void AdviseNormalAccess (int fd)
                {
                        AdviseNormalAccess (fd, 0, 0);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (file, FileAccessPattern.Normal, offset, len)")]
                public static void AdviseNormalAccess (FileStream file, long offset, long len)
                {
                        AdviseNormalAccess (file.Handle.ToInt32(), offset, len);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (file, FileAccessPattern.Normal)")]
                public static void AdviseNormalAccess (FileStream file)
                {
                        AdviseNormalAccess (file.Handle.ToInt32());
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (stream, FileAccessPattern.Normal, offset, len)")]
                public static void AdviseNormalAccess (UnixStream stream, long offset, long len)
                {
                        AdviseNormalAccess (stream.Handle, offset, len);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (stream, FileAccessPattern.Normal)")]
                public static void AdviseNormalAccess (UnixStream stream)
                {
                        AdviseNormalAccess (stream.Handle);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (fd, FileAccessPattern.Sequential, offset, len)")]
                public static void AdviseSequentialAccess (int fd, long offset, long len)
                {
                        int r = Syscall.posix_fadvise (fd, offset, len,
@@ -391,31 +434,37 @@ namespace Mono.Unix {
                        UnixMarshal.ThrowExceptionForLastErrorIf (r);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (fd, FileAccessPattern.Sequential)")]
                public static void AdviseSequentialAccess (int fd)
                {
                        AdviseSequentialAccess (fd, 0, 0);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (file, FileAccessPattern.Sequential, offset, len)")]
                public static void AdviseSequentialAccess (FileStream file, long offset, long len)
                {
                        AdviseSequentialAccess (file.Handle.ToInt32(), offset, len);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (file, FileAccessPattern.Sequential)")]
                public static void AdviseSequentialAccess (FileStream file)
                {
                        AdviseSequentialAccess (file.Handle.ToInt32());
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (stream, FileAccessPattern.Sequential, offset, len)")]
                public static void AdviseSequentialAccess (UnixStream stream, long offset, long len)
                {
                        AdviseSequentialAccess (stream.Handle, offset, len);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (stream, FileAccessPattern.Sequential)")]
                public static void AdviseSequentialAccess (UnixStream stream)
                {
                        AdviseSequentialAccess (stream.Handle);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (fd, FileAccessPattern.Random, offset, len)")]
                public static void AdviseRandomAccess (int fd, long offset, long len)
                {
                        int r = Syscall.posix_fadvise (fd, offset, len,
@@ -423,31 +472,37 @@ namespace Mono.Unix {
                        UnixMarshal.ThrowExceptionForLastErrorIf (r);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (fd, FileAccessPattern.Random)")]
                public static void AdviseRandomAccess (int fd)
                {
                        AdviseRandomAccess (fd, 0, 0);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (file, FileAccessPattern.Random, offset, len)")]
                public static void AdviseRandomAccess (FileStream file, long offset, long len)
                {
                        AdviseRandomAccess (file.Handle.ToInt32(), offset, len);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (file, FileAccessPattern.Random)")]
                public static void AdviseRandomAccess (FileStream file)
                {
                        AdviseRandomAccess (file.Handle.ToInt32());
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (stream, FileAccessPattern.Random, offset, len)")]
                public static void AdviseRandomAccess (UnixStream stream, long offset, long len)
                {
                        AdviseRandomAccess (stream.Handle, offset, len);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (stream, FileAccessPattern.Random)")]
                public static void AdviseRandomAccess (UnixStream stream)
                {
                        AdviseRandomAccess (stream.Handle);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (fd, FileAccessPattern.UseSoon, offset, len)")]
                public static void AdviseNeedAccess (int fd, long offset, long len)
                {
                        int r = Syscall.posix_fadvise (fd, offset, len,
@@ -455,31 +510,37 @@ namespace Mono.Unix {
                        UnixMarshal.ThrowExceptionForLastErrorIf (r);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (fd, FileAccessPattern.UseSoon)")]
                public static void AdviseNeedAccess (int fd)
                {
                        AdviseNeedAccess (fd, 0, 0);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (file, FileAccessPattern.UseSoon, offset, len)")]
                public static void AdviseNeedAccess (FileStream file, long offset, long len)
                {
                        AdviseNeedAccess (file.Handle.ToInt32(), offset, len);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (file, FileAccessPattern.UseSoon)")]
                public static void AdviseNeedAccess (FileStream file)
                {
                        AdviseNeedAccess (file.Handle.ToInt32());
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (stream, FileAccessPattern.UseSoon, offset, len)")]
                public static void AdviseNeedAccess (UnixStream stream, long offset, long len)
                {
                        AdviseNeedAccess (stream.Handle, offset, len);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (stream, FileAccessPattern.UseSoon)")]
                public static void AdviseNeedAccess (UnixStream stream)
                {
                        AdviseNeedAccess (stream.Handle);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (fd, FileAccessPattern.WillNotUse, offset, len)")]
                public static void AdviseNoAccess (int fd, long offset, long len)
                {
                        int r = Syscall.posix_fadvise (fd, offset, len,
@@ -487,31 +548,37 @@ namespace Mono.Unix {
                        UnixMarshal.ThrowExceptionForLastErrorIf (r);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (fd, FileAccessPattern.WillNotUse)")]
                public static void AdviseNoAccess (int fd)
                {
                        AdviseNoAccess (fd, 0, 0);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (file, FileAccessPattern.WillNotUse, offset, len)")]
                public static void AdviseNoAccess (FileStream file, long offset, long len)
                {
                        AdviseNoAccess (file.Handle.ToInt32(), offset, len);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (file, FileAccessPattern.WillNotUse)")]
                public static void AdviseNoAccess (FileStream file)
                {
                        AdviseNoAccess (file.Handle.ToInt32());
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (stream, FileAccessPattern.WillNotUse, offset, len)")]
                public static void AdviseNoAccess (UnixStream stream, long offset, long len)
                {
                        AdviseNoAccess (stream.Handle, offset, len);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (stream, FileAccessPattern.WillNotUse)")]
                public static void AdviseNoAccess (UnixStream stream)
                {
                        AdviseNoAccess (stream.Handle);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (fd, FileAccessPattern.UseOnce, offset, len)")]
                public static void AdviseOnceAccess (int fd, long offset, long len)
                {
                        int r = Syscall.posix_fadvise (fd, offset, len,
@@ -519,26 +586,31 @@ namespace Mono.Unix {
                        UnixMarshal.ThrowExceptionForLastErrorIf (r);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (fd, FileAccessPattern.UseOnce)")]
                public static void AdviseOnceAccess (int fd)
                {
                        AdviseOnceAccess (fd, 0, 0);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (file, FileAccessPattern.UseOnce, offset, len)")]
                public static void AdviseOnceAccess (FileStream file, long offset, long len)
                {
                        AdviseOnceAccess (file.Handle.ToInt32(), offset, len);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (file, FileAccessPattern.UseOnce)")]
                public static void AdviseOnceAccess (FileStream file)
                {
                        AdviseOnceAccess (file.Handle.ToInt32());
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (stream, FileAccessPattern.UseOnce, offset, len)")]
                public static void AdviseOnceAccess (UnixStream stream, long offset, long len)
                {
                        AdviseOnceAccess (stream.Handle, offset, len);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (stream, FileAccessPattern.UseOnce)")]
                public static void AdviseOnceAccess (UnixStream stream)
                {
                        AdviseOnceAccess (stream.Handle);

diff --git a/mcs/class/Mono.Posix/Mono.Unix/UnixStream.cs b/mcs/class/Mono.Posix/Mono.Unix/UnixStream.cs
index e7149285aa64fb5e80221c2e225b9aa7cf3f634b..d2d164bd8a6952171b7647d0aa35521dae2b875c 100644 (file)
--- a/mcs/class/Mono.Posix/Mono.Unix/UnixStream.cs
+++ b/mcs/class/Mono.Posix/Mono.Unix/UnixStream.cs
@@ -177,61 +177,83 @@ namespace Mono.Unix {
                        }
                }
 
+               public void AdviseFileAccessPattern (FileAccessPattern pattern, long offset, long len)
+               {
+                       UnixFile.AdviseFileAccessPattern (fileDescriptor, pattern, offset, len);
+               }
+
+               public void AdviseFileAccessPattern (FileAccessPattern pattern)
+               {
+                       AdviseFileAccessPattern (pattern, 0, 0);
+               }
+
+               [Obsolete ("Use AdviseFileAccessPattern (FileAccessPattern.Normal, offset, len)")]
                public void AdviseNormalAccess (long offset, long len)
                {
                        UnixFile.AdviseNormalAccess (fileDescriptor, offset, len);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (FileAccessPattern.Normal)")]
                public void AdviseNormalAccess ()
                {
                        UnixFile.AdviseNormalAccess (fileDescriptor);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (FileAccessPattern.Sequential, offset, len)")]
                public void AdviseSequentialAccess (long offset, long len)
                {
                        UnixFile.AdviseSequentialAccess (fileDescriptor, offset, len);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (FileAccessPattern.Sequential)")]
                public void AdviseSequentialAccess ()
                {
                        UnixFile.AdviseSequentialAccess (fileDescriptor);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (FileAccessPattern.Random, offset, len)")]
                public void AdviseRandomAccess (long offset, long len)
                {
                        UnixFile.AdviseRandomAccess (fileDescriptor, offset, len);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (FileAccessPattern.Random)")]
                public void AdviseRandomAccess ()
                {
                        UnixFile.AdviseRandomAccess (fileDescriptor);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (FileAccessPattern.UseSoon, offset, len)")]
                public void AdviseNeedAccess (long offset, long len)
                {
                        UnixFile.AdviseNeedAccess (fileDescriptor, offset, len);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (FileAccessPattern.UseSoon)")]
                public void AdviseNeedAccess ()
                {
                        UnixFile.AdviseNeedAccess (fileDescriptor);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (FileAccessPattern.WillNotUse, offset, len)")]
                public void AdviseNoAccess (long offset, long len)
                {
                        UnixFile.AdviseNoAccess (fileDescriptor, offset, len);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (FileAccessPattern.WillNotUse)")]
                public void AdviseNoAccess ()
                {
                        UnixFile.AdviseNoAccess (fileDescriptor);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (FileAccessPattern.UseOnce, offset, len)")]
                public void AdviseOnceAccess (long offset, long len)
                {
                        UnixFile.AdviseOnceAccess (fileDescriptor, offset, len);
                }
 
+               [Obsolete ("Use AdviseFileAccessPattern (FileAccessPattern.UseOnce)")]
                public void AdviseOnceAccess ()
                {
                        UnixFile.AdviseOnceAccess (fileDescriptor);