merging in PR

Author: Michael Ward

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);
+                encode_func(&mut encoder, each_slice.iter().map(|x| *x));
 
                 let end = 1i32;
                 end_encode_func(&mut encoder, end);
@@ -106,49 +106,49 @@ fn test_encode_then_decode_u8_slice() {
     }
 
     run_encode_then_decode_for_array_of_u8_len_16!(
-        DemoEncoder::fixed_16_char_at_most_16_items_from_slice,
+        DemoEncoder::fixed_16_char_from_iter,
         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_at_most_16_items_from_slice,
+        DemoEncoder::fixed_16_ascii_char_from_iter,
         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_at_most_16_items_from_slice,
+        DemoEncoder::fixed_16_gb_18030_char_from_iter,
         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_at_most_16_items_from_slice,
+        DemoEncoder::fixed_16_utf_8_char_from_iter,
         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_at_most_16_items_from_slice,
+        DemoEncoder::fixed_16_u8_from_iter,
         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_at_most_16_items_from_slice,
+        DemoEncoder::fixed_16_ascii_u8_from_iter,
         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_at_most_16_items_from_slice,
+        DemoEncoder::fixed_16_gb_18030_u8_from_iter,
         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_at_most_16_items_from_slice,
+        DemoEncoder::fixed_16_utf_8_u8_from_iter,
         DemoDecoder::fixed_16_utf_8_u8,
         DemoEncoder::fixed_16_utf_8u_8_end,
         DemoDecoder::fixed_16_utf_8u_8_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);
+                encode_func(&mut encoder, each_slice.iter().map(|x| *x));
 
                 let end = 1i32;
                 end_encode_func(&mut encoder, end);
@@ -333,28 +333,28 @@ fn test_encode_then_decode_non_u8_signed_primitive_slice() {
     }
 
     run_encode_then_decode_for_array_of_signed_len_16!(
-        DemoEncoder::fixed_16_i8_at_most_16_items_from_slice,
+        DemoEncoder::fixed_16_i8_from_iter,
         DemoDecoder::fixed_16_i8,
         DemoEncoder::fixed_16_i8_end,
         DemoDecoder::fixed_16_i8_end,
         i8, i8::from_le_bytes([uninit])
     );
     run_encode_then_decode_for_array_of_signed_len_16!(
-        DemoEncoder::fixed_16_i16_at_most_16_items_from_slice,
+        DemoEncoder::fixed_16_i16_from_iter,
         DemoDecoder::fixed_16_i16,
         DemoEncoder::fixed_16_i16_end,
         DemoDecoder::fixed_16_i16_end,
         i16, i16::from_le_bytes([uninit, uninit])
     );
     run_encode_then_decode_for_array_of_signed_len_16!(
-        DemoEncoder::fixed_16_i32_at_most_16_items_from_slice,
+        DemoEncoder::fixed_16_i32_from_iter,
         DemoDecoder::fixed_16_i32,
         DemoEncoder::fixed_16_i32_end,
         DemoDecoder::fixed_16_i32_end,
         i32, i32::from_le_bytes([uninit, uninit, uninit, uninit])
     );
     run_encode_then_decode_for_array_of_signed_len_16!(
-        DemoEncoder::fixed_16_i64_at_most_16_items_from_slice,
+        DemoEncoder::fixed_16_i64_from_iter,
         DemoDecoder::fixed_16_i64,
         DemoEncoder::fixed_16_i64_end,
         DemoDecoder::fixed_16_i64_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);
+                encode_func(&mut encoder, each_slice.iter().map(|x| *x));
 
                 let end = 1i32;
                 end_encode_func(&mut encoder, end);
