Set up new methods for reading strings with a specific encoding and r…

…eading schema objects into a span.
MeltyPlayer · Nov 3, 2023 · 84dfeee · 84dfeee
1 parent 2cbae29
commit 84dfeee
Show file tree

Hide file tree

Showing 7 changed files with 123 additions and 46 deletions.
diff --git a/Schema Build Tests/attributes/sequence/ClassSequenceTests.cs b/Schema Build Tests/attributes/sequence/ClassSequenceTests.cs
@@ -83,7 +83,7 @@ public void TestWriteAndReadArrayValues() {
 
       var er = new SchemaBinaryReader(ms, endianness);
       er.Position = 1;
-      var actualSws = er.ReadNewArray<SchemaClass>(expectedSw.Values.Length);
+      var actualSws = er.ReadNews<SchemaClass>(expectedSw.Values.Length);
       Assert.True(expectedSw.Values.SequenceEqual(actualSws));
     }
 

diff --git a/Schema Build Tests/attributes/sequence/StructSequenceTests.cs b/Schema Build Tests/attributes/sequence/StructSequenceTests.cs
@@ -81,7 +81,7 @@ public void TestWriteAndReadArrayValues() {
 
       var er = new SchemaBinaryReader(ms, endianness);
       er.Position = 1;
-      var actualSws = er.ReadNewArray<SchemaStruct>(expectedSw.Values.Length);
+      var actualSws = er.ReadNews<SchemaStruct>(expectedSw.Values.Length);
       Assert.True(expectedSw.Values.SequenceEqual(actualSws));
     }
 

diff --git a/Schema/src/binary/reader/IBinaryReader.cs b/Schema/src/binary/reader/IBinaryReader.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Text;
 
 using schema.binary.attributes;
 
@@ -122,31 +123,50 @@ void ReadChars(StringEncodingType encodingType,
 
     void ReadChars(StringEncodingType encodingType, Span<char> dst);
 
+    void AssertChar(Encoding encoding, char expectedValue);
+    char ReadChar(Encoding encoding);
+    char[] ReadChars(Encoding encoding, long count);
+
+    void ReadChars(Encoding encoding,
+                   char[] dst,
+                   int start,
+                   int length);
+
+    void ReadChars(Encoding encoding, Span<char> dst);
+
     string ReadUpTo(char endToken);
     string ReadUpTo(StringEncodingType encodingType, char endToken);
+    string ReadUpTo(Encoding encoding, char endToken);
 
     string ReadUpTo(ReadOnlySpan<string> endTokens);
-    string ReadUpTo(StringEncodingType encodingType, ReadOnlySpan<string> endTokens);
+
+    string ReadUpTo(StringEncodingType encodingType,
+                    ReadOnlySpan<string> endTokens);
+
+    string ReadUpTo(Encoding encoding, ReadOnlySpan<string> endTokens);
 
     string ReadLine();
     string ReadLine(StringEncodingType encodingType);
+    string ReadLine(Encoding encoding);
 
     void AssertString(StringEncodingType encodingType, string expectedValue);
     string ReadString(StringEncodingType encodingType, long count);
 
+    void AssertString(Encoding encoding, string expectedValue);
+    string ReadString(Encoding encoding, long count);
+
     void AssertStringNT(string expectedValue);
     string ReadStringNT();
 
     void AssertStringNT(StringEncodingType encodingType, string expectedValue);
     string ReadStringNT(StringEncodingType encodingType);
 
-    T ReadNew<T>() where T : IBinaryDeserializable, new();
+    void AssertStringNT(Encoding encoding, string expectedValue);
+    string ReadStringNT(Encoding encoding);
 
+    T ReadNew<T>() where T : IBinaryDeserializable, new();
     bool TryReadNew<T>(out T? value) where T : IBinaryDeserializable, new();
-
-    void ReadNewArray<T>(out T[] array, int length)
-        where T : IBinaryDeserializable, new();
-
-    T[] ReadNewArray<T>(int length) where T : IBinaryDeserializable, new();
+    T[] ReadNews<T>(int length) where T : IBinaryDeserializable, new();
+    void ReadNews<T>(Span<T> dst) where T : IBinaryDeserializable, new();
   }
 }
