Allow string and char[] with fixed sizes to optionally be read with the '\0's taken out

Kermalis · Kermalis · commit f8dd3cf88010 · 2020-09-11T04:25:37.000-04:00
Closes #19
diff --git a/README.md b/README.md
@@ -56,8 +56,10 @@ class MyBasicObj
     public string NullTerminatedASCIIString { get; set; }
 
     // String encoded in UTF-16 that will only read/write 10 chars
+    // The BinaryStringTrimNullTerminatorsAttribute will indicate that every char from the first \0 will be removed from the string. This attribute also works with char arrays
     [BinaryEncoding(EncodingType.UTF16)]
     [BinaryStringFixedLength(10)]
+    [BinaryStringTrimNullTerminators(true)]
     public string UTF16String { get; set; }
 }
 ```
diff --git a/Source/Attributes.cs b/Source/Attributes.cs
@@ -103,4 +103,14 @@ public BinaryStringVariableLengthAttribute(string anchor)
             Value = anchor;
         }
     }
+    [AttributeUsage(AttributeTargets.Property)]
+    public sealed class BinaryStringTrimNullTerminatorsAttribute : Attribute, IBinaryAttribute<bool>
+    {
+        public bool Value { get; }
+
+        public BinaryStringTrimNullTerminatorsAttribute(bool trim = true)
+        {
+            Value = trim;
+        }
+    }
 }
diff --git a/Source/EndianBinaryReader.cs b/Source/EndianBinaryReader.cs
@@ -276,16 +276,16 @@ public char ReadChar(EncodingType encodingType, long offset)
             BaseStream.Position = offset;
             return ReadChar(encodingType);
         }
-        public char[] ReadChars(int count)
+        public char[] ReadChars(int count, bool trimNullTerminators)
         {
-            return ReadChars(count, Encoding);
+            return ReadChars(count, trimNullTerminators, Encoding);
         }
-        public char[] ReadChars(int count, long offset)
+        public char[] ReadChars(int count, bool trimNullTerminators, long offset)
         {
             BaseStream.Position = offset;
-            return ReadChars(count);
+            return ReadChars(count, trimNullTerminators);
         }
-        public char[] ReadChars(int count, EncodingType encodingType)
+        public char[] ReadChars(int count, bool trimNullTerminators, EncodingType encodingType)
         {
             if (Utils.ValidateReadArraySize(count, out char[] array))
             {
@@ -294,12 +294,21 @@ public char[] ReadChars(int count, EncodingType encodingType)
             Encoding encoding = Utils.EncodingFromEnum(encodingType);
             int encodingSize = Utils.EncodingSize(encoding);
             ReadBytesIntoBuffer(count * encodingSize);
-            return encoding.GetChars(_buffer, 0, encodingSize * count);
+            array = encoding.GetChars(_buffer, 0, encodingSize * count);
+            if (trimNullTerminators)
+            {
+                int i = Array.IndexOf(array, '\0');
+                if (i != -1)
+                {
+                    Array.Resize(ref array, i);
+                }
+            }
+            return array;
         }
-        public char[] ReadChars(int count, EncodingType encodingType, long offset)
+        public char[] ReadChars(int count, bool trimNullTerminators, EncodingType encodingType, long offset)
         {
             BaseStream.Position = offset;
-            return ReadChars(count, encodingType);
+            return ReadChars(count, trimNullTerminators, encodingType);
         }
         public string ReadStringNullTerminated()
         {
@@ -329,23 +338,23 @@ public string ReadStringNullTerminated(EncodingType encodingType, long offset)
             BaseStream.Position = offset;
             return ReadStringNullTerminated(encodingType);
         }
-        public string ReadString(int charCount)
+        public string ReadString(int charCount, bool trimNullTerminators)
         {
-            return ReadString(charCount, Encoding);
+            return ReadString(charCount, trimNullTerminators, Encoding);
         }
-        public string ReadString(int charCount, long offset)
+        public string ReadString(int charCount, bool trimNullTerminators, long offset)
         {
             BaseStream.Position = offset;
-            return ReadString(charCount);
+            return ReadString(charCount, trimNullTerminators);
         }
-        public string ReadString(int charCount, EncodingType encodingType)
+        public string ReadString(int charCount, bool trimNullTerminators, EncodingType encodingType)
         {
-            return new string(ReadChars(charCount, encodingType));
+            return new string(ReadChars(charCount, trimNullTerminators, encodingType));
         }
-        public string ReadString(int charCount, EncodingType encodingType, long offset)
+        public string ReadString(int charCount, bool trimNullTerminators, EncodingType encodingType, long offset)
         {
             BaseStream.Position = offset;
-            return ReadString(charCount, encodingType);
+            return ReadString(charCount, trimNullTerminators, encodingType);
         }
         public string[] ReadStringsNullTerminated(int count)
         {
@@ -373,31 +382,31 @@ public string[] ReadStringsNullTerminated(int count, EncodingType encodingType,
             BaseStream.Position = offset;
             return ReadStringsNullTerminated(count, encodingType);
         }
-        public string[] ReadStrings(int count, int charCount)
+        public string[] ReadStrings(int count, int charCount, bool trimNullTerminators)
         {
-            return ReadStrings(count, charCount, Encoding);
+            return ReadStrings(count, charCount, trimNullTerminators, Encoding);
         }
-        public string[] ReadStrings(int count, int charCount, long offset)
+        public string[] ReadStrings(int count, int charCount, bool trimNullTerminators, long offset)
         {
             BaseStream.Position = offset;
-            return ReadStrings(count, charCount);
+            return ReadStrings(count, charCount, trimNullTerminators);
         }
-        public string[] ReadStrings(int count, int charCount, EncodingType encodingType)
+        public string[] ReadStrings(int count, int charCount, bool trimNullTerminators, EncodingType encodingType)
         {
             if (!Utils.ValidateReadArraySize(count, out string[] array))
             {
                 array = new string[count];
                 for (int i = 0; i < count; i++)
                 {
-                    array[i] = ReadString(charCount, encodingType);
+                    array[i] = ReadString(charCount, trimNullTerminators, encodingType);
                 }
             }
             return array;
         }
-        public string[] ReadStrings(int count, int charCount, EncodingType encodingType, long offset)
+        public string[] ReadStrings(int count, int charCount, bool trimNullTerminators, EncodingType encodingType, long offset)
         {
             BaseStream.Position = offset;
-            return ReadStrings(count, charCount, encodingType);
+            return ReadStrings(count, charCount, trimNullTerminators, encodingType);
         }
         public short ReadInt16()
         {
@@ -739,7 +748,8 @@ public void ReadIntoObject(object obj)
                             case TypeCode.Char:
                             {
                                 EncodingType encodingType = Utils.AttributeValueOrDefault<BinaryEncodingAttribute, EncodingType>(propertyInfo, Encoding);
-                                value = ReadChars(arrayLength, encodingType);
+                                bool trimNullTerminators = Utils.AttributeValueOrDefault<BinaryStringTrimNullTerminatorsAttribute, bool>(propertyInfo, false);
+                                value = ReadChars(arrayLength, trimNullTerminators, encodingType);
                                 break;
                             }
                             case TypeCode.Int16: value = ReadInt16s(arrayLength); break;
@@ -762,7 +772,8 @@ public void ReadIntoObject(object obj)
                                 }
                                 else
                                 {
-                                    value = ReadStrings(arrayLength, stringLength, encodingType);
+                                    bool trimNullTerminators = Utils.AttributeValueOrDefault<BinaryStringTrimNullTerminatorsAttribute, bool>(propertyInfo, false);
+                                    value = ReadStrings(arrayLength, stringLength, trimNullTerminators, encodingType);
                                 }
                                 break;
                             }
@@ -834,7 +845,8 @@ public void ReadIntoObject(object obj)
                             }
                             else
                             {
-                                value = ReadString(stringLength, encodingType);
+                                bool trimNullTerminators = Utils.AttributeValueOrDefault<BinaryStringTrimNullTerminatorsAttribute, bool>(propertyInfo, false);
+                                value = ReadString(stringLength, trimNullTerminators, encodingType);
                             }
                             break;
                         }
diff --git a/Source/Utils.cs b/Source/Utils.cs
@@ -154,6 +154,10 @@ int Validate(int value)
                 {
                     throw new ArgumentException($"A string property in \"{objType.FullName}\" has a string length attribute and a {nameof(BinaryStringNullTerminatedAttribute)}; cannot use both.");
                 }
+                if (propertyInfo.IsDefined(typeof(BinaryStringTrimNullTerminatorsAttribute)))
+                {
+                    throw new ArgumentException($"A string property in \"{objType.FullName}\" has a {nameof(BinaryStringNullTerminatedAttribute)} and a {nameof(BinaryStringTrimNullTerminatorsAttribute)}; cannot use both.");
+                }
                 bool nt = GetAttributeValue<BinaryStringNullTerminatedAttribute, bool>(nullTermAttribute);
                 if (forReads && !nt) // Not forcing BinaryStringNullTerminatedAttribute to be treated as true since you may only write objects without reading them.
                 {
diff --git a/Testing/BasicTests.cs b/Testing/BasicTests.cs
@@ -37,6 +37,7 @@ private sealed class MyBasicObj
             // String encoded in UTF-16 that will only read/write 10 chars
             [BinaryEncoding(EncodingType.UTF16)]
             [BinaryStringFixedLength(10)]
+            [BinaryStringTrimNullTerminators(true)]
             public string UTF16String { get; set; }
         }
 
@@ -95,7 +96,7 @@ public void ReadObject()
             Assert.False(obj.Bool32); // bool32 works
 
             Assert.True(obj.NullTerminatedASCIIString == "EndianBinaryIO"); // Stops reading at null terminator
-            Assert.True(obj.UTF16String == "Kermalis\0\0"); // Fixed size (10 chars) utf16
+            Assert.True(obj.UTF16String == "Kermalis"); // Fixed size (10 chars) utf16, with the \0s trimmed
         }
 
         [Fact]
@@ -126,8 +127,8 @@ public void ReadManually()
 
                 obj.NullTerminatedASCIIString = reader.ReadStringNullTerminated(EncodingType.ASCII);
                 Assert.True(obj.NullTerminatedASCIIString == "EndianBinaryIO"); // Stops reading at null terminator
-                obj.UTF16String = reader.ReadString(10, EncodingType.UTF16);
-                Assert.True(obj.UTF16String == "Kermalis\0\0"); // Fixed size (10 chars) utf16
+                obj.UTF16String = reader.ReadString(10, true, EncodingType.UTF16);
+                Assert.True(obj.UTF16String == "Kermalis"); // Fixed size (10 chars) utf16, with the \0s trimmed
             }
         }
 

Original file line number	Diff line number	Diff line change
`@@ -103,4 +103,14 @@ public BinaryStringVariableLengthAttribute(string anchor)`
`103`	`103`	`Value = anchor;`
`104`	`104`	`}`
`105`	`105`	`}`
	`106`	`+ [AttributeUsage(AttributeTargets.Property)]`
	`107`	`+ public sealed class BinaryStringTrimNullTerminatorsAttribute : Attribute, IBinaryAttribute<bool>`
	`108`	`+ {`
	`109`	`+ public bool Value { get; }`
	`110`	`+`
	`111`	`+ public BinaryStringTrimNullTerminatorsAttribute(bool trim = true)`
	`112`	`+ {`
	`113`	`+ Value = trim;`
	`114`	`+ }`
	`115`	`+ }`
`106`	`116`	`}`
Original file line number	Diff line number	Diff line change
`@@ -276,16 +276,16 @@ public char ReadChar(EncodingType encodingType, long offset)`
`276`	`276`	`BaseStream.Position = offset;`
`277`	`277`	`return ReadChar(encodingType);`
`278`	`278`	`}`
`279`		`- public char[] ReadChars(int count)`
	`279`	`+ public char[] ReadChars(int count, bool trimNullTerminators)`
`280`	`280`	`{`
`281`		`- return ReadChars(count, Encoding);`
	`281`	`+ return ReadChars(count, trimNullTerminators, Encoding);`
`282`	`282`	`}`
`283`		`- public char[] ReadChars(int count, long offset)`
	`283`	`+ public char[] ReadChars(int count, bool trimNullTerminators, long offset)`
`284`	`284`	`{`
`285`	`285`	`BaseStream.Position = offset;`
`286`		`- return ReadChars(count);`
	`286`	`+ return ReadChars(count, trimNullTerminators);`
`287`	`287`	`}`
`288`		`- public char[] ReadChars(int count, EncodingType encodingType)`
	`288`	`+ public char[] ReadChars(int count, bool trimNullTerminators, EncodingType encodingType)`
`289`	`289`	`{`
`290`	`290`	`if (Utils.ValidateReadArraySize(count, out char[] array))`
`291`	`291`	`{`
`@@ -294,12 +294,21 @@ public char[] ReadChars(int count, EncodingType encodingType)`
`294`	`294`	`Encoding encoding = Utils.EncodingFromEnum(encodingType);`
`295`	`295`	`int encodingSize = Utils.EncodingSize(encoding);`
`296`	`296`	`ReadBytesIntoBuffer(count * encodingSize);`
`297`		`- return encoding.GetChars(_buffer, 0, encodingSize * count);`
	`297`	`+ array = encoding.GetChars(_buffer, 0, encodingSize * count);`
	`298`	`+ if (trimNullTerminators)`
	`299`	`+ {`
	`300`	`+ int i = Array.IndexOf(array, '\0');`
	`301`	`+ if (i != -1)`
	`302`	`+ {`
	`303`	`+ Array.Resize(ref array, i);`
	`304`	`+ }`
	`305`	`+ }`
	`306`	`+ return array;`
`298`	`307`	`}`
`299`		`- public char[] ReadChars(int count, EncodingType encodingType, long offset)`
	`308`	`+ public char[] ReadChars(int count, bool trimNullTerminators, EncodingType encodingType, long offset)`
`300`	`309`	`{`
`301`	`310`	`BaseStream.Position = offset;`
`302`		`- return ReadChars(count, encodingType);`
	`311`	`+ return ReadChars(count, trimNullTerminators, encodingType);`
`303`	`312`	`}`
`304`	`313`	`public string ReadStringNullTerminated()`
`305`	`314`	`{`
`@@ -329,23 +338,23 @@ public string ReadStringNullTerminated(EncodingType encodingType, long offset)`
`329`	`338`	`BaseStream.Position = offset;`
`330`	`339`	`return ReadStringNullTerminated(encodingType);`
`331`	`340`	`}`
`332`		`- public string ReadString(int charCount)`
	`341`	`+ public string ReadString(int charCount, bool trimNullTerminators)`
`333`	`342`	`{`
`334`		`- return ReadString(charCount, Encoding);`
	`343`	`+ return ReadString(charCount, trimNullTerminators, Encoding);`
`335`	`344`	`}`
`336`		`- public string ReadString(int charCount, long offset)`
	`345`	`+ public string ReadString(int charCount, bool trimNullTerminators, long offset)`
`337`	`346`	`{`
`338`	`347`	`BaseStream.Position = offset;`
`339`		`- return ReadString(charCount);`
	`348`	`+ return ReadString(charCount, trimNullTerminators);`
`340`	`349`	`}`
`341`		`- public string ReadString(int charCount, EncodingType encodingType)`
	`350`	`+ public string ReadString(int charCount, bool trimNullTerminators, EncodingType encodingType)`
`342`	`351`	`{`
`343`		`- return new string(ReadChars(charCount, encodingType));`
	`352`	`+ return new string(ReadChars(charCount, trimNullTerminators, encodingType));`
`344`	`353`	`}`
`345`		`- public string ReadString(int charCount, EncodingType encodingType, long offset)`
	`354`	`+ public string ReadString(int charCount, bool trimNullTerminators, EncodingType encodingType, long offset)`
`346`	`355`	`{`
`347`	`356`	`BaseStream.Position = offset;`
`348`		`- return ReadString(charCount, encodingType);`
	`357`	`+ return ReadString(charCount, trimNullTerminators, encodingType);`
`349`	`358`	`}`
`350`	`359`	`public string[] ReadStringsNullTerminated(int count)`
`351`	`360`	`{`
`@@ -373,31 +382,31 @@ public string[] ReadStringsNullTerminated(int count, EncodingType encodingType,`
`373`	`382`	`BaseStream.Position = offset;`
`374`	`383`	`return ReadStringsNullTerminated(count, encodingType);`
`375`	`384`	`}`
`376`		`- public string[] ReadStrings(int count, int charCount)`
	`385`	`+ public string[] ReadStrings(int count, int charCount, bool trimNullTerminators)`
`377`	`386`	`{`
`378`		`- return ReadStrings(count, charCount, Encoding);`
	`387`	`+ return ReadStrings(count, charCount, trimNullTerminators, Encoding);`
`379`	`388`	`}`
`380`		`- public string[] ReadStrings(int count, int charCount, long offset)`
	`389`	`+ public string[] ReadStrings(int count, int charCount, bool trimNullTerminators, long offset)`
`381`	`390`	`{`
`382`	`391`	`BaseStream.Position = offset;`
`383`		`- return ReadStrings(count, charCount);`
	`392`	`+ return ReadStrings(count, charCount, trimNullTerminators);`
`384`	`393`	`}`
`385`		`- public string[] ReadStrings(int count, int charCount, EncodingType encodingType)`
	`394`	`+ public string[] ReadStrings(int count, int charCount, bool trimNullTerminators, EncodingType encodingType)`
`386`	`395`	`{`
`387`	`396`	`if (!Utils.ValidateReadArraySize(count, out string[] array))`
`388`	`397`	`{`
`389`	`398`	`array = new string[count];`
`390`	`399`	`for (int i = 0; i < count; i++)`
`391`	`400`	`{`
`392`		`- array[i] = ReadString(charCount, encodingType);`
	`401`	`+ array[i] = ReadString(charCount, trimNullTerminators, encodingType);`
`393`	`402`	`}`
`394`	`403`	`}`
`395`	`404`	`return array;`
`396`	`405`	`}`
`397`		`- public string[] ReadStrings(int count, int charCount, EncodingType encodingType, long offset)`
	`406`	`+ public string[] ReadStrings(int count, int charCount, bool trimNullTerminators, EncodingType encodingType, long offset)`
`398`	`407`	`{`
`399`	`408`	`BaseStream.Position = offset;`
`400`		`- return ReadStrings(count, charCount, encodingType);`
	`409`	`+ return ReadStrings(count, charCount, trimNullTerminators, encodingType);`
`401`	`410`	`}`
`402`	`411`	`public short ReadInt16()`
`403`	`412`	`{`
`@@ -739,7 +748,8 @@ public void ReadIntoObject(object obj)`
`739`	`748`	`case TypeCode.Char:`
`740`	`749`	`{`
`741`	`750`	`EncodingType encodingType = Utils.AttributeValueOrDefault<BinaryEncodingAttribute, EncodingType>(propertyInfo, Encoding);`
`742`		`- value = ReadChars(arrayLength, encodingType);`
	`751`	`+ bool trimNullTerminators = Utils.AttributeValueOrDefault<BinaryStringTrimNullTerminatorsAttribute, bool>(propertyInfo, false);`
	`752`	`+ value = ReadChars(arrayLength, trimNullTerminators, encodingType);`
`743`	`753`	`break;`
`744`	`754`	`}`
`745`	`755`	`case TypeCode.Int16: value = ReadInt16s(arrayLength); break;`
`@@ -762,7 +772,8 @@ public void ReadIntoObject(object obj)`
`762`	`772`	`}`
`763`	`773`	`else`
`764`	`774`	`{`
`765`		`- value = ReadStrings(arrayLength, stringLength, encodingType);`
	`775`	`+ bool trimNullTerminators = Utils.AttributeValueOrDefault<BinaryStringTrimNullTerminatorsAttribute, bool>(propertyInfo, false);`
	`776`	`+ value = ReadStrings(arrayLength, stringLength, trimNullTerminators, encodingType);`
`766`	`777`	`}`
`767`	`778`	`break;`
`768`	`779`	`}`
`@@ -834,7 +845,8 @@ public void ReadIntoObject(object obj)`
`834`	`845`	`}`
`835`	`846`	`else`
`836`	`847`	`{`
`837`		`- value = ReadString(stringLength, encodingType);`
	`848`	`+ bool trimNullTerminators = Utils.AttributeValueOrDefault<BinaryStringTrimNullTerminatorsAttribute, bool>(propertyInfo, false);`
	`849`	`+ value = ReadString(stringLength, trimNullTerminators, encodingType);`
`838`	`850`	`}`
`839`	`851`	`break;`
`840`	`852`	`}`
Original file line number	Diff line number	Diff line change
`@@ -154,6 +154,10 @@ int Validate(int value)`
`154`	`154`	`{`
`155`	`155`	`throw new ArgumentException($"A string property in \"{objType.FullName}\" has a string length attribute and a {nameof(BinaryStringNullTerminatedAttribute)}; cannot use both.");`
`156`	`156`	`}`
	`157`	`+ if (propertyInfo.IsDefined(typeof(BinaryStringTrimNullTerminatorsAttribute)))`
	`158`	`+ {`
	`159`	`+ throw new ArgumentException($"A string property in \"{objType.FullName}\" has a {nameof(BinaryStringNullTerminatedAttribute)} and a {nameof(BinaryStringTrimNullTerminatorsAttribute)}; cannot use both.");`
	`160`	`+ }`
`157`	`161`	`bool nt = GetAttributeValue<BinaryStringNullTerminatedAttribute, bool>(nullTermAttribute);`
`158`	`162`	`if (forReads && !nt) // Not forcing BinaryStringNullTerminatedAttribute to be treated as true since you may only write objects without reading them.`
`159`	`163`	`{`
Original file line number	Diff line number	Diff line change
`@@ -37,6 +37,7 @@ private sealed class MyBasicObj`
`37`	`37`	`// String encoded in UTF-16 that will only read/write 10 chars`
`38`	`38`	`[BinaryEncoding(EncodingType.UTF16)]`
`39`	`39`	`[BinaryStringFixedLength(10)]`
	`40`	`+ [BinaryStringTrimNullTerminators(true)]`