@@ -539,23 +539,23 @@ fn test_encode_then_decode_non_u8_unsigned_primitive_slice() {
     }
 
     run_encode_then_decode_for_array_of_unsigned_len_16!(
-        DemoEncoder::fixed_16_u16_at_most_16_items_from_slice,
+        DemoEncoder::fixed_16_u16_from_iter,
         DemoDecoder::fixed_16_u16,
         DemoEncoder::fixed_16_u16_end,
         DemoDecoder::fixed_16_u16_end,
         u16,
         u16::from_le_bytes([uninit, uninit])
     );
     run_encode_then_decode_for_array_of_unsigned_len_16!(
-        DemoEncoder::fixed_16_u32_at_most_16_items_from_slice,
+        DemoEncoder::fixed_16_u32_from_iter,
         DemoDecoder::fixed_16_u32,
         DemoEncoder::fixed_16_u32_end,
         DemoDecoder::fixed_16_u32_end,
         u32,
         u32::from_le_bytes([uninit, uninit, uninit, uninit])
     );
     run_encode_then_decode_for_array_of_unsigned_len_16!(
-        DemoEncoder::fixed_16_u64_at_most_16_items_from_slice,
+        DemoEncoder::fixed_16_u64_from_iter,
         DemoDecoder::fixed_16_u64,
         DemoEncoder::fixed_16_u64_end,
         DemoDecoder::fixed_16_u64_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);
+                encode_func(&mut encoder, each_slice.iter().map(|x| *x));
 
                 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_at_most_16_items_from_slice_padded_with_zero,
+        DemoEncoder::fixed_16_char_from_iter,
         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_at_most_16_items_from_slice_padded_with_zero,
+        DemoEncoder::fixed_16_ascii_char_from_iter,
         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_at_most_16_items_from_slice_padded_with_zero,
+        DemoEncoder::fixed_16_gb_18030_char_from_iter,
         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_at_most_16_items_from_slice_padded_with_zero,
+        DemoEncoder::fixed_16_utf_8_char_from_iter,
         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_at_most_16_items_from_slice_padded_with_zero,
+        DemoEncoder::fixed_16_u8_from_iter,
         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_at_most_16_items_from_slice_padded_with_zero,
+        DemoEncoder::fixed_16_ascii_u8_from_iter,
         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_at_most_16_items_from_slice_padded_with_zero,
+        DemoEncoder::fixed_16_gb_18030_u8_from_iter,
         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_at_most_16_items_from_slice_padded_with_zero,
+        DemoEncoder::fixed_16_utf_8_u8_from_iter,
         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);
+                encode_func(&mut encoder, each_slice.iter().map(|x| *x));
 
                 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_at_most_16_items_from_slice_padded_with_zero,
+        DemoEncoder::fixed_16_i8_from_iter,
         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_at_most_16_items_from_slice_padded_with_zero,
+        DemoEncoder::fixed_16_i16_from_iter,
         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_at_most_16_items_from_slice_padded_with_zero,
+        DemoEncoder::fixed_16_i32_from_iter,
         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_at_most_16_items_from_slice_padded_with_zero,
+        DemoEncoder::fixed_16_i64_from_iter,
         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);
+                encode_func(&mut encoder, each_slice.iter().map(|x| *x));
 
                 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_at_most_16_items_from_slice_padded_with_zero,
+        DemoEncoder::fixed_16_u16_from_iter,
         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_at_most_16_items_from_slice_padded_with_zero,
+        DemoEncoder::fixed_16_u32_from_iter,
         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_at_most_16_items_from_slice_padded_with_zero,
+        DemoEncoder::fixed_16_u64_from_iter,
         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

@@ -361,6 +361,12 @@ static void generateEncoderVarData(
         }
     }
 
