Centralize data segment info dispatching

Author: manuelbl

CONTEXT.md

@@ -51,6 +51,15 @@ The 8-bit symbols the payload becomes after a version and error correction level
 chosen: data codewords (segment bits + terminator + padding) followed by Reed-Solomon
 error correction codewords, interleaved per spec, ready to fill into the matrix.
 
+**Data segment mode info**:
+The per-mode rules of a `DataSegmentMode` — mode indicator, count-indicator widths, and
+(for the data modes: numeric, alphanumeric, Kanji, binary) the bit-length/byte-count
+formulas and the segment factory — held in one internal descriptor per mode and looked
+up by mode value. The public `DataSegmentMode` enum stays a plain enum; the behavior
+keyed off it lives in the descriptor.
+_Avoid_: putting per-mode logic on the public enum, or re-deriving it via `switch`/
+`(int)mode` arithmetic at each call site.
+
 ## Relationships
 
 - The encode pipeline is: text → data segments → **codewords** → **module** matrix.

QrCodeGenerator/ArraySegmentExtensions.cs

@@ -23,23 +23,23 @@ internal static class ArraySegmentExtensions
         /// needed as the struct includes an indexer.</remarks>
         internal static T At<T>(this ArraySegment<T> segment, int index)
         {
-            Debug.Assert(segment.Array != null);
+            Trace.Assert(segment.Array != null);
             return segment.Array[segment.Offset + index];
         }
 
         /// <summary>
         /// Forms a slice of the specified length out of the current array segment starting at the specified index.
         /// </summary>
         /// <param name="segment">The array segment.</param>
-        /// <param name="startIndex">The index at which the slices starts.</param>
+        /// <param name="startIndex">The index at which the slice starts.</param>
         /// <param name="length">The length of the slice.</param>
         /// <typeparam name="T">The type of the elements in the array segment.</typeparam>
         /// <returns>An array segment.</returns>
         /// <remarks>In later versions of the .NET Framework, this method is not
         /// needed as it was added to the struct.</remarks>
         internal static ArraySegment<T> MakeSlice<T>(this ArraySegment<T> segment, int startIndex, int length)
         {
-            Debug.Assert(segment.Array != null);
+            Trace.Assert(segment.Array != null);
             return new ArraySegment<T>(segment.Array, segment.Offset + startIndex, length);
         }
     }

QrCodeGenerator/DataSegment.cs

@@ -75,7 +75,7 @@ public abstract class DataSegment
         /// The position of the QR code within a structured append message.
         /// <para>
         /// Valid positions are between 1 and 16.
-        /// The value is only valuid if this segment uses the segment mode <see cref="DataSegmentMode.StructuredAppend"/>.
+        /// The value is only valid if this segment uses the segment mode <see cref="DataSegmentMode.StructuredAppend"/>.
         /// </para>
         /// </summary>
         public virtual int StructuredAppendPosition => 0;
@@ -84,15 +84,15 @@ public abstract class DataSegment
         /// The total number of QR codes used for the structured append message.
         /// <para>
         /// Valid numbers are between 1 and 16.
-        /// The value is only valuid if this segment uses the segment mode <see cref="DataSegmentMode.StructuredAppend"/>.
+        /// The value is only valid if this segment uses the segment mode <see cref="DataSegmentMode.StructuredAppend"/>.
         /// </para>
         /// </summary>
         public virtual int StructuredAppendTotal => 0;
 
         /// <summary>
         /// The data parity in the structured append messages.
         /// <para>
-        /// The value is only valuid if this segment uses the segment mode <see cref="DataSegmentMode.StructuredAppend"/>.
+        /// The value is only valid if this segment uses the segment mode <see cref="DataSegmentMode.StructuredAppend"/>.
         /// </para>
         /// </summary>
         public virtual byte StructuredAppendParity => 0;
@@ -274,19 +274,20 @@ internal static BitStream CreateBitStream(List<DataSegment> segments, int versio
             var bitStream = new BitStream(capacity);
             foreach (var segment in segments)
             {
+                var modeInfo = DataSegmentModeInfo.For(segment.Mode);
                 // mode indicator
-                bitStream.AppendBits(GetModeIndicator(segment.Mode), 4);
+                bitStream.AppendBits((uint)modeInfo.ModeIndicator, 4);
                 // character count indicator
-                if (segment.Mode >= DataSegmentMode.Numeric && segment.Mode <= DataSegmentMode.Binary)
+                if (modeInfo.HasCountIndicator)
                 {
                     bitStream.AppendBits((uint)segment.DataBytes.Count,
-                        GetCountIndicatorLength(segment.Mode, version));
+                        modeInfo.GetCountIndicatorLength(version));
                 }
                 // data bit stream
                 segment.WriteToBitStream(bitStream);
             }
 
