Add Reset() function

Author: rzikm

src/libraries/System.IO.Compression.ZStandard/ref/System.IO.Compression.ZStandard.cs

@@ -13,6 +13,7 @@ public ZstandardCompressionOptions(int quality) { }
         public ZstandardCompressionOptions(System.IO.Compression.CompressionLevel level) { }
         public ZstandardCompressionOptions(System.IO.Compression.ZstandardDictionary dictionary) { }
         public static int DefaultQuality { get { throw null; } }
+        public static int DefaultWindow { get { throw null; } }
         public System.IO.Compression.ZstandardDictionary? Dictionary { get { throw null; } }
         public static int MaxQuality { get { throw null; } }
         public static int MinQuality { get { throw null; } }
@@ -23,9 +24,10 @@ public partial struct ZstandardDecoder : System.IDisposable
         private object _dummy;
         private int _dummyPrimitive;
         public ZstandardDecoder(System.IO.Compression.ZstandardDictionary dictionary) { throw null; }
-        public readonly System.Buffers.OperationStatus Decompress(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesConsumed, out int bytesWritten) { throw null; }
+        public System.Buffers.OperationStatus Decompress(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesConsumed, out int bytesWritten) { throw null; }
         public void Dispose() { }
         public static int GetMaxDecompressedLength(System.ReadOnlySpan<byte> data) { throw null; }
+        public void Reset() { }
         public static bool TryDecompress(System.ReadOnlySpan<byte> source, System.IO.Compression.ZstandardDictionary dictionary, System.Span<byte> destination, out int bytesWritten) { throw null; }
         public static bool TryDecompress(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesWritten) { throw null; }
     }
@@ -42,10 +44,11 @@ public partial struct ZstandardEncoder : System.IDisposable
         private int _dummyPrimitive;
         public ZstandardEncoder(int quality, int window) { throw null; }
         public ZstandardEncoder(System.IO.Compression.ZstandardDictionary dictionary, int window) { throw null; }
-        public readonly System.Buffers.OperationStatus Compress(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesConsumed, out int bytesWritten, bool isFinalBlock) { throw null; }
+        public System.Buffers.OperationStatus Compress(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesConsumed, out int bytesWritten, bool isFinalBlock) { throw null; }
         public void Dispose() { }
-        public readonly System.Buffers.OperationStatus Flush(System.Span<byte> destination, out int bytesWritten) { throw null; }
+        public System.Buffers.OperationStatus Flush(System.Span<byte> destination, out int bytesWritten) { throw null; }
         public static int GetMaxCompressedLength(int inputSize) { throw null; }
+        public void Reset() { }
         public static bool TryCompress(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesWritten) { throw null; }
         public static bool TryCompress(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesWritten, int quality, int window) { throw null; }
         public static bool TryCompress(System.ReadOnlySpan<byte> source, System.Span<byte> destination, out int bytesWritten, System.IO.Compression.ZstandardDictionary dictionary, int window) { throw null; }

src/libraries/System.IO.Compression.ZStandard/src/System/IO/Compression/ZstandardCompressionOptions.cs

@@ -15,6 +15,9 @@ public sealed class ZstandardCompressionOptions
         /// <summary>The maximum compression quality level.</summary>
         public static int MaxQuality => ZstandardUtils.Quality_Max;
 
+        /// <summary>The default window size to use for Zstandard compression.</summary>
+        public static int DefaultWindow => ZstandardUtils.WindowBits_Default;
+
         /// <summary>Initializes a new instance of the <see cref="ZstandardCompressionOptions"/> class.</summary>
         public ZstandardCompressionOptions()
         {

src/libraries/System.IO.Compression.ZStandard/src/System/IO/Compression/ZstandardDecoder.cs

@@ -207,6 +207,25 @@ public static bool TryDecompress(ReadOnlySpan<byte> source, ZstandardDictionary
             }
         }
 