+    private static String rustNullLiteral(final Encoding encoding)
+    {
+        return generateRustLiteral(encoding.primitiveType(), encoding.applicableNullValue());
+    }
+
+
     private static void generateRustDoc(
         final StringBuilder sb,
         final int level,
@@ -369,7 +375,7 @@ private static void generateRustDoc(
     {
         indent(sb, level, "/// - min value: %s\n", encoding.applicableMinValue());
         indent(sb, level, "/// - max value: %s\n", encoding.applicableMaxValue());
-        indent(sb, level, "/// - null value: %s\n", encoding.applicableNullValue());
+        indent(sb, level, "/// - null value: %s\n", rustNullLiteral(encoding));
         indent(sb, level, "/// - characterEncoding: %s\n", encoding.characterEncoding());
         indent(sb, level, "/// - semanticType: %s\n", encoding.semanticType());
         indent(sb, level, "/// - encodedOffset: %d\n", typeToken.offset());
@@ -404,7 +410,7 @@ private static void generatePrimitiveArrayEncoder(
             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_u8);\n", encoding.applicableNullValue());
+            indent(sb, level + 2, "buf.put_u8_at(offset + (i * 1), %s);\n", rustNullLiteral(encoding));
             indent(sb, level + 1, "}\n");
             indent(sb, level, "}\n\n");
         }
@@ -436,8 +442,8 @@ private static void generatePrimitiveArrayEncoder(
 
         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_%s)).take(%d);\n",
-            encoding.applicableNullValue(), rustPrimitiveType, arrayLength);
+        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",
@@ -715,7 +721,7 @@ private static void generatePrimitiveArrayDecoder(
         if (fieldToken.version() > 0)
         {
             indent(sb, level + 1, "if self.acting_version() < %d {\n", fieldToken.version());
-            indent(sb, level + 2, "return [%s; %d];\n", encoding.applicableNullValue(), arrayLength);
+            indent(sb, level + 2, "return [%s; %d];\n", rustNullLiteral(encoding), arrayLength);
             indent(sb, level + 1, "}\n\n");
         }
 
@@ -808,7 +814,7 @@ private static void generatePrimitiveOptionalDecoder(
         final String rustPrimitiveType = rustTypeName(primitiveType);
         final String characterEncoding = encoding.characterEncoding();
         indent(sb, level, "/// primitive field - '%s' { null_value: '%s' }\n",
-            encoding.presence(), encoding.applicableNullValue());
+            encoding.presence(), rustNullLiteral(encoding));
 
         if (characterEncoding != null)
         {
@@ -825,14 +831,14 @@ private static void generatePrimitiveOptionalDecoder(
             rustPrimitiveType,
             getBufOffset(fieldToken));
 
-        final String literal = generateRustLiteral(primitiveType, encoding.applicableNullValue().toString());
-        if (literal.endsWith("::NAN"))
+        final String nullLiteral = rustNullLiteral(encoding);
+        if (nullLiteral.endsWith("::NAN"))
         {
             indent(sb, level + 1, "if value.is_nan() {\n");
         }
         else
         {
-            indent(sb, level + 1, "if value == %s {\n", literal);
+            indent(sb, level + 1, "if value == %s {\n", nullLiteral);
         }
 
         indent(sb, level + 2, "None\n");
@@ -869,8 +875,7 @@ private static void generatePrimitiveRequiredDecoder(
         if (fieldToken.version() > 0)
         {
             indent(sb, level + 1, "if self.acting_version() < %d {\n", fieldToken.version());
-            indent(sb, level + 2, "return %s;\n",
-                generateRustLiteral(encoding.primitiveType(), encoding.applicableNullValue().toString()));
+            indent(sb, level + 2, "return %s;\n", rustNullLiteral(encoding));
             indent(sb, level + 1, "}\n\n");
         }
 
@@ -1293,8 +1298,7 @@ private static void generateEnum(
         // null value
         {
             final Encoding encoding = messageBody.get(0).encoding();
-            final CharSequence nullVal = generateRustLiteral(encoding.primitiveType(),
-                encoding.applicableNullValue().toString());
+            final CharSequence nullVal = rustNullLiteral(encoding);
             indent(writer, 1, "#[default]\n");
             indent(writer, 1, "NullVal = %s, \n", nullVal);
         }
@@ -1358,8 +1362,7 @@ private static void generateFromEnumForPrimitive(
 
         {
             final Encoding encoding = messageBody.get(0).encoding();
-            final CharSequence nullVal = generateRustLiteral(encoding.primitiveType(),
-                encoding.applicableNullValue().toString());
+            final CharSequence nullVal = rustNullLiteral(encoding);
             indent(writer, 3, "%s::NullVal => %s,\n", enumRustName, nullVal);
         }
         indent(writer, 2, "}\n");