diff --git a/Schema/src/binary/reader/SchemaBinaryReader_New.cs b/Schema/src/binary/reader/SchemaBinaryReader_New.cs
@@ -1,4 +1,5 @@
-using System.Runtime.CompilerServices;
+using System;
+using System.Runtime.CompilerServices;
 
 
 namespace schema.binary {
@@ -25,19 +26,20 @@ public bool TryReadNew<T>(out T? value)
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void ReadNewArray<T>(out T[] array, int length)
+    public T[] ReadNews<T>(int length)
         where T : IBinaryDeserializable, new() {
-      array = ReadNewArray<T>(length);
+      var array = new T[length];
+      this.ReadNews<T>(array);
+      return array;
     }
 
-    public T[] ReadNewArray<T>(int length)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void ReadNews<T>(Span<T> dst)
         where T : IBinaryDeserializable, new() {
-      var array = new T[length];
-      for (var i = 0; i < length; ++i) {
+      for (var i = 0; i < dst.Length; ++i) {
         this.AssertNotEof();
-        array[i] = this.ReadNew<T>();
+        dst[i] = this.ReadNew<T>();
       }
-      return array;
     }
   }
 }
diff --git a/Schema/src/binary/reader/SchemaBinaryReader_Strings.cs b/Schema/src/binary/reader/SchemaBinaryReader_Strings.cs
@@ -38,42 +38,67 @@ public void ReadChars(Span<char> dst) {
     }
 
 
-    // Encoded Chars
+    // Enum encoded Chars
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void AssertChar(StringEncodingType encodingType, char expectedValue)
       => SchemaBinaryReader.Assert_(expectedValue, this.ReadChar(encodingType));
 
