Bump corefx

[mono.git] / mcs / class / System / System.IO.Compression / DeflateStream.cs

diff --git a/mcs/class/System/System.IO.Compression/DeflateStream.cs b/mcs/class/System/System.IO.Compression/DeflateStream.cs
index a79f8826a9b324e615078aa3d10958c16d3ec965..354a16e39e39ce67361fbd28fbd1e0701cb88e0a 100644 (file)
--- a/mcs/class/System/System.IO.Compression/DeflateStream.cs
+++ b/mcs/class/System/System.IO.Compression/DeflateStream.cs
@@ -58,6 +58,11 @@ namespace System.IO.Compression
                {
                }
 
+               internal DeflateStream (Stream stream, CompressionMode mode, bool leaveOpen, int windowsBits) :
+                       this (stream, mode, leaveOpen, true)
+               {
+               }
+
                internal DeflateStream (Stream compressedStream, CompressionMode mode, bool leaveOpen, bool gzip)
                {
                        if (compressedStream == null)
@@ -86,6 +91,11 @@ namespace System.IO.Compression
                {
                }
 
+               internal DeflateStream (Stream stream, CompressionLevel compressionLevel, bool leaveOpen, int windowsBits)
+                       : this (stream, compressionLevel, leaveOpen, true)
+               {
+               }
+
                internal DeflateStream (Stream stream, CompressionLevel compressionLevel, bool leaveOpen, bool gzip)
                        : this (stream, CompressionMode.Compress, leaveOpen, gzip)
                {
@@ -120,6 +130,11 @@ namespace System.IO.Compression
                        }
                }
 
+               internal int ReadCore (Span<byte> destination)
+               {
+                       throw new NotImplementedException ();
+               }
+
                public override int Read (byte[] array, int offset, int count)
                {
                        if (disposed)
@@ -150,6 +165,11 @@ namespace System.IO.Compression
                        }
                }
 
+               internal void WriteCore (ReadOnlySpan<byte> source)
+               {
+                       throw new NotImplementedException ();
+               }
+
                public override void Write (byte[] array, int offset, int count)
                {
                        if (disposed)
@@ -183,8 +203,8 @@ namespace System.IO.Compression
                        }
                }
 
-               public override IAsyncResult BeginRead (byte [] buffer, int offset, int count,
-                                                       AsyncCallback cback, object state)
+               public override IAsyncResult BeginRead (byte [] array, int offset, int count,
+                                                       AsyncCallback asyncCallback, object asyncState)
                {
                        if (disposed)
                                throw new ObjectDisposedException (GetType ().FullName);
@@ -192,8 +212,8 @@ namespace System.IO.Compression
                        if (!CanRead)
                                throw new NotSupportedException ("This stream does not support reading");
 
-                       if (buffer == null)
-                               throw new ArgumentNullException ("buffer");
+                       if (array == null)
+                               throw new ArgumentNullException ("array");
 
                        if (count < 0)
                                throw new ArgumentOutOfRangeException ("count", "Must be >= 0");
@@ -201,15 +221,15 @@ namespace System.IO.Compression
                        if (offset < 0)
                                throw new ArgumentOutOfRangeException ("offset", "Must be >= 0");
 
-                       if (count + offset > buffer.Length)
+                       if (count + offset > array.Length)
                                throw new ArgumentException ("Buffer too small. count/offset wrong.");
 
                        ReadMethod r = new ReadMethod (ReadInternal);
-                       return r.BeginInvoke (buffer, offset, count, cback, state);
+                       return r.BeginInvoke (array, offset, count, asyncCallback, asyncState);
                }
 
-               public override IAsyncResult BeginWrite (byte [] buffer, int offset, int count,
-                                                       AsyncCallback cback, object state)
+               public override IAsyncResult BeginWrite (byte [] array, int offset, int count,
+                                                       AsyncCallback asyncCallback, object asyncState)
                {
                        if (disposed)
                                throw new ObjectDisposedException (GetType ().FullName);
@@ -217,8 +237,8 @@ namespace System.IO.Compression
                        if (!CanWrite)
                                throw new InvalidOperationException ("This stream does not support writing");
 
-                       if (buffer == null)
-                               throw new ArgumentNullException ("buffer");
+                       if (array == null)
+                               throw new ArgumentNullException ("array");
 
                        if (count < 0)
                                throw new ArgumentOutOfRangeException ("count", "Must be >= 0");
@@ -226,43 +246,43 @@ namespace System.IO.Compression
                        if (offset < 0)
                                throw new ArgumentOutOfRangeException ("offset", "Must be >= 0");
 
-                       if (count + offset > buffer.Length)
+                       if (count + offset > array.Length)
                                throw new ArgumentException ("Buffer too small. count/offset wrong.");
 
                        WriteMethod w = new WriteMethod (WriteInternal);
-                       return w.BeginInvoke (buffer, offset, count, cback, state);                     
+                       return w.BeginInvoke (array, offset, count, asyncCallback, asyncState);                 
                }
 
