[Rust] updated generator to create "_from_iter" and "_zero_padded" functions for primitive array

Author: Michael Ward

rust/tests/extension_test.rs

@@ -187,7 +187,7 @@ fn encode_car_from_scratch() -> SbeResult<(usize, Vec<u8>)> {
     car.available(BooleanType::T);
     car.code(Model::A);
     car.some_numbers(&[0, 1, 2, 3]);
-    car.vehicle_code_from_iter(b"abcdef_extra_is_ignored".iter().map(|x| *x)); // abcdef
+    car.vehicle_code_from_iter(b"abcdef_extra_is_ignored".into_iter().copied()); // abcdef
 
     extras.set_cruise_control(true);
     extras.set_sports_pack(true);

rust/tests/fixed_sized_primitive_array.rs

@@ -74,7 +74,7 @@ fn test_encode_then_decode_u8_slice() {
                 let mut buffer = [uninit; 1024];
                 let mut encoder = create_encoder(&mut buffer);
 
-                encode_func(&mut encoder, each_slice.iter().map(|x| *x));
+                encode_func(&mut encoder, each_slice.into_iter().copied());
 
                 let end = 1i32;
                 end_encode_func(&mut encoder, end);
@@ -295,7 +295,7 @@ fn test_encode_then_decode_non_u8_signed_primitive_slice() {
                 let mut buffer = [uninit; 1024];
                 let mut encoder = create_encoder(&mut buffer);
 
-                encode_func(&mut encoder, each_slice.iter().map(|x| *x));
+                encode_func(&mut encoder, each_slice.into_iter().copied());
 
                 let end = 1i32;
                 end_encode_func(&mut encoder, end);
@@ -500,7 +500,7 @@ fn test_encode_then_decode_non_u8_unsigned_primitive_slice() {
                 let mut buffer = [uninit; 1024];
                 let mut encoder = create_encoder(&mut buffer);
 
-                encode_func(&mut encoder, each_slice.iter().map(|x| *x));
+                encode_func(&mut encoder, each_slice.into_iter().copied());
 
                 let end = 1i32;
                 end_encode_func(&mut encoder, end);
@@ -628,7 +628,7 @@ fn test_encode_then_decode_u8_slice_padded() {
                 let mut buffer = [uninit; 1024];
                 let mut encoder = create_encoder(&mut buffer);
 
-                encode_func(&mut encoder, each_slice.iter().map(|x| *x));
+                encode_func(&mut encoder, each_slice);
 
                 let end = 1i32;
                 end_encode_func(&mut encoder, end);
@@ -660,49 +660,49 @@ fn test_encode_then_decode_u8_slice_padded() {
     }
 
     run_encode_then_decode_for_array_of_u8_len_16!(
-        DemoEncoder::fixed_16_char_from_iter,
+        DemoEncoder::fixed_16_char_zero_padded,
         DemoDecoder::fixed_16_char,
         DemoEncoder::fixed_16_char_end,
         DemoDecoder::fixed_16_char_end,
     );
     run_encode_then_decode_for_array_of_u8_len_16!(
-        DemoEncoder::fixed_16_ascii_char_from_iter,
+        DemoEncoder::fixed_16_ascii_char_zero_padded,
         DemoDecoder::fixed_16_ascii_char,
         DemoEncoder::fixed_16_ascii_char_end,
         DemoDecoder::fixed_16_ascii_char_end,
     );
     run_encode_then_decode_for_array_of_u8_len_16!(
-        DemoEncoder::fixed_16_gb_18030_char_from_iter,
+        DemoEncoder::fixed_16_gb_18030_char_zero_padded,
         DemoDecoder::fixed_16_gb_18030_char,
         DemoEncoder::fixed_16_gb_18030_char_end,
         DemoDecoder::fixed_16_gb_18030_char_end,
     );
     run_encode_then_decode_for_array_of_u8_len_16!(
-        DemoEncoder::fixed_16_utf_8_char_from_iter,
+        DemoEncoder::fixed_16_utf_8_char_zero_padded,
         DemoDecoder::fixed_16_utf_8_char,
         DemoEncoder::fixed_16_utf_8_char_end,
         DemoDecoder::fixed_16_utf_8_char_end,
     );
     run_encode_then_decode_for_array_of_u8_len_16!(
-        DemoEncoder::fixed_16_u8_from_iter,
+        DemoEncoder::fixed_16_u8_zero_padded,
         DemoDecoder::fixed_16_u8,
         DemoEncoder::fixed_16_u8_end,
         DemoDecoder::fixed_16_u8_end,
     );
     run_encode_then_decode_for_array_of_u8_len_16!(
-        DemoEncoder::fixed_16_ascii_u8_from_iter,
+        DemoEncoder::fixed_16_ascii_u8_zero_padded,
         DemoDecoder::fixed_16_ascii_u8,
         DemoEncoder::fixed_16_ascii_u8_end,
         DemoDecoder::fixed_16_ascii_u8_end,
     );
     run_encode_then_decode_for_array_of_u8_len_16!(
-        DemoEncoder::fixed_16_gb_18030_u8_from_iter,
+        DemoEncoder::fixed_16_gb_18030_u8_zero_padded,
         DemoDecoder::fixed_16_gb_18030_u8,
         DemoEncoder::fixed_16_gb_18030_u8_end,
         DemoDecoder::fixed_16_gb_18030_u8_end,
     );
     run_encode_then_decode_for_array_of_u8_len_16!(
-        DemoEncoder::fixed_16_utf_8_u8_from_iter,
+        DemoEncoder::fixed_16_utf_8_u8_zero_padded,
         DemoDecoder::fixed_16_utf_8_u8,
         DemoEncoder::fixed_16_utf_8u_8_end,
         DemoDecoder::fixed_16_utf_8u_8_end,
@@ -846,7 +846,7 @@ fn test_encode_then_decode_non_u8_signed_primitive_slice_padded() {
                 let mut buffer = [uninit; 1024];
                 let mut encoder = create_encoder(&mut buffer);
 
-                encode_func(&mut encoder, each_slice.iter().map(|x| *x));
+                encode_func(&mut encoder, each_slice);
 
                 let end = 1i32;
                 end_encode_func(&mut encoder, end);
@@ -884,28 +884,28 @@ fn test_encode_then_decode_non_u8_signed_primitive_slice_padded() {
     }
 
     run_encode_then_decode_for_array_of_signed_len_16!(
-        DemoEncoder::fixed_16_i8_from_iter,
+        DemoEncoder::fixed_16_i8_zero_padded,
         DemoDecoder::fixed_16_i8,
         DemoEncoder::fixed_16_i8_end,
         DemoDecoder::fixed_16_i8_end,
         i8,
     );
     run_encode_then_decode_for_array_of_signed_len_16!(
-        DemoEncoder::fixed_16_i16_from_iter,
+        DemoEncoder::fixed_16_i16_zero_padded,
         DemoDecoder::fixed_16_i16,
         DemoEncoder::fixed_16_i16_end,
         DemoDecoder::fixed_16_i16_end,
         i16,
     );
     run_encode_then_decode_for_array_of_signed_len_16!(
-        DemoEncoder::fixed_16_i32_from_iter,
+        DemoEncoder::fixed_16_i32_zero_padded,
         DemoDecoder::fixed_16_i32,
         DemoEncoder::fixed_16_i32_end,
         DemoDecoder::fixed_16_i32_end,
         i32,
     );
     run_encode_then_decode_for_array_of_signed_len_16!(
-        DemoEncoder::fixed_16_i64_from_iter,
+        DemoEncoder::fixed_16_i64_zero_padded,
         DemoDecoder::fixed_16_i64,
         DemoEncoder::fixed_16_i64_end,
         DemoDecoder::fixed_16_i64_end,
@@ -1049,7 +1049,7 @@ fn test_encode_then_decode_non_u8_unsigned_primitive_slice_padded() {
                 let mut buffer = [uninit; 1024];
                 let mut encoder = create_encoder(&mut buffer);
 
-                encode_func(&mut encoder, each_slice.iter().map(|x| *x));
+                encode_func(&mut encoder, each_slice);
 
                 let end = 1i32;
                 end_encode_func(&mut encoder, end);
@@ -1087,21 +1087,21 @@ fn test_encode_then_decode_non_u8_unsigned_primitive_slice_padded() {
     }
 
     run_encode_then_decode_for_array_of_unsigned_len_16!(
-        DemoEncoder::fixed_16_u16_from_iter,
+        DemoEncoder::fixed_16_u16_zero_padded,
         DemoDecoder::fixed_16_u16,
         DemoEncoder::fixed_16_u16_end,
         DemoDecoder::fixed_16_u16_end,
         u16
     );
     run_encode_then_decode_for_array_of_unsigned_len_16!(
-        DemoEncoder::fixed_16_u32_from_iter,
+        DemoEncoder::fixed_16_u32_zero_padded,
         DemoDecoder::fixed_16_u32,
         DemoEncoder::fixed_16_u32_end,
         DemoDecoder::fixed_16_u32_end,
         u32
     );
     run_encode_then_decode_for_array_of_unsigned_len_16!(
-        DemoEncoder::fixed_16_u64_from_iter,
+        DemoEncoder::fixed_16_u64_zero_padded,
         DemoDecoder::fixed_16_u64,
         DemoEncoder::fixed_16_u64_end,
         DemoDecoder::fixed_16_u64_end,

sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/RustGenerator.java

@@ -383,6 +383,63 @@ private static void generateRustDoc(
         indent(sb, level, "/// - version: %d\n", typeToken.version());
     }
 
+    private static void generatePrimitiveArrayFromIterEncoder(
+            final StringBuilder sb,
+            final int level,
+            final Token typeToken,
+            final String name) throws IOException
+    {
+        final Encoding encoding = typeToken.encoding();
+        final PrimitiveType primitiveType = encoding.primitiveType();
+        final String rustPrimitiveType = rustTypeName(primitiveType);
+
+        indent(sb, level, "/// primitive array field '%s' from an Iterator\n", name);
+        generateRustDoc(sb, level, typeToken, encoding);
+        indent(sb, level, "#[inline]\n");
+        indent(sb, level, "pub fn %s_from_iter(&mut self, iter: impl Iterator<Item = %s>) {\n",
+                formatFunctionName(name), rustPrimitiveType);
+
+        indent(sb, level + 1, "let offset = self.%s;\n", getBufOffset(typeToken));
+        indent(sb, level + 1, "let buf = self.get_buf_mut();\n");
+        indent(sb, level + 1, "for (i, v) in iter.enumerate() {\n");
+
+        if (primitiveType.size() == 1)
+        {
+            indent(sb, level + 2, "buf.put_%s_at(offset + i, v);\n", rustPrimitiveType);
+        }
+        else
+        {
+            indent(sb, level + 2, "buf.put_%s_at(offset + i * %d, v);\n",
+                rustPrimitiveType, primitiveType.size());
+        }
+        indent(sb, level + 1, "}\n");
+        indent(sb, level, "}\n\n");
+    }
+
+    private static void generatePrimitiveArrayZeroPaddedEncoder(
+            final StringBuilder sb,
+            final int level,
+            final Token typeToken,
+            final String name) throws IOException
+    {
+        final Encoding encoding = typeToken.encoding();
+        final PrimitiveType primitiveType = encoding.primitiveType();
+        final String rustPrimitiveType = rustTypeName(primitiveType);
+        final int arrayLength = typeToken.arrayLength();
+
+        indent(sb, level, "/// primitive array field '%s' with zero padding\n", name);
+        generateRustDoc(sb, level, typeToken, encoding);
+        indent(sb, level, "#[inline]\n");
+        indent(sb, level, "pub fn %s_zero_padded(&mut self, value: &[%s]) {\n",
+            formatFunctionName(name), rustPrimitiveType);
+
+        indent(sb, level + 1, "let iter = value.iter().copied().chain(std::iter::repeat(0_%s)).take(%d);\n",
+            rustPrimitiveType, arrayLength);
+
+        indent(sb, level + 1, "self.%s_from_iter(iter);", formatFunctionName(name));
+        indent(sb, level, "}\n\n");
+    }
+
     private static void generatePrimitiveArrayEncoder(
         final StringBuilder sb,
         final int level,
@@ -394,6 +451,24 @@ private static void generatePrimitiveArrayEncoder(
         final String rustPrimitiveType = rustTypeName(primitiveType);
         final int arrayLength = typeToken.arrayLength();
 
+        indent(sb, level, "#[inline]\n");
+        indent(sb, level, "pub fn %s_at(&mut self, index: usize, value: %s) {\n",
+            formatFunctionName(name), rustPrimitiveType);
+        indent(sb, level + 1, "let offset = self.%s;\n", getBufOffset(typeToken));
+        indent(sb, level + 1, "let buf = self.get_buf_mut();\n");
+
+        if (primitiveType.size() == 1)
+        {
+            indent(sb, level + 1, "buf.put_%s_at(offset + index, value);\n",
+                rustPrimitiveType, primitiveType.size());
+        }
+        else
+        {
+            indent(sb, level + 1, "buf.put_%s_at(offset + index * %d, value);\n",
+                rustPrimitiveType, primitiveType.size());
+        }
+        indent(sb, level, "}\n\n");
+
         indent(sb, level, "/// primitive array field '%s'\n", name);
         generateRustDoc(sb, level, typeToken, encoding);
         indent(sb, level, "#[inline]\n");
@@ -407,11 +482,7 @@ private static void generatePrimitiveArrayEncoder(
 
         if (rustPrimitiveType.equals("u8"))
         {
-            indent(sb, level + 1, "let mid = %d.min(value.len());\n", arrayLength);
-            indent(sb, level + 1, "buf.put_slice_at(offset, value.split_at(mid).0);\n");
-            indent(sb, level + 1, "for i in mid..%d {\n", arrayLength);
-            indent(sb, level + 2, "buf.put_u8_at(offset + (i * 1), %s);\n", rustNullLiteral(encoding));
-            indent(sb, level + 1, "}\n");
+            indent(sb, level + 1, "buf.put_slice_at(offset, value);\n");
             indent(sb, level, "}\n\n");
         }
         else
@@ -434,22 +505,8 @@ private static void generatePrimitiveArrayEncoder(
             indent(sb, level, "}\n\n");
         }
 
-        indent(sb, level, "/// primitive array field '%s' from an Iterator\n", name);
-        generateRustDoc(sb, level, typeToken, encoding);
-        indent(sb, level, "#[inline]\n");
-        indent(sb, level, "pub fn %s_from_iter(&mut self, iter: impl Iterator<Item = %s>) {\n",
-            formatFunctionName(name), rustPrimitiveType);
-
-        indent(sb, level + 1, "let offset = self.%s;\n", getBufOffset(typeToken));
-        indent(sb, level + 1, "let buf = self.get_buf_mut();\n");
-        indent(sb, level + 1, "let iter = iter.chain(std::iter::repeat(%s)).take(%d);\n",
-            rustNullLiteral(encoding), arrayLength);
-
-        indent(sb, level + 1, "for (i, v) in iter.enumerate() {\n");
-        indent(sb, level + 2, "buf.put_%s_at(offset + (i * %d), v);\n",
-            rustPrimitiveType, primitiveType.size());
-        indent(sb, level + 1, "}\n");
-        indent(sb, level, "}\n\n");
+        generatePrimitiveArrayFromIterEncoder(sb, level, typeToken, name);
+        generatePrimitiveArrayZeroPaddedEncoder(sb, level, typeToken, name);
     }
 
     private static void generatePrimitiveEncoder(
@@ -485,7 +542,6 @@ private static void generatePrimitiveEncoder(
         indent(sb, level + 1, "let offset = self.%s;\n", getBufOffset(typeToken));
         indent(sb, level + 1, "self.get_buf_mut().put_%s_at(offset, value);\n", rustPrimitiveType);
         indent(sb, level, "}\n\n");
-
     }
 
     private static void generateEnumEncoder(