Remove AsSpan, add AsArraySpan

xPaw · xPaw · commit dd8a1fb18ccd · 2026-04-04T23:44:05.000+03:00
diff --git a/ValveKeyValue/ValveKeyValue.Test/Test Data/apisurface.txt b/ValveKeyValue/ValveKeyValue.Test/Test Data/apisurface.txt
@@ -37,8 +37,8 @@ public class ValveKeyValue.KVDocument
     public .ctor(ValveKeyValue.KVHeader header, string name, ValveKeyValue.KVObject root);
     public void Add(string key, ValveKeyValue.KVObject value);
     public void Add(ValveKeyValue.KVObject value);
+    public Span`1[[ValveKeyValue.KVObject]] AsArraySpan();
     public byte[] AsBlob();
-    public ReadOnlySpan`1[[byte]] AsSpan();
     public void Clear();
     public bool ContainsKey(string name);
     public bool Equals(object obj);
@@ -169,8 +169,8 @@ public class ValveKeyValue.KVObject
     public static ValveKeyValue.KVObject Array();
     public static ValveKeyValue.KVObject Array(int capacity);
     public static ValveKeyValue.KVObject Array(System.Collections.Generic.IEnumerable`1[[ValveKeyValue.KVObject]] elements);
+    public Span`1[[ValveKeyValue.KVObject]] AsArraySpan();
     public byte[] AsBlob();
-    public ReadOnlySpan`1[[byte]] AsSpan();
     public static ValveKeyValue.KVObject Blob(byte[] data);
     public void Clear();
     public static ValveKeyValue.KVObject Collection();
diff --git a/ValveKeyValue/ValveKeyValue.Test/TextKV3/ValveFormatTestCase.cs b/ValveKeyValue/ValveKeyValue.Test/TextKV3/ValveFormatTestCase.cs
@@ -132,13 +132,13 @@ public void SerializesBinaryBlobsRoundTrip()
 
             var blob32 = data2["blob32"];
             Assert.That(blob32.AsBlob().Length, Is.EqualTo(32));
-            Assert.That(blob32.AsSpan()[0], Is.EqualTo(0x00));
-            Assert.That(blob32.AsSpan()[31], Is.EqualTo(0x1F));
+            Assert.That(blob32.AsBlob()[0], Is.EqualTo(0x00));
+            Assert.That(blob32.AsBlob()[31], Is.EqualTo(0x1F));
 
             var blob100 = data2["blob100"];
             Assert.That(blob100.AsBlob().Length, Is.EqualTo(100));
-            Assert.That(blob100.AsSpan()[0], Is.EqualTo(0x00));
-            Assert.That(blob100.AsSpan()[99], Is.EqualTo(0x63));
+            Assert.That(blob100.AsBlob()[0], Is.EqualTo(0x00));
+            Assert.That(blob100.AsBlob()[99], Is.EqualTo(0x63));
         }
 
         [Test]
@@ -345,8 +345,8 @@ public void BinaryBlobInlineRoundTrip()
                 Assert.That(data2["small"].AsBlob(), Is.EqualTo(new byte[] { 0x11, 0xFF }));
                 var exact32 = data2["exact32"];
                 Assert.That(exact32.AsBlob().Length, Is.EqualTo(32));
-                Assert.That(exact32.AsSpan()[0], Is.EqualTo(0x00));
-                Assert.That(exact32.AsSpan()[31], Is.EqualTo(0x1F));
+                Assert.That(exact32.AsBlob()[0], Is.EqualTo(0x00));
+                Assert.That(exact32.AsBlob()[31], Is.EqualTo(0x1F));
             });
         }
 
diff --git a/ValveKeyValue/ValveKeyValue/Abstraction/KVObjectVisitor.cs b/ValveKeyValue/ValveKeyValue/Abstraction/KVObjectVisitor.cs
@@ -30,7 +30,7 @@ void VisitObject(string? name, KVObject obj, bool isArray)
                     break;
 
                 case KVValueType.Array:
-                    var arrayList = obj.GetArrayList();
+                    var arrayList = obj.AsArraySpan();
                     var allSimple = true;
                     foreach (var element in arrayList)
                     {
@@ -40,7 +40,7 @@ void VisitObject(string? name, KVObject obj, bool isArray)
                             break;
                         }
                     }
-                    listener.OnArrayStart(name, obj.Flag, arrayList.Count, allSimple);
+                    listener.OnArrayStart(name, obj.Flag, arrayList.Length, allSimple);
                     foreach (var element in arrayList)
                     {
                         VisitObject(null, element, true);
diff --git a/ValveKeyValue/ValveKeyValue/KVObject.cs b/ValveKeyValue/ValveKeyValue/KVObject.cs
@@ -2,6 +2,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.Linq;
+using System.Runtime.InteropServices;
 
 namespace ValveKeyValue
 {
@@ -55,7 +56,7 @@ public partial class KVObject : IReadOnlyDictionary<string, KVObject>
         public int Count => ValueType switch
         {
             KVValueType.Collection => GetCollectionCount(),
-            KVValueType.Array => GetArrayList().Count,
+            KVValueType.Array => ((List<KVObject>)_ref!).Count,
             _ => 0,
         };
 
@@ -223,10 +224,11 @@ public KVObject this[int index]
             {
                 if (ValueType == KVValueType.Array)
                 {
-                    return GetArrayList()[index];
+                    var listArray = (List<KVObject>)_ref!;
+                    return listArray[index];
                 }
 
-                if (_ref is List<KeyValuePair<string, KVObject>> list && ValueType == KVValueType.Collection)
+                if (ValueType == KVValueType.Collection && _ref is List<KeyValuePair<string, KVObject>> list)
                 {
                     return list[index].Value;
                 }
@@ -280,7 +282,7 @@ public bool ContainsKey(string name)
         /// </summary>
         public IEnumerable<KeyValuePair<string, KVObject>> Children => ValueType switch
         {
-            KVValueType.Collection => GetCollectionChildren(),
+            KVValueType.Collection => EnumerateCollection(),
             KVValueType.Array => EnumerateArray(),
             _ => [],
         };
@@ -345,7 +347,8 @@ public void Add(KVObject value)
                 throw new InvalidOperationException($"Cannot add an array element to a {ValueType} value.");
             }
 
-            GetArrayList().Add(value ?? Null());
+            var list = (List<KVObject>)_ref!;
+            list.Add(value ?? Null());
         }
 
         /// <summary>
@@ -374,7 +377,8 @@ public void RemoveAt(int index)
                 throw new InvalidOperationException($"Cannot remove by index from a {ValueType} value.");
             }
 
-            GetArrayList().RemoveAt(index);
+            var list = (List<KVObject>)_ref!;
+            list.RemoveAt(index);
         }
 
         /// <summary>
@@ -492,7 +496,7 @@ public static KVObject Blob(byte[] data)
 
         #endregion
 
-        #region Blob access
+        #region Blob and list access
 
         /// <summary>Gets the binary blob data as a byte array.</summary>
         public byte[] AsBlob()
@@ -505,26 +509,19 @@ public byte[] AsBlob()
             return (byte[])_ref!;
         }
 
-        /// <summary>Gets the binary blob data as a span.</summary>
-        public ReadOnlySpan<byte> AsSpan()
+        /// <summary>Gets the array elements as a span.</summary>
+        public Span<KVObject> AsArraySpan()
         {
-            if (ValueType != KVValueType.BinaryBlob)
+            if (ValueType != KVValueType.Array)
             {
-                throw new InvalidOperationException($"Cannot get blob span from a {ValueType} value.");
+                throw new InvalidOperationException($"Cannot get list from a {ValueType} value.");
             }
 
-            return ((byte[])_ref!).AsSpan();
+            return CollectionsMarshal.AsSpan((List<KVObject>)_ref!);
         }
 
         #endregion
 
-        #region Internal accessors
-
-        internal List<KVObject> GetArrayList()
-            => (List<KVObject>)_ref!;
-
-        #endregion
-
         #region Private helpers
 
         private enum InsertionBehavior
@@ -593,7 +590,7 @@ private bool TryInsert(string key, KVObject value, InsertionBehavior behavior)
             _ => 0,
         };
 
-        private IEnumerable<KeyValuePair<string, KVObject>> GetCollectionChildren() => _ref switch
+        private IEnumerable<KeyValuePair<string, KVObject>> EnumerateCollection() => _ref switch
         {
             Dictionary<string, KVObject> dict => dict,
             List<KeyValuePair<string, KVObject>> list => list,
@@ -602,10 +599,10 @@ private bool TryInsert(string key, KVObject value, InsertionBehavior behavior)
 
         private IEnumerable<KeyValuePair<string, KVObject>> EnumerateArray()
         {
-            var list = GetArrayList();
-            for (var i = 0; i < list.Count; i++)
+            var list = (List<KVObject>)_ref!;
+            foreach (var item in list)
             {
-                yield return new KeyValuePair<string, KVObject>(null!, list[i]);
+                yield return new KeyValuePair<string, KVObject>(null!, item);
             }
         }
 
@@ -628,8 +625,8 @@ private static bool TryFindInList(List<KeyValuePair<string, KVObject>> list, str
         {
             KVValueType.String => $"\"{_ref}\"",
             KVValueType.Null => "null",
-            KVValueType.Collection => $"Collection ({GetCollectionCount()} items)",
-            KVValueType.Array => $"Array ({GetArrayList().Count} items)",
+            KVValueType.Collection => $"Collection ({Count} items)",
+            KVValueType.Array => $"Array ({Count} items)",
             _ => $"{ToString(CultureInfo.InvariantCulture)} ({ValueType})",
         };
 
diff --git a/ValveKeyValue/ValveKeyValue/KVObject_IConvertible.cs b/ValveKeyValue/ValveKeyValue/KVObject_IConvertible.cs
@@ -271,19 +271,24 @@ private T ConvertFromString<T>(IFormatProvider? provider) where T : IParsable<T>
         private string FormatBlob()
         {
             var bytes = ((byte[])_ref!).AsSpan();
-            var builder = new StringBuilder(bytes.Length * 3);
+
+            if (bytes.Length == 0)
+            {
+                return string.Empty;
+            }
+
+            var builder = new StringBuilder(bytes.Length * 3 - 1);
 
             for (var i = 0; i < bytes.Length; i++)
             {
+                if (i > 0)
+                {
+                    builder.Append(' ');
+                }
+
                 var b = bytes[i];
                 builder.Append(HexStringHelper.HexToCharUpper(b >> 4));
                 builder.Append(HexStringHelper.HexToCharUpper(b));
-                builder.Append(' ');
-            }
-
-            if (builder.Length > 1)
-            {
-                builder.Length -= 1;
             }
 
             return builder.ToString();
diff --git a/ValveKeyValue/ValveKeyValue/ObjectCopier.cs b/ValveKeyValue/ValveKeyValue/ObjectCopier.cs
@@ -52,7 +52,7 @@ public static object MakeObject(
             }
             else if (keyValueObject.ValueType == KVValueType.Array)
             {
-                var arrayValues = keyValueObject.GetArrayList().Select(c => (object)c).ToArray();
+                var arrayValues = keyValueObject.Values.Select(c => (object)c).ToArray();
                 if (ConstructTypedEnumerable(typeof(TObject), arrayValues, reflector, out var enumerable))
                 {
                     return (TObject)enumerable;
diff --git a/ValveKeyValue/ValveKeyValue/Serialization/KeyValues3/KV3TextSerializer.cs b/ValveKeyValue/ValveKeyValue/Serialization/KeyValues3/KV3TextSerializer.cs
@@ -304,7 +304,7 @@ void WriteFloatTrimmed(string formatted)
 
         void WriteBinaryBlob(KVObject value)
         {
-            var bytes = value.AsSpan();
+            var bytes = value.AsBlob();
 
             if (bytes.Length <= 32)
             {

Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ void VisitObject(string? name, KVObject obj, bool isArray)`
`30`	`30`	`break;`
`31`	`31`
`32`	`32`	`case KVValueType.Array:`
`33`		`- var arrayList = obj.GetArrayList();`
	`33`	`+ var arrayList = obj.AsArraySpan();`
`34`	`34`	`var allSimple = true;`
`35`	`35`	`foreach (var element in arrayList)`
`36`	`36`	`{`
`@@ -40,7 +40,7 @@ void VisitObject(string? name, KVObject obj, bool isArray)`
`40`	`40`	`break;`
`41`	`41`	`}`
`42`	`42`	`}`
`43`		`- listener.OnArrayStart(name, obj.Flag, arrayList.Count, allSimple);`
	`43`	`+ listener.OnArrayStart(name, obj.Flag, arrayList.Length, allSimple);`
`44`	`44`	`foreach (var element in arrayList)`
`45`	`45`	`{`
`46`	`46`	`VisitObject(null, element, true);`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`	`using System.Diagnostics.CodeAnalysis;`
`3`	`3`	`using System.Globalization;`
`4`	`4`	`using System.Linq;`
	`5`	`+using System.Runtime.InteropServices;`
`5`	`6`
`6`	`7`	`namespace ValveKeyValue`
`7`	`8`	`{`
`@@ -55,7 +56,7 @@ public partial class KVObject : IReadOnlyDictionary<string, KVObject>`
`55`	`56`	`public int Count => ValueType switch`
`56`	`57`	`{`
`57`	`58`	`KVValueType.Collection => GetCollectionCount(),`
`58`		`- KVValueType.Array => GetArrayList().Count,`
	`59`	`+ KVValueType.Array => ((List<KVObject>)_ref!).Count,`
`59`	`60`	`_ => 0,`
`60`	`61`	`};`
`61`	`62`
`@@ -223,10 +224,11 @@ public KVObject this[int index]`
`223`	`224`	`{`
`224`	`225`	`if (ValueType == KVValueType.Array)`
`225`	`226`	`{`
`226`		`- return GetArrayList()[index];`
	`227`	`+ var listArray = (List<KVObject>)_ref!;`
	`228`	`+ return listArray[index];`
`227`	`229`	`}`
`228`	`230`
`229`		`- if (_ref is List<KeyValuePair<string, KVObject>> list && ValueType == KVValueType.Collection)`
	`231`	`+ if (ValueType == KVValueType.Collection && _ref is List<KeyValuePair<string, KVObject>> list)`
`230`	`232`	`{`
`231`	`233`	`return list[index].Value;`
`232`	`234`	`}`
`@@ -280,7 +282,7 @@ public bool ContainsKey(string name)`
`280`	`282`	`/// </summary>`
`281`	`283`	`public IEnumerable<KeyValuePair<string, KVObject>> Children => ValueType switch`
`282`	`284`	`{`
`283`		`- KVValueType.Collection => GetCollectionChildren(),`
	`285`	`+ KVValueType.Collection => EnumerateCollection(),`
`284`	`286`	`KVValueType.Array => EnumerateArray(),`
`285`	`287`	`_ => [],`
`286`	`288`	`};`
`@@ -345,7 +347,8 @@ public void Add(KVObject value)`
`345`	`347`	`throw new InvalidOperationException($"Cannot add an array element to a {ValueType} value.");`
`346`	`348`	`}`
`347`	`349`
`348`		`- GetArrayList().Add(value ?? Null());`
	`350`	`+ var list = (List<KVObject>)_ref!;`
	`351`	`+ list.Add(value ?? Null());`
`349`	`352`	`}`
`350`	`353`
`351`	`354`	`/// <summary>`
`@@ -374,7 +377,8 @@ public void RemoveAt(int index)`
`374`	`377`	`throw new InvalidOperationException($"Cannot remove by index from a {ValueType} value.");`
`375`	`378`	`}`
`376`	`379`
`377`		`- GetArrayList().RemoveAt(index);`
	`380`	`+ var list = (List<KVObject>)_ref!;`
	`381`	`+ list.RemoveAt(index);`
`378`	`382`	`}`
`379`	`383`
`380`	`384`	`/// <summary>`
`@@ -492,7 +496,7 @@ public static KVObject Blob(byte[] data)`
`492`	`496`
`493`	`497`	`#endregion`
`494`	`498`
`495`		`- #region Blob access`
	`499`	`+ #region Blob and list access`
`496`	`500`
`497`	`501`	`/// <summary>Gets the binary blob data as a byte array.</summary>`
`498`	`502`	`public byte[] AsBlob()`
`@@ -505,26 +509,19 @@ public byte[] AsBlob()`
`505`	`509`	`return (byte[])_ref!;`
`506`	`510`	`}`
`507`	`511`
`508`		`- /// <summary>Gets the binary blob data as a span.</summary>`
`509`		`- public ReadOnlySpan<byte> AsSpan()`
	`512`	`+ /// <summary>Gets the array elements as a span.</summary>`
	`513`	`+ public Span<KVObject> AsArraySpan()`
`510`	`514`	`{`
`511`		`- if (ValueType != KVValueType.BinaryBlob)`
	`515`	`+ if (ValueType != KVValueType.Array)`
`512`	`516`	`{`
`513`		`- throw new InvalidOperationException($"Cannot get blob span from a {ValueType} value.");`
	`517`	`+ throw new InvalidOperationException($"Cannot get list from a {ValueType} value.");`
`514`	`518`	`}`
`515`	`519`
`516`		`- return ((byte[])_ref!).AsSpan();`
	`520`	`+ return CollectionsMarshal.AsSpan((List<KVObject>)_ref!);`
`517`	`521`	`}`
`518`	`522`
`519`	`523`	`#endregion`
`520`	`524`
`521`		`- #region Internal accessors`
`522`		`-`
`523`		`- internal List<KVObject> GetArrayList()`
`524`		`- => (List<KVObject>)_ref!;`
`525`		`-`
`526`		`- #endregion`
`527`		`-`
`528`	`525`	`#region Private helpers`
`529`	`526`
`530`	`527`	`private enum InsertionBehavior`
`@@ -593,7 +590,7 @@ private bool TryInsert(string key, KVObject value, InsertionBehavior behavior)`
`593`	`590`	`_ => 0,`
`594`	`591`	`};`
`595`	`592`
`596`		`- private IEnumerable<KeyValuePair<string, KVObject>> GetCollectionChildren() => _ref switch`
	`593`	`+ private IEnumerable<KeyValuePair<string, KVObject>> EnumerateCollection() => _ref switch`
`597`	`594`	`{`
`598`	`595`	`Dictionary<string, KVObject> dict => dict,`
`599`	`596`	`List<KeyValuePair<string, KVObject>> list => list,`
`@@ -602,10 +599,10 @@ private bool TryInsert(string key, KVObject value, InsertionBehavior behavior)`
`602`	`599`
`603`	`600`	`private IEnumerable<KeyValuePair<string, KVObject>> EnumerateArray()`
`604`	`601`	`{`
`605`		`- var list = GetArrayList();`
`606`		`- for (var i = 0; i < list.Count; i++)`
	`602`	`+ var list = (List<KVObject>)_ref!;`
	`603`	`+ foreach (var item in list)`
`607`	`604`	`{`
`608`		`- yield return new KeyValuePair<string, KVObject>(null!, list[i]);`
	`605`	`+ yield return new KeyValuePair<string, KVObject>(null!, item);`
`609`	`606`	`}`
`610`	`607`	`}`
`611`	`608`
`@@ -628,8 +625,8 @@ private static bool TryFindInList(List<KeyValuePair<string, KVObject>> list, str`
`628`	`625`	`{`
`629`	`626`	`KVValueType.String => $"\"{_ref}\"",`
`630`	`627`	`KVValueType.Null => "null",`
`631`		`- KVValueType.Collection => $"Collection ({GetCollectionCount()} items)",`
`632`		`- KVValueType.Array => $"Array ({GetArrayList().Count} items)",`
	`628`	`+ KVValueType.Collection => $"Collection ({Count} items)",`
	`629`	`+ KVValueType.Array => $"Array ({Count} items)",`
`633`	`630`	`_ => $"{ToString(CultureInfo.InvariantCulture)} ({ValueType})",`
`634`	`631`	`};`
`635`	`632`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ public static object MakeObject(`
`52`	`52`	`}`
`53`	`53`	`else if (keyValueObject.ValueType == KVValueType.Array)`
`54`	`54`	`{`
`55`		`- var arrayValues = keyValueObject.GetArrayList().Select(c => (object)c).ToArray();`
	`55`	`+ var arrayValues = keyValueObject.Values.Select(c => (object)c).ToArray();`
`56`	`56`	`if (ConstructTypedEnumerable(typeof(TObject), arrayValues, reflector, out var enumerable))`
`57`	`57`	`{`
`58`	`58`	`return (TObject)enumerable;`
Original file line number	Diff line number	Diff line change
`@@ -304,7 +304,7 @@ void WriteFloatTrimmed(string formatted)`
`304`	`304`
`305`	`305`	`void WriteBinaryBlob(KVObject value)`
`306`	`306`	`{`
`307`		`- var bytes = value.AsSpan();`
	`307`	`+ var bytes = value.AsBlob();`
`308`	`308`
`309`	`309`	`if (bytes.Length <= 32)`
`310`	`310`	`{`