-            Debug.Assert(bitStream.Length <= 8 * capacity);
+            Trace.Assert(bitStream.Length <= 8 * capacity);
 
             // terminator
             var terminatorLength = Math.Min(4, capacity * 8 - bitStream.Length);
@@ -309,17 +310,7 @@ internal static BitStream CreateBitStream(List<DataSegment> segments, int versio
 
         internal static uint GetModeIndicator(DataSegmentMode mode)
         {
-            uint symbol = 0;
-            switch (mode)
-            {
-                case DataSegmentMode.Numeric: symbol = 1; break;
-                case DataSegmentMode.Alphanumeric: symbol = 2; break;
-                case DataSegmentMode.Kanji: symbol = 8; break;
-                case DataSegmentMode.Binary: symbol = 4; break;
-                case DataSegmentMode.ECI: symbol = 7; break;
-                case DataSegmentMode.StructuredAppend: symbol = 3; break;
-            }
-            return symbol;
+            return (uint)DataSegmentModeInfo.For(mode).ModeIndicator;
         }
 
         #endregion
@@ -353,20 +344,10 @@ protected DataSegment(DataSegmentMode mode, int encodedLength)
         public static DataSegment MakeSegment(DataSegmentMode dataSegmentMode, ArraySegment<byte> dataBytes)
         {
             Objects.RequireNonNull(dataBytes.Array, "dataBytes.Array");
-            
-            switch (dataSegmentMode)
-            {
-                case DataSegmentMode.Numeric:
-                    return new DataSegmentNumeric(dataBytes);
-                case DataSegmentMode.Alphanumeric:
-                    return new DataSegmentAlphanumeric(dataBytes);
-                case DataSegmentMode.Kanji:
-                    return new DataSegmentKanji(dataBytes);
-                case DataSegmentMode.Binary:
-                    return new DataSegmentByte(dataBytes);
-                default:
-                    throw new ArgumentOutOfRangeException(nameof(dataSegmentMode), dataSegmentMode, "This mode is not supported by this function.");
-            }
+
+            var create = DataSegmentModeInfo.For(dataSegmentMode).Create;
+            Trace.Assert(create != null);
+            return create(dataBytes);
         }
 
         /// <summary>
@@ -397,35 +378,6 @@ public static DataSegment MakeStructuredAppend(int position, int total, byte par
 
         #region Length Calculation
 
-        /// <summary>
-        /// Calculates the encoded length of the payload.
-        /// <para>
-        /// The length does not include the mode indicator and  the count indicator.
-        /// </para>
-        /// <para>
-        /// This function only supports the encoding modes <em>Numeric</em>,
-        /// <em>AlphaNumeric</em>, <em>Kanji</em> and <em>Binary</em>.
-        /// </para>
-        /// </summary>
-        /// <param name="mode">The encoding mode.</param>
-        /// <param name="length">The number of bytes to encode.</param>
-        /// <returns>The payload length, in bits.</returns>
-        private static int GetDataBitLength(DataSegmentMode mode, int length)
-        {
-            switch (mode)
-            {
-                case DataSegmentMode.Numeric:
-                    return DataSegmentNumeric.GetNumericBitLength(length);
-                case DataSegmentMode.Alphanumeric:
-                    return DataSegmentAlphanumeric.GetAlphanumericBitLength(length);
-                case DataSegmentMode.Kanji:
-                    return DataSegmentKanji.GetKanjiBitLength(length);
-                case DataSegmentMode.Binary:
-                    return DataSegmentByte.GetByteBitLength(length);
-                default: throw new ArgumentOutOfRangeException(nameof(mode), mode, "This mode is not supported by this function.");
-            }
-        }
-        
         /// <summary>
         /// Calculates the segment length.
         /// <para>
@@ -442,7 +394,9 @@ private static int GetDataBitLength(DataSegmentMode mode, int length)
         /// <returns>The segment length, in bits.</returns>
         internal static int GetBitLength(DataSegmentMode mode, int length, int version)
         {
-            return GetHeaderLength(mode, version) + GetDataBitLength(mode, length);
+            var info = DataSegmentModeInfo.For(mode);
+            Trace.Assert(info.EncodedBitLength != null);
+            return info.GetHeaderLength(version) + info.EncodedBitLength(length);
         }
 
         internal static int GetBitLength(IEnumerable<DataSegment> segments, int version)
@@ -462,18 +416,9 @@ internal static int GetBitLength(IEnumerable<DataSegment> segments, int version)
         /// <exception cref="ArgumentOutOfRangeException">Thrown if an unsupported mode is specified.</exception>
         internal static int GetByteCount(DataSegmentMode mode, int bitLength)
         {
-            switch (mode)
-            {
-                case DataSegmentMode.Numeric:
-                    return DataSegmentNumeric.GetNumericByteCount(bitLength);
-                case DataSegmentMode.Alphanumeric:
-                    return DataSegmentAlphanumeric.GetAlphanumericByteCount(bitLength);
-                case DataSegmentMode.Kanji:
-                    return DataSegmentKanji.GetKanjiByteCount(bitLength);
-                case DataSegmentMode.Binary:
-                    return DataSegmentByte.GetByteByteCount(bitLength);
-                default: throw new ArgumentOutOfRangeException(nameof(mode), mode, "This mode is not supported by this function.");
-            }
+            var info = DataSegmentModeInfo.For(mode);
+            Trace.Assert(info.ByteCount != null);
+            return info.ByteCount(bitLength);
         }
 
         /// <summary>
@@ -484,25 +429,8 @@ internal static int GetByteCount(DataSegmentMode mode, int bitLength)
         /// <returns>The header length, in bits.</returns>
         internal static int GetHeaderLength(DataSegmentMode mode, int version)
         {
-            return 4 + GetCountIndicatorLength(mode, version);
+            return DataSegmentModeInfo.For(mode).GetHeaderLength(version);
         }
-
-        private static int GetCountIndicatorLength(DataSegmentMode mode, int version)
-        {
-            // Groups are: 1 to 9, 10 to 26, 27 to 40
-            var versionGroup = (version + 7) / 17;
-            return CountIndicatorLength[(int)mode * 3 - 3 + versionGroup];
-        }
-
-        private static readonly int[] CountIndicatorLength =
-        {
-            10, 12, 14, // numeric
-            9, 11, 13,  // alphanumeric
-            8, 10, 12,  // Kanji
-            8, 16, 16,  // binary
-            0, 0, 0,    // ECI designator
-            0, 0, 0     // structured append
-        };
 
         #endregion
 
@@ -531,7 +459,7 @@ public static string GetText(IEnumerable<DataSegment> segments)
                 else
                 {
                     var dataBytes = segment.DataBytes;
-                    Debug.Assert(dataBytes.Array != null);
+                    Trace.Assert(dataBytes.Array != null);
                     text.Append(encoding.GetString(dataBytes.Array, dataBytes.Offset, dataBytes.Count));
                 }
             }

QrCodeGenerator/DataSegmentAlphanumeric.cs

@@ -19,7 +19,7 @@ internal class DataSegmentAlphanumeric : DataSegment
         internal DataSegmentAlphanumeric(ArraySegment<byte> bytes)
             : base(DataSegmentMode.Alphanumeric, GetAlphanumericBitLength(bytes.Count))
         {
-            Debug.Assert(bytes.Array != null);
+            Trace.Assert(bytes.Array != null);
             DataBytes = bytes;
         }
 
@@ -51,7 +51,7 @@ internal static int GetAlphanumericByteCount(int bitLength)
 
         internal override void WriteToBitStream(BitStream bitStream)
         {
-            Debug.Assert(DataBytes.Array != null);
+            Trace.Assert(DataBytes.Array != null);
             for (var i = 0; i + 1 < DataBytes.Count; i += 2)
             {
                 // 2 letters are encoded into 11 bits

QrCodeGenerator/DataSegmentByte.cs

@@ -18,7 +18,7 @@ internal class DataSegmentByte : DataSegment
         internal DataSegmentByte(ArraySegment<byte> bytes)
             : base(DataSegmentMode.Binary, GetByteBitLength(bytes.Count))
         {
-            Debug.Assert(bytes.Array != null);
+            Trace.Assert(bytes.Array != null);
             DataBytes = bytes;
         }
 

QrCodeGenerator/DataSegmentKanji.cs

@@ -18,8 +18,8 @@ internal class DataSegmentKanji : DataSegment
         internal DataSegmentKanji(ArraySegment<byte> bytes)
             : base(DataSegmentMode.Kanji, GetKanjiBitLength(bytes.Count))
         {
-            Debug.Assert(bytes.Array != null);
-            Debug.Assert(bytes.Count % 2 == 0);
+            Trace.Assert(bytes.Array != null);
+            Trace.Assert(bytes.Count % 2 == 0);
             DataBytes = bytes;
         }
 
@@ -56,7 +56,7 @@ internal static int GetKanjiByteCount(int bitLength)
         internal override void WriteToBitStream(BitStream bitStream)
         {
             var bytes = DataBytes;
-            Debug.Assert(bytes.Array != null);
+            Trace.Assert(bytes.Array != null);
 
             for (var i = 0; i < bytes.Count; i += 2)
             {