-    public unsafe char ReadChar(StringEncodingType encodingType) {
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public char ReadChar(StringEncodingType encodingType)
+      => this.ReadChar(encodingType.GetEncoding(this.Endianness));
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public char[] ReadChars(StringEncodingType encodingType, long count)
+      => this.ReadChars(encodingType.GetEncoding(this.Endianness), count);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void ReadChars(StringEncodingType encodingType,
+                          char[] dst,
+                          int start,
+                          int length)
+      => this.ReadChars(encodingType.GetEncoding(this.Endianness),
+                        dst,
+                        start,
+                        length);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void ReadChars(StringEncodingType encodingType, Span<char> dst)
+      => this.ReadChars(encodingType.GetEncoding(this.Endianness), dst);
+
+
+    // Encoded Chars
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void AssertChar(Encoding encoding, char expectedValue)
+      => SchemaBinaryReader.Assert_(expectedValue, this.ReadChar(encoding));
+
+    public unsafe char ReadChar(Encoding encoding) {
       char c;
       var ptr = &c;
-      this.ReadChars(encodingType, new Span<char>(ptr, 1));
+      this.ReadChars(encoding, new Span<char>(ptr, 1));
       return c;
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public char[] ReadChars(StringEncodingType encodingType, long count) {
+    public char[] ReadChars(Encoding encoding, long count) {
       var newArray = new char[count];
-      this.ReadChars(encodingType, newArray);
+      this.ReadChars(encoding, newArray);
       return newArray;
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void ReadChars(StringEncodingType encodingType,
+    public void ReadChars(Encoding encoding,
                           char[] dst,
                           int start,
                           int length)
-      => this.ReadChars(encodingType, dst.AsSpan(start, length));
+      => this.ReadChars(encoding, dst.AsSpan(start, length));
 
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public unsafe void ReadChars(StringEncodingType encodingType,
-                                 Span<char> dst) {
+    public unsafe void ReadChars(Encoding encoding, Span<char> dst) {
       if (dst.Length == 0) {
         return;
       }
 
       var basePosition = this.Position;
 
-      var encoding = encodingType.GetEncoding(this.Endianness);
       var maxByteCount = encoding.GetMaxByteCount(dst.Length);
 
       Span<byte> buffer = stackalloc byte[maxByteCount];
@@ -121,10 +146,14 @@ public string ReadUpTo(char endToken) {
       return strBuilder.ToString();
     }
 
-    public string ReadUpTo(StringEncodingType encodingType, char endToken) {
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public string ReadUpTo(StringEncodingType encodingType, char endToken)
+      => this.ReadUpTo(encodingType.GetEncoding(this.Endianness), endToken);
+
+    public string ReadUpTo(Encoding encoding, char endToken) {
       var strBuilder = new StringBuilder();
       while (!this.Eof) {
-        var c = this.ReadChar(encodingType);
+        var c = this.ReadChar(encoding);
         if (c == endToken) {
           break;
         }
@@ -135,7 +164,6 @@ public string ReadUpTo(StringEncodingType encodingType, char endToken) {
       return strBuilder.ToString();
     }
 
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public string ReadUpTo(ReadOnlySpan<string> endTokens) {
       var strBuilder = new StringBuilder();
       while (!Eof) {
@@ -163,17 +191,21 @@ public string ReadUpTo(ReadOnlySpan<string> endTokens) {
       return strBuilder.ToString();
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public string ReadUpTo(StringEncodingType encodingType,
-                           ReadOnlySpan<string> endTokens) {
+                           ReadOnlySpan<string> endTokens)
+      => this.ReadUpTo(encodingType.GetEncoding(this.Endianness), endTokens);
+
+    public string ReadUpTo(Encoding encoding, ReadOnlySpan<string> endTokens) {
       var strBuilder = new StringBuilder();
       while (!Eof) {
-        var firstC = this.ReadChar(encodingType);
+        var firstC = this.ReadChar(encoding);
         var originalOffset = Position;
 
         foreach (var endToken in endTokens) {
           if (firstC == endToken[0]) {
             for (var i = 1; i < endToken.Length; ++i) {
-              var c = this.ReadChar(encodingType);
+              var c = this.ReadChar(encoding);
               if (c != endToken[1]) {
                 Position = originalOffset;
                 break;
@@ -200,7 +232,11 @@ public string ReadLine()
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public string ReadLine(StringEncodingType encodingType)
-      => this.ReadUpTo(encodingType, TextReaderConstants.NEWLINE_STRINGS);
+      => this.ReadLine(encodingType.GetEncoding(this.Endianness));
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public string ReadLine(Encoding encoding)
+      => this.ReadUpTo(encoding, TextReaderConstants.NEWLINE_STRINGS);
 
 
     // String
@@ -213,9 +249,14 @@ public void AssertString(string expectedValue)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void AssertString(StringEncodingType encodingType,
                              string expectedValue)
+      => this.AssertString(encodingType.GetEncoding(this.Endianness),
+                           expectedValue);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void AssertString(Encoding encoding, string expectedValue)
       => SchemaBinaryReader.AssertStrings_(
           expectedValue.AsSpan().TrimEnd('\0'),
-          this.ReadString(encodingType, expectedValue.Length).AsSpan());
+          this.ReadString(encoding, expectedValue.Length).AsSpan());
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public string ReadString(long count) {
@@ -225,9 +266,13 @@ public string ReadString(long count) {
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public string ReadString(StringEncodingType encodingType, long count) {
+    public string ReadString(StringEncodingType encodingType, long count)
+      => this.ReadString(encodingType.GetEncoding(this.Endianness), count);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public string ReadString(Encoding encoding, long count) {
       Span<char> buffer = stackalloc char[(int) count];
-      this.ReadChars(encodingType, buffer);
+      this.ReadChars(encoding, buffer);
       return ((ReadOnlySpan<char>) buffer).TrimEnd('\0').ToString();
     }
 
@@ -246,13 +291,23 @@ public void AssertStringNT(string expectedValue)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void AssertStringNT(StringEncodingType encodingType,
                                string expectedValue)
+      => this.AssertStringNT(encodingType.GetEncoding(this.Endianness),
+                             expectedValue);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public string ReadStringNT(StringEncodingType encodingType)
+      => this.ReadStringNT(encodingType.GetEncoding(this.Endianness));
+
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void AssertStringNT(Encoding encoding, string expectedValue)
       => SchemaBinaryReader.AssertStrings_(
           expectedValue.AsSpan(),
           // TODO: Consider removing an allocation here
-          this.ReadStringNT(encodingType).AsSpan());
+          this.ReadStringNT(encoding).AsSpan());
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public string ReadStringNT(StringEncodingType encodingType)
-      => this.ReadUpTo(encodingType, '\0');
+    public string ReadStringNT(Encoding encoding)
+      => this.ReadUpTo(encoding, '\0');
   }
 }
diff --git a/Schema/src/text/reader/ITextReader.cs b/Schema/src/text/reader/ITextReader.cs
@@ -156,9 +156,9 @@ string[] ReadStrings(ReadOnlySpan<string> separators,
 
     bool TryReadNew<T>(out T? value) where T : ITextDeserializable, new();
 
-    void ReadNewArray<T>(out T[] array, int length)
+    void ReadNews<T>(out T[] array, int length)
         where T : ITextDeserializable, new();
 
-    T[] ReadNewArray<T>(int length) where T : ITextDeserializable, new();
+    T[] ReadNews<T>(int length) where T : ITextDeserializable, new();
   }
 }
diff --git a/Schema/src/text/reader/SchemaTextReader.cs b/Schema/src/text/reader/SchemaTextReader.cs
@@ -49,11 +49,11 @@ public bool TryReadNew<T>(out T? value)
       return success;
     }
 
-    public void ReadNewArray<T>(out T[] array, int length)
+    public void ReadNews<T>(out T[] array, int length)
         where T : ITextDeserializable, new()
-      => array = this.ReadNewArray<T>(length);
+      => array = this.ReadNews<T>(length);
 
-    public T[] ReadNewArray<T>(int length)
+    public T[] ReadNews<T>(int length)
         where T : ITextDeserializable, new() {
       var array = new T[length];
       for (var i = 0; i < length; ++i) {