Fix regressions

Author: Stefán J. Sigurðarson

projects/RabbitMQ.Client/client/impl/WireFormatting.cs

@@ -515,22 +515,101 @@ public static int WriteBits(Span<byte> span, bool val)
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int WriteBits(Span<byte> span, params bool[] vals)
+        public static int WriteBits(Span<byte> span, bool val1, bool val2)
         {
-            if(vals.Length > 8)
+            byte bits = 0;
+            if (val1)
+            {
+                bits |= 1 << 0;
+            }
+
+            if (val2)
             {
-                throw new ArgumentOutOfRangeException(nameof(vals), "Can only write less than 8 values");
+                bits |= 1 << 1;
             }
+            span[0] = bits;
+            return 1;
+        }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int WriteBits(Span<byte> span, bool val1, bool val2, bool val3)
+        {
             byte bits = 0;
-            for(int i = 0; i < vals.Length; i++)
+            if (val1)
             {
-                if (vals[i])
-                {
-                    bits |= (byte)(1 << i);
-                }
+                bits |= 1 << 0;
             }
 
+            if (val2)
+            {
+                bits |= 1 << 1;
+            }
+
+            if (val3)
+            {
+                bits |= 1 << 2;
+            }
+
+            span[0] = bits;
+            return 1;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int WriteBits(Span<byte> span, bool val1, bool val2, bool val3, bool val4)
+        {
+            byte bits = 0;
+            if (val1)
+            {
+                bits |= 1 << 0;
+            }
+
+            if (val2)
+            {
+                bits |= 1 << 1;
+            }
+
+            if (val3)
+            {
+                bits |= 1 << 2;
+            }
+
+            if (val4)
+            {
+                bits |= 1 << 3;
+            }
+
+            span[0] = bits;
+            return 1;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int WriteBits(Span<byte> span, bool val1, bool val2, bool val3, bool val4, bool val5)
+        {
+            byte bits = 0;
+            if (val1)
+            {
+                bits |= 1 << 0;
+            }
+
+            if (val2)
+            {
+                bits |= 1 << 1;
+            }
+
+            if (val3)
+            {
+                bits |= 1 << 2;
+            }
+
+            if (val4)
+            {
+                bits |= 1 << 3;
+            }
+
+            if (val5)
+            {
+                bits |= 1 << 4;
+            }
             span[0] = bits;
             return 1;
         }
@@ -541,8 +620,78 @@ public static int WriteBits(Span<byte> span,
             bool val6, bool val7, bool val8, bool val9, bool val10,
             bool val11, bool val12, bool val13, bool val14)
         {
-            WriteBits(span, val8, val7, val6, val5, val4, val3, val2, val1);
-            WriteBits(span.Slice(1), false, false, val14, val13, val12, val11, val10, val9);
+            byte bits = 0;
+            if (val1)
+            {
+                bits |= 1 << 7;
+            }
+
+            if (val2)
+            {
+                bits |= 1 << 6;
+            }
+
+            if (val3)
+            {
+                bits |= 1 << 5;
+            }
+
+            if (val4)
+            {
+                bits |= 1 << 4;
+            }
+
+            if (val5)
+            {
+                bits |= 1 << 3;
+            }
+
+            if (val6)
+            {
+                bits |= 1 << 2;
+            }
+
+            if (val7)
+            {
+                bits |= 1 << 1;
+            }
+
+            if (val8)
+            {
+                bits |= 1 << 0;
+            }
+            span[0] = bits;
+            bits = 0;
+            if (val9)
+            {
+                bits |= 1 << 7;
+            }
+
+            if (val10)
+            {
+                bits |= 1 << 6;
+            }
+
+            if (val11)
+            {
+                bits |= 1 << 5;
+            }
+
+            if (val12)
+            {
+                bits |= 1 << 4;
+            }
+
+            if (val13)
+            {
+                bits |= 1 << 3;
+            }
+
+            if (val14)
+            {
+                bits |= 1 << 2;
+            }
+            span[1] = bits;
             return 2;
         }
 
@@ -637,7 +786,7 @@ public static int WriteTable(Span<byte> span, IDictionary val)
             return 4 + bytesWritten;
         }
 
-        public static int WriteTable<T>(Span<byte> span, T val) where T : class, IDictionary<string, object>
+        public static int WriteTable(Span<byte> span, IDictionary<string, object> val)
         {
             if (val is null || val.Count == 0)
             {
@@ -648,10 +797,21 @@ public static int WriteTable<T>(Span<byte> span, T val) where T : class, IDictio
             // Let's only write after the length header.
             Span<byte> slice = span.Slice(4);
             int bytesWritten = 0;
-            foreach (KeyValuePair<string, object> entry in val)
+            if (val is Dictionary<string, object> dictVal)
             {
-                bytesWritten += WriteShortstr(slice.Slice(bytesWritten), entry.Key);
-                bytesWritten += WriteFieldValue(slice.Slice(bytesWritten), entry.Value);
+                foreach (KeyValuePair<string, object> entry in dictVal)
+                {
+                    bytesWritten += WriteShortstr(slice.Slice(bytesWritten), entry.Key);
+                    bytesWritten += WriteFieldValue(slice.Slice(bytesWritten), entry.Value);
+                }
+            }
+            else
+            {
+                foreach (KeyValuePair<string, object> entry in val)
+                {
+                    bytesWritten += WriteShortstr(slice.Slice(bytesWritten), entry.Key);
+                    bytesWritten += WriteFieldValue(slice.Slice(bytesWritten), entry.Value);
+                }
             }
 
             NetworkOrderSerializer.WriteUInt32(span, (uint)bytesWritten);
@@ -675,18 +835,29 @@ public static int GetTableByteCount(IDictionary val)
             return byteCount;
         }
 
-        public static int GetTableByteCount<T>(T val) where T : class, IDictionary<string, object>
+        public static int GetTableByteCount(IDictionary<string, object> val)
         {
             int byteCount = 4;
             if (val is null || val.Count == 0)
             {
                 return byteCount;
             }
 
-            foreach (KeyValuePair<string, object> entry in val)
+            if (val is Dictionary<string, object> valDict)
             {
-                byteCount += GetUTF8ByteCount(entry.Key) + 1;
-                byteCount += GetFieldValueByteCount(entry.Value);
+                foreach (KeyValuePair<string, object> entry in valDict)
+                {
+                    byteCount += GetUTF8ByteCount(entry.Key) + 1;
+                    byteCount += GetFieldValueByteCount(entry.Value);
+                }
+            }
+            else
+            {
+                foreach (KeyValuePair<string, object> entry in val)
+                {
+                    byteCount += GetUTF8ByteCount(entry.Key) + 1;
+                    byteCount += GetFieldValueByteCount(entry.Value);
+                }
             }
 
             return byteCount;