-               public override int EndRead(IAsyncResult async_result)
+               public override int EndRead(IAsyncResult asyncResult)
                {
-                       if (async_result == null)
-                               throw new ArgumentNullException ("async_result");
+                       if (asyncResult == null)
+                               throw new ArgumentNullException ("asyncResult");
 
-                       AsyncResult ares = async_result as AsyncResult;
+                       AsyncResult ares = asyncResult as AsyncResult;
                        if (ares == null)
-                               throw new ArgumentException ("Invalid IAsyncResult", "async_result");
+                               throw new ArgumentException ("Invalid IAsyncResult", "asyncResult");
 
                        ReadMethod r = ares.AsyncDelegate as ReadMethod;
                        if (r == null)
-                               throw new ArgumentException ("Invalid IAsyncResult", "async_result");
+                               throw new ArgumentException ("Invalid IAsyncResult", "asyncResult");
 
-                       return r.EndInvoke (async_result);
+                       return r.EndInvoke (asyncResult);
                }
 
-               public override void EndWrite (IAsyncResult async_result)
+               public override void EndWrite (IAsyncResult asyncResult)
                {
-                       if (async_result == null)
-                               throw new ArgumentNullException ("async_result");
+                       if (asyncResult == null)
+                               throw new ArgumentNullException ("asyncResult");
 
-                       AsyncResult ares = async_result as AsyncResult;
+                       AsyncResult ares = asyncResult as AsyncResult;
                        if (ares == null)
-                               throw new ArgumentException ("Invalid IAsyncResult", "async_result");
+                               throw new ArgumentException ("Invalid IAsyncResult", "asyncResult");
 
                        WriteMethod w = ares.AsyncDelegate as WriteMethod;
                        if (w == null)
-                               throw new ArgumentException ("Invalid IAsyncResult", "async_result");
+                               throw new ArgumentException ("Invalid IAsyncResult", "asyncResult");
 
-                       w.EndInvoke (async_result);
+                       w.EndInvoke (asyncResult);
                        return;
                }
 
@@ -379,9 +399,7 @@ namespace System.IO.Compression
                        CheckResult (res, "WriteInternal");
                }
 
-#if MONOTOUCH || FULL_AOT_RUNTIME
                [Mono.Util.MonoPInvokeCallback (typeof (UnmanagedReadOrWrite))]
-#endif
                static int UnmanagedRead (IntPtr buffer, int length, IntPtr data)
                {
                        GCHandle s = GCHandle.FromIntPtr (data);
@@ -404,9 +422,7 @@ namespace System.IO.Compression
                        return n;
                }
 
-#if MONOTOUCH || FULL_AOT_RUNTIME
                [Mono.Util.MonoPInvokeCallback (typeof (UnmanagedReadOrWrite))]
-#endif
                static int UnmanagedWrite (IntPtr buffer, int length, IntPtr data)
                {
                        GCHandle s = GCHandle.FromIntPtr (data);
@@ -480,6 +496,7 @@ namespace System.IO.Compression
                const string LIBNAME = "MonoPosixHelper";
 #endif
 
+#if !ORBIS
                [DllImport (LIBNAME, CallingConvention=CallingConvention.Cdecl)]
                static extern IntPtr CreateZStream (CompressionMode compress, bool gzip, UnmanagedReadOrWrite feeder, IntPtr data);
 
@@ -494,6 +511,33 @@ namespace System.IO.Compression
 
                [DllImport (LIBNAME, CallingConvention=CallingConvention.Cdecl)]
                static extern int WriteZStream (IntPtr stream, IntPtr buffer, int length);
+#else
+               static IntPtr CreateZStream (CompressionMode compress, bool gzip, UnmanagedReadOrWrite feeder, IntPtr data)
+               {
+                       throw new PlatformNotSupportedException ();
+               }
+
+               static int CloseZStream (IntPtr stream)
+               {
+                       throw new PlatformNotSupportedException ();
+               }
+
+               static int Flush (IntPtr stream)
+               {
+                       throw new PlatformNotSupportedException ();
+               }
+
+               static int ReadZStream (IntPtr stream, IntPtr buffer, int length)
+               {
+                       throw new PlatformNotSupportedException ();
+               }
+
+               static int WriteZStream (IntPtr stream, IntPtr buffer, int length)
+               {
+                       throw new PlatformNotSupportedException ();
+               }
+#endif
+
        }
 }