+        /// <summary>Resets the decoder session, allowing reuse for the next decompression operation.</summary>
+        /// <exception cref="ObjectDisposedException">The decoder has been disposed.</exception>
+        /// <exception cref="IOException">Failed to reset the decoder session.</exception>
+        public void Reset()
+        {
+            EnsureNotDisposed();
+
+            if (_context is null)
+                return;
+
+            nuint result = Interop.Zstd.ZSTD_DCtx_reset(_context, Interop.Zstd.ZstdResetDirective.ZSTD_reset_session_only);
+            if (Interop.Zstd.ZSTD_isError(result) != 0)
+            {
+                throw new IOException(string.Format(SR.ZstandardDecoder_DecompressError, ZstandardUtils.GetErrorMessage(result)));
+            }
+
+            _finished = false;
+        }
+
         /// <summary>Releases all resources used by the <see cref="ZstandardDecoder"/>.</summary>
         public void Dispose()
         {

src/libraries/System.IO.Compression.ZStandard/src/System/IO/Compression/ZstandardEncoder.cs

@@ -251,6 +251,23 @@ public static bool TryCompress(ReadOnlySpan<byte> source, Span<byte> destination
             return encoder.Compress(source, destination, out _, out bytesWritten, isFinalBlock: true) == OperationStatus.Done;
         }
 
+        /// <summary>Resets the encoder session, allowing reuse for the next compression operation.</summary>
+        /// <exception cref="ObjectDisposedException">The encoder has been disposed.</exception>
+        /// <exception cref="IOException">Failed to reset the encoder session.</exception>
+        public void Reset()
+        {
+            EnsureNotDisposed();
+
+            if (_context is null)
+                return;
+
+            nuint result = Interop.Zstd.ZSTD_CCtx_reset(_context, Interop.Zstd.ZstdResetDirective.ZSTD_reset_session_only);
+            if (ZstandardUtils.IsError(result))
+            {
+                throw new IOException(string.Format(SR.ZstandardEncoder_CompressError, ZstandardUtils.GetErrorMessage(result)));
+            }
+        }
+
         /// <summary>Releases all resources used by the <see cref="ZstandardEncoder"/>.</summary>
         public void Dispose()
         {

src/libraries/System.IO.Compression.ZStandard/tests/ZStandardDecoderTests.cs

@@ -26,6 +26,56 @@ public void Dispose_CanBeCalledMultipleTimes()
             decoder.Dispose();
         }
 
+        [Fact]
+        public void Reset_AfterDispose_ThrowsObjectDisposedException()
+        {
+            var decoder = new ZstandardDecoder();
+            decoder.Dispose();
+
+            Assert.Throws<ObjectDisposedException>(() => decoder.Reset());
+        }
+
+        [Theory]
+        [InlineData(true)]
+        [InlineData(false)]
+        public void Reset_AllowsReuseForMultipleDecompressions(bool useDictionary)
+        {
+            byte[] dictionaryData = CreateSampleDictionary();
+            using ZstandardDictionary dictionary = ZstandardDictionary.Create(dictionaryData);
+
+            // First compress some data to have something to decompress
+            byte[] input = CreateTestData();
+            byte[] compressed = new byte[ZstandardEncoder.GetMaxCompressedLength(input.Length)];
+            bool compressResult = useDictionary
+                ? ZstandardEncoder.TryCompress(input, compressed, out int compressedLength, dictionary, ZstandardCompressionOptions.DefaultWindow)
+                : ZstandardEncoder.TryCompress(input, compressed, out compressedLength);
+            Assert.True(compressResult);
+
+            // Resize compressed to actual length
+            Array.Resize(ref compressed, compressedLength);
+
+            using var decoder = useDictionary
+                ? new ZstandardDecoder(dictionary)
+                : new ZstandardDecoder();
+            byte[] output1 = new byte[input.Length];
+            byte[] output2 = new byte[input.Length];
+
+            // First decompression
+            OperationStatus result1 = decoder.Decompress(compressed, output1, out int consumed1, out int written1);
+            Assert.Equal(OperationStatus.Done, result1);
+            Assert.Equal(compressed.Length, consumed1);
+            Assert.Equal(input.Length, written1);
+            Assert.Equal(input, output1);
+
+            // Reset and decompress again
+            decoder.Reset();
+            OperationStatus result2 = decoder.Decompress(compressed, output2, out int consumed2, out int written2);
+            Assert.Equal(OperationStatus.Done, result2);
+            Assert.Equal(compressed.Length, consumed2);
+            Assert.Equal(input.Length, written2);
+            Assert.Equal(input, output2);
+        }
+
         [Fact]
         public void GetMaxDecompressedLength_WithEmptyData_ReturnsZero()
         {
@@ -192,5 +242,16 @@ public void RoundTrip_SuccessfullyCompressesAndDecompresses(int quality, bool us
         }
 
         private static byte[] CreateSampleDictionary() => ZstandardTestUtils.CreateSampleDictionary();
+
+        private static byte[] CreateTestData()
+        {
+            // Create some test data that compresses well
+            byte[] data = new byte[1000];
+            for (int i = 0; i < data.Length; i++)
+            {
+                data[i] = (byte)(i % 10); // Repeating pattern
+            }
+            return data;
+        }
     }
 }

src/libraries/System.IO.Compression.ZStandard/tests/ZStandardEncoderTests.cs

@@ -204,6 +204,45 @@ public void Dispose_CanBeCalledMultipleTimes()
             encoder.Dispose();
         }
 
+        [Fact]
+        public void Reset_AfterDispose_ThrowsObjectDisposedException()
+        {
+            var encoder = new ZstandardEncoder(ValidQuality, ValidWindow);
+            encoder.Dispose();
+
+            Assert.Throws<ObjectDisposedException>(() => encoder.Reset());
+        }
+
+        [Theory]
+        [InlineData(true)]
+        [InlineData(false)]
+        public void Reset_AllowsReuseForMultipleCompressions(bool useDictionary)
+        {
+            using ZstandardDictionary dictionary = ZstandardDictionary.Create(ZstandardTestUtils.CreateSampleDictionary(), ValidQuality);
+            using var encoder = useDictionary
+                ? new ZstandardEncoder(dictionary, ValidWindow)
+                : new ZstandardEncoder(ValidQuality, ValidWindow);
+
+            byte[] input = CreateTestData();
+            byte[] output1 = new byte[ZstandardEncoder.GetMaxCompressedLength(input.Length)];
+            byte[] output2 = new byte[ZstandardEncoder.GetMaxCompressedLength(input.Length)];
+
+            // First compression
+            OperationStatus result1 = encoder.Compress(input, output1, out int consumed1, out int written1, isFinalBlock: true);
+            Assert.Equal(OperationStatus.Done, result1);
+            Assert.Equal(input.Length, consumed1);
+            Assert.True(written1 > 0);
+
+            // Reset and compress again
+            encoder.Reset();
+            OperationStatus result2 = encoder.Compress(input, output2, out int consumed2, out int written2, isFinalBlock: true);
+            Assert.Equal(OperationStatus.Done, result2);
+            Assert.Equal(input.Length, consumed2);
+            Assert.True(written2 > 0);
+
+            Assert.Equal(output1, output2);
+        }
+
         private static byte[] CreateTestData()
         {
             // Create some test data that compresses well