From 532cfc5942f2140efee4f642d7cbcd31f31b518c Mon Sep 17 00:00:00 2001 From: Megaflan Date: Sat, 17 Oct 2020 02:28:57 +0200 Subject: [PATCH 1/9] Method design --- src/Yarhl/IO/DataStream.cs | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/src/Yarhl/IO/DataStream.cs b/src/Yarhl/IO/DataStream.cs index 75595366..7302c1cb 100644 --- a/src/Yarhl/IO/DataStream.cs +++ b/src/Yarhl/IO/DataStream.cs @@ -639,6 +639,29 @@ public bool Compare(DataStream otherStream) return result; } + /// + /// Creates a substream starting in a defined position. + /// + /// The substream defined by offset and length parameters. + /// Defined starting position. + public DataStream Slice(long start) + { + // TODO + return ParentDataStream; + } + + /// + /// Creates a substream starting in a defined position and with a defined length. + /// + /// The substream defined by offset and length parameters. + /// Defined starting position. + /// Defined length to be written. + public DataStream Slice(long start, long length) + { + // TODO + return ParentDataStream; + } + /// /// Releases all resource used by the /// object. From d488f9fe32fd81be5d581f4a8ae1087553474009 Mon Sep 17 00:00:00 2001 From: Megaflan Date: Sat, 17 Oct 2020 02:43:02 +0200 Subject: [PATCH 2/9] ArgumentOutOfRange based on Span --- src/Yarhl/IO/DataStream.cs | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/Yarhl/IO/DataStream.cs b/src/Yarhl/IO/DataStream.cs index 7302c1cb..aa4d494a 100644 --- a/src/Yarhl/IO/DataStream.cs +++ b/src/Yarhl/IO/DataStream.cs @@ -646,6 +646,9 @@ public bool Compare(DataStream otherStream) /// Defined starting position. public DataStream Slice(long start) { + if (start < 0 || start > Length) + throw new ArgumentOutOfRangeException(nameof(start)); + // TODO return ParentDataStream; } @@ -658,6 +661,11 @@ public DataStream Slice(long start) /// Defined length to be written. public DataStream Slice(long start, long length) { + if (start < 0 || start > Length) + throw new ArgumentOutOfRangeException(nameof(start)); + if (length < 0 || start + length > Length) + throw new ArgumentOutOfRangeException(nameof(length)); + // TODO return ParentDataStream; } From d8117b984c8ff3834c8219a2e7fb481e0c2da09e Mon Sep 17 00:00:00 2001 From: Megaflan Date: Sat, 17 Oct 2020 02:47:49 +0200 Subject: [PATCH 3/9] Function written based on WriteSegmentTo() --- src/Yarhl/IO/DataStream.cs | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/src/Yarhl/IO/DataStream.cs b/src/Yarhl/IO/DataStream.cs index aa4d494a..ab64b9b7 100644 --- a/src/Yarhl/IO/DataStream.cs +++ b/src/Yarhl/IO/DataStream.cs @@ -649,8 +649,10 @@ public DataStream Slice(long start) if (start < 0 || start > Length) throw new ArgumentOutOfRangeException(nameof(start)); - // TODO - return ParentDataStream; + DataStream slicedStream = new DataStream(); + WriteSegmentTo(start, slicedStream); + + return slicedStream; } /// @@ -666,8 +668,10 @@ public DataStream Slice(long start, long length) if (length < 0 || start + length > Length) throw new ArgumentOutOfRangeException(nameof(length)); - // TODO - return ParentDataStream; + DataStream slicedStream = new DataStream(); + WriteSegmentTo(start, length, slicedStream); + + return slicedStream; } /// From adfe6299ca5af6edff2daf1eff28c107cd59831f Mon Sep 17 00:00:00 2001 From: Megaflan Date: Sat, 17 Oct 2020 03:10:03 +0200 Subject: [PATCH 4/9] Full coverage --- src/Yarhl.UnitTests/IO/DataStreamTests.cs | 28 ++++++++++++++++++++++- 1 file changed, 27 insertions(+), 1 deletion(-) diff --git a/src/Yarhl.UnitTests/IO/DataStreamTests.cs b/src/Yarhl.UnitTests/IO/DataStreamTests.cs index 34862b3d..a2186809 100644 --- a/src/Yarhl.UnitTests/IO/DataStreamTests.cs +++ b/src/Yarhl.UnitTests/IO/DataStreamTests.cs @@ -954,7 +954,7 @@ public void ReadFormat() } [Test] - public void ReadFormAfeterDisposeThrowException() + public void ReadFormAfterDisposeThrowException() { DataStream stream = new DataStream(); stream.WriteByte(0xAF); @@ -965,6 +965,32 @@ public void ReadFormAfeterDisposeThrowException() Assert.Throws(() => stream.ReadFormat()); } + [Test] + public void SliceStream() + { + DataStream stream = new DataStream(); + stream.WriteByte(0xBE); + stream.WriteByte(0xBA); + stream.WriteByte(0xCA); + stream.WriteByte(0xFE); + + Assert.That( + () => stream.Slice(2), + Throws.Nothing); + Assert.That( + () => stream.Slice(2, 2), + Throws.Nothing); + Assert.That( + () => stream.Slice(10), + Throws.Exception); + Assert.That( + () => stream.Slice(10, 10), + Throws.Exception); + Assert.That( + () => stream.Slice(2, 10), + Throws.Exception); + } + [Test] public void WritesAByteAndIncreasePosition() { From 14be673418fedcc73808c4bead24bc5a5d24cca9 Mon Sep 17 00:00:00 2001 From: Megaflan Date: Sun, 18 Oct 2020 16:15:31 +0200 Subject: [PATCH 5/9] new DataStream instead of WriteSegmentTo to avoid a copy --- src/Yarhl/IO/DataStream.cs | 10 ++-------- 1 file changed, 2 insertions(+), 8 deletions(-) diff --git a/src/Yarhl/IO/DataStream.cs b/src/Yarhl/IO/DataStream.cs index ab64b9b7..dfa65e3b 100644 --- a/src/Yarhl/IO/DataStream.cs +++ b/src/Yarhl/IO/DataStream.cs @@ -649,10 +649,7 @@ public DataStream Slice(long start) if (start < 0 || start > Length) throw new ArgumentOutOfRangeException(nameof(start)); - DataStream slicedStream = new DataStream(); - WriteSegmentTo(start, slicedStream); - - return slicedStream; + return new DataStream(this, start, Length - start); } /// @@ -668,10 +665,7 @@ public DataStream Slice(long start, long length) if (length < 0 || start + length > Length) throw new ArgumentOutOfRangeException(nameof(length)); - DataStream slicedStream = new DataStream(); - WriteSegmentTo(start, length, slicedStream); - - return slicedStream; + return new DataStream(this, start, length); } /// From 4a7eebd247b7d2a553ddfe3374b0c459011d590c Mon Sep 17 00:00:00 2001 From: Megaflan Date: Sun, 18 Oct 2020 17:19:20 +0200 Subject: [PATCH 6/9] New tests regarding offset, position and length --- src/Yarhl.UnitTests/IO/DataStreamTests.cs | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/src/Yarhl.UnitTests/IO/DataStreamTests.cs b/src/Yarhl.UnitTests/IO/DataStreamTests.cs index a2186809..63e64ac7 100644 --- a/src/Yarhl.UnitTests/IO/DataStreamTests.cs +++ b/src/Yarhl.UnitTests/IO/DataStreamTests.cs @@ -974,12 +974,21 @@ public void SliceStream() stream.WriteByte(0xCA); stream.WriteByte(0xFE); + DataStream testSlice = stream.Slice(2); Assert.That( - () => stream.Slice(2), + () => testSlice, Throws.Nothing); + Assert.AreEqual(0, testSlice.Position); + Assert.AreEqual(2, testSlice.Offset); + Assert.AreEqual(stream.Length - testSlice.Offset, testSlice.Length); + + testSlice = stream.Slice(2, 2); Assert.That( - () => stream.Slice(2, 2), + () => testSlice, Throws.Nothing); + Assert.AreEqual(0, testSlice.Position); + Assert.AreEqual(2, testSlice.Offset); + Assert.AreEqual(2, testSlice.Length); Assert.That( () => stream.Slice(10), Throws.Exception); From cbd28ab6fc7122b6670885e8bcae592feeea5b94 Mon Sep 17 00:00:00 2001 From: Megaflan Date: Sun, 18 Oct 2020 17:24:56 +0200 Subject: [PATCH 7/9] Length 2 to 1, to ease the length checking --- src/Yarhl.UnitTests/IO/DataStreamTests.cs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Yarhl.UnitTests/IO/DataStreamTests.cs b/src/Yarhl.UnitTests/IO/DataStreamTests.cs index 63e64ac7..1e0d3e79 100644 --- a/src/Yarhl.UnitTests/IO/DataStreamTests.cs +++ b/src/Yarhl.UnitTests/IO/DataStreamTests.cs @@ -982,13 +982,13 @@ public void SliceStream() Assert.AreEqual(2, testSlice.Offset); Assert.AreEqual(stream.Length - testSlice.Offset, testSlice.Length); - testSlice = stream.Slice(2, 2); + testSlice = stream.Slice(2, 1); Assert.That( () => testSlice, Throws.Nothing); Assert.AreEqual(0, testSlice.Position); Assert.AreEqual(2, testSlice.Offset); - Assert.AreEqual(2, testSlice.Length); + Assert.AreEqual(1, testSlice.Length); Assert.That( () => stream.Slice(10), Throws.Exception); From 203f43045501f238f01a28779a6612e0480c14b9 Mon Sep 17 00:00:00 2001 From: Benito Palacios Sanchez Date: Tue, 28 Nov 2023 10:30:23 +0100 Subject: [PATCH 8/9] :umbrella: Implement more tests cases for slice --- src/Yarhl.UnitTests/IO/DataStreamTests.cs | 116 +++++++++++++++++----- src/Yarhl/IO/DataStream.cs | 10 +- 2 files changed, 99 insertions(+), 27 deletions(-) diff --git a/src/Yarhl.UnitTests/IO/DataStreamTests.cs b/src/Yarhl.UnitTests/IO/DataStreamTests.cs index 5b916249..651671c6 100644 --- a/src/Yarhl.UnitTests/IO/DataStreamTests.cs +++ b/src/Yarhl.UnitTests/IO/DataStreamTests.cs @@ -23,8 +23,10 @@ namespace Yarhl.UnitTests.IO using System.Diagnostics.CodeAnalysis; using System.IO; using System.Threading.Tasks; + using Microsoft.VisualStudio.TestPlatform.PlatformAbstractions.Interfaces; using Moq; using NUnit.Framework; + using NUnit.Framework.Internal; using Yarhl.FileFormat; using Yarhl.IO; using Yarhl.IO.StreamFormat; @@ -979,39 +981,105 @@ public void ReadBufferOutOfRange() stream.Dispose(); } + [Test] + public void SliceUsesSameBaseStream() + { + baseStream.Write(new byte[] { 0xCA, 0xFE }); + using var parent = new DataStream(baseStream); + + using DataStream slice = parent.Slice(1); + + Assert.That(parent.BaseStream, Is.SameAs(baseStream)); + Assert.That(slice.BaseStream, Is.SameAs(baseStream)); + } + [Test] public void SliceStream() { - DataStream stream = new DataStream(); + using var stream = new DataStream(); stream.WriteByte(0xBE); stream.WriteByte(0xBA); stream.WriteByte(0xCA); stream.WriteByte(0xFE); - DataStream testSlice = stream.Slice(2); - Assert.That( - () => testSlice, - Throws.Nothing); - Assert.AreEqual(0, testSlice.Position); - Assert.AreEqual(2, testSlice.Offset); - Assert.AreEqual(stream.Length - testSlice.Offset, testSlice.Length); + using DataStream testSlice = stream.Slice(2); + Assert.That(testSlice, Is.Not.Null); - testSlice = stream.Slice(2, 1); - Assert.That( - () => testSlice, - Throws.Nothing); - Assert.AreEqual(0, testSlice.Position); - Assert.AreEqual(2, testSlice.Offset); - Assert.AreEqual(1, testSlice.Length); - Assert.That( - () => stream.Slice(10), - Throws.Exception); - Assert.That( - () => stream.Slice(10, 10), - Throws.Exception); - Assert.That( - () => stream.Slice(2, 10), - Throws.Exception); + Assert.Multiple(() => { + Assert.That(testSlice.Position, Is.EqualTo(0)); + Assert.That(testSlice.Offset, Is.EqualTo(2)); + Assert.That(testSlice.Length, Is.EqualTo(2)); + Assert.That(testSlice.ReadByte(), Is.EqualTo(0xCA)); + }); + } + + [Test] + public void SliceWithLength() + { + baseStream.Write(new byte[] { 0xBE, 0xBA, 0xCA, 0xFE }); + using var stream = new DataStream(baseStream); + + using DataStream testSlice = stream.Slice(2, 1); + + Assert.That(testSlice, Is.Not.Null); + Assert.Multiple(() => { + Assert.That(testSlice.Position, Is.EqualTo(0)); + Assert.That(testSlice.Offset, Is.EqualTo(2)); + Assert.That(testSlice.Length, Is.EqualTo(1)); + Assert.That(testSlice.ReadByte(), Is.EqualTo(0xCA)); + }); + } + + [Test] + public void SliceZeroLengthSucceeds() + { + baseStream.Write(new byte[] { 0xBE, 0xBA, 0xCA, 0xFE }); + using var stream = new DataStream(baseStream); + + using DataStream testSlice = stream.Slice(2, 0); + + Assert.That(testSlice, Is.Not.Null); + Assert.Multiple(() => { + Assert.That(testSlice.Offset, Is.EqualTo(2)); + Assert.That(testSlice.Length, Is.EqualTo(0)); + }); + + using DataStream endSlice = stream.Slice(4); + Assert.That(endSlice, Is.Not.Null); + Assert.Multiple(() => { + Assert.That(endSlice.Offset, Is.EqualTo(4)); + Assert.That(endSlice.Length, Is.EqualTo(0)); + }); + } + + [Test] + public void SliceCannotExpand() + { + baseStream.Write(new byte[] { 0xBE, 0xBA, 0xCA, 0xFE }); + using var stream = new DataStream(baseStream); + + using DataStream testSlice = stream.Slice(2, 1); + + testSlice.Position = 1; + Assert.That(() => testSlice.WriteByte(0xC0), Throws.InstanceOf()); + + using DataStream endSlice = stream.Slice(4, 0); + Assert.That(() => endSlice.WriteByte(0xC0), Throws.InstanceOf()); + } + + [Test] + public void SliceThrowsWithInvalidArgs() + { + baseStream.Write(new byte[] { 0xBE, 0xBA, 0xCA, 0xFE }); + using var stream = new DataStream(baseStream); + + Assert.Multiple(() => { + Assert.That(() => stream.Slice(-1), Throws.InstanceOf()); + Assert.That(() => stream.Slice(5), Throws.InstanceOf()); + Assert.That(() => stream.Slice(-1, 1), Throws.InstanceOf()); + Assert.That(() => stream.Slice(5, 1), Throws.InstanceOf()); + Assert.That(() => stream.Slice(0, 5), Throws.InstanceOf()); + }); } [Test] diff --git a/src/Yarhl/IO/DataStream.cs b/src/Yarhl/IO/DataStream.cs index 04eadfba..18bf9331 100644 --- a/src/Yarhl/IO/DataStream.cs +++ b/src/Yarhl/IO/DataStream.cs @@ -727,8 +727,9 @@ public bool Compare(Stream otherStream) /// Defined starting position. public DataStream Slice(long start) { - if (start < 0 || start > Length) + if (start < 0 || start > Length) { throw new ArgumentOutOfRangeException(nameof(start)); + } return new DataStream(this, start, Length - start); } @@ -741,10 +742,13 @@ public DataStream Slice(long start) /// Defined length to be written. public DataStream Slice(long start, long length) { - if (start < 0 || start > Length) + if (start < 0 || start > Length) { throw new ArgumentOutOfRangeException(nameof(start)); - if (length < 0 || start + length > Length) + } + + if (length < 0 || start + length > Length) { throw new ArgumentOutOfRangeException(nameof(length)); + } return new DataStream(this, start, length); } From 74711de2900e18d4aaa6643fdca422f10c6fe0a3 Mon Sep 17 00:00:00 2001 From: Benito Palacios Sanchez Date: Tue, 28 Nov 2023 10:44:16 +0100 Subject: [PATCH 9/9] =?UTF-8?q?=F0=9F=93=96=20Document=20Slice=20API?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/articles/core/binary/datastream.md | 8 ++++ src/Yarhl.Examples/IO/DataStreamExamples.cs | 44 +++++++++++++++++++++ src/Yarhl.UnitTests/IO/DataStreamTests.cs | 2 - 3 files changed, 52 insertions(+), 2 deletions(-) create mode 100644 src/Yarhl.Examples/IO/DataStreamExamples.cs diff --git a/docs/articles/core/binary/datastream.md b/docs/articles/core/binary/datastream.md index a55ac1db..85ee7565 100644 --- a/docs/articles/core/binary/datastream.md +++ b/docs/articles/core/binary/datastream.md @@ -38,6 +38,14 @@ Another use case is reading a binary format with sections. By creating a modular and safe. It would prevent reading data outside the range of the section. +We can create a _sub-stream_ from the `DataStream` constructor: + +[!code-csharp[SubStreamConstructor](./../../../../src/Yarhl.Examples/IO/DataStreamExamples.cs?name=SubStreamConstructor)] + +or from the `Slice` API: + +[!code-csharp[SubStreamConstructor](./../../../../src/Yarhl.Examples/IO/DataStreamExamples.cs?name=SubStreamSlice)] + ## Factory The constructors of `DataStream` takes a `Stream` with optional offset and diff --git a/src/Yarhl.Examples/IO/DataStreamExamples.cs b/src/Yarhl.Examples/IO/DataStreamExamples.cs new file mode 100644 index 00000000..32a684e0 --- /dev/null +++ b/src/Yarhl.Examples/IO/DataStreamExamples.cs @@ -0,0 +1,44 @@ +// Copyright (c) 2023 SceneGate + +// 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. +namespace Yarhl.Examples.IO; + +using Yarhl.IO; + +public static class DataStreamExamples +{ + public static void CreateSubStreamConstructor() + { + #region SubStreamConstructor + var baseStream = new FileStream("container.bin", FileMode.Open); + using var file1Stream = new DataStream(baseStream, 0x100, 0x2C0); + using var file2Stream = new DataStream(baseStream, 0x3C0, 0x80); + #endregion + } + + public static void CreateSubStreamSlice() + { + #region SubStreamSlice + DataStream containerStream = DataStreamFactory.FromFile("container.bin", FileOpenMode.Read); + using DataStream file1Stream = containerStream.Slice(0x100, 0x2C0); + using DataStream file2Stream = containerStream.Slice(0x3C0, 0x80); + using DataStream lastFileStream = containerStream.Slice(0x8400); + #endregion + } +} diff --git a/src/Yarhl.UnitTests/IO/DataStreamTests.cs b/src/Yarhl.UnitTests/IO/DataStreamTests.cs index 651671c6..b77b3bae 100644 --- a/src/Yarhl.UnitTests/IO/DataStreamTests.cs +++ b/src/Yarhl.UnitTests/IO/DataStreamTests.cs @@ -23,10 +23,8 @@ namespace Yarhl.UnitTests.IO using System.Diagnostics.CodeAnalysis; using System.IO; using System.Threading.Tasks; - using Microsoft.VisualStudio.TestPlatform.PlatformAbstractions.Interfaces; using Moq; using NUnit.Framework; - using NUnit.Framework.Internal; using Yarhl.FileFormat; using Yarhl.IO; using Yarhl.IO.StreamFormat;