`40`	`41`	`public string UTF16String { get; set; }`
`41`	`42`	`}`
`42`	`43`
`@@ -95,7 +96,7 @@ public void ReadObject()`
`95`	`96`	`Assert.False(obj.Bool32); // bool32 works`
`96`	`97`
`97`	`98`	`Assert.True(obj.NullTerminatedASCIIString == "EndianBinaryIO"); // Stops reading at null terminator`
`98`		`- Assert.True(obj.UTF16String == "Kermalis\0\0"); // Fixed size (10 chars) utf16`
	`99`	`+ Assert.True(obj.UTF16String == "Kermalis"); // Fixed size (10 chars) utf16, with the \0s trimmed`
`99`	`100`	`}`
`100`	`101`
`101`	`102`	`[Fact]`
`@@ -126,8 +127,8 @@ public void ReadManually()`
`126`	`127`
`127`	`128`	`obj.NullTerminatedASCIIString = reader.ReadStringNullTerminated(EncodingType.ASCII);`
`128`	`129`	`Assert.True(obj.NullTerminatedASCIIString == "EndianBinaryIO"); // Stops reading at null terminator`
`129`		`- obj.UTF16String = reader.ReadString(10, EncodingType.UTF16);`
`130`		`- Assert.True(obj.UTF16String == "Kermalis\0\0"); // Fixed size (10 chars) utf16`
	`130`	`+ obj.UTF16String = reader.ReadString(10, true, EncodingType.UTF16);`
	`131`	`+ Assert.True(obj.UTF16String == "Kermalis"); // Fixed size (10 chars) utf16, with the \0s trimmed`
`131`	`132`	`}`
`132`	`133`	`}`
`133`	`134`