From ded0bcad8f2046af72c0767247e64ef280489c26 Mon Sep 17 00:00:00 2001 From: Michael Ward Date: Tue, 17 Dec 2024 08:43:33 -0600 Subject: [PATCH 01/12] [Rust] codegen now implements: "From<&'a mut WriteBuf<'a>> for &'a mut [u8]" --- .../uk/co/real_logic/sbe/generation/rust/LibRsDef.java | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/LibRsDef.java b/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/LibRsDef.java index ae50c9bef7..3eed55b034 100644 --- a/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/LibRsDef.java +++ b/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/LibRsDef.java @@ -277,6 +277,13 @@ static void generateWriteBuf(final Writer writer, final ByteOrder byteOrder) thr indent(writer, 2, "len\n"); indent(writer, 1, "}\n"); + indent(writer, 0, "}\n"); + + indent(writer, 0, "impl<%s> From<&%1$s mut %2$s<%1$s>> for &%1$s mut [u8] {\n", BUF_LIFETIME, WRITE_BUF_TYPE); + indent(writer, 1, "#[inline]\n"); + indent(writer, 1, "fn from(buf: &%s mut %2$s<%1$s>) -> &%1$s mut [u8] {\n", BUF_LIFETIME, WRITE_BUF_TYPE); + indent(writer, 2, "buf.data\n"); + indent(writer, 1, "}\n"); indent(writer, 0, "}\n\n"); } } From e18556b5498e70e7e98bebee0c23d6b62ee943c7 Mon Sep 17 00:00:00 2001 From: Michael Ward Date: Wed, 18 Dec 2024 07:06:41 -0600 Subject: [PATCH 02/12] [Rust] refactored codegen of primitive array encoding to accept slice instead of array --- .../co/real_logic/sbe/generation/rust/LibRsDef.java | 2 +- .../real_logic/sbe/generation/rust/RustGenerator.java | 11 +++++++---- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/LibRsDef.java b/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/LibRsDef.java index 3eed55b034..39a5ed633c 100644 --- a/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/LibRsDef.java +++ b/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/LibRsDef.java @@ -276,9 +276,9 @@ static void generateWriteBuf(final Writer writer, final ByteOrder byteOrder) thr indent(writer, 2, "dest.clone_from_slice(src);\n"); indent(writer, 2, "len\n"); indent(writer, 1, "}\n"); - indent(writer, 0, "}\n"); + // impl From for &[u8] indent(writer, 0, "impl<%s> From<&%1$s mut %2$s<%1$s>> for &%1$s mut [u8] {\n", BUF_LIFETIME, WRITE_BUF_TYPE); indent(writer, 1, "#[inline]\n"); indent(writer, 1, "fn from(buf: &%s mut %2$s<%1$s>) -> &%1$s mut [u8] {\n", BUF_LIFETIME, WRITE_BUF_TYPE); diff --git a/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/RustGenerator.java b/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/RustGenerator.java index f78899cb4b..3706cb8c64 100644 --- a/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/RustGenerator.java +++ b/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/RustGenerator.java @@ -383,10 +383,9 @@ private static void generatePrimitiveEncoder( indent(sb, level, "/// - encodedLength: %d\n", typeToken.encodedLength()); indent(sb, level, "/// - version: %d\n", typeToken.version()); indent(sb, level, "#[inline]\n"); - indent(sb, level, "pub fn %s(&mut self, value: &[%s; %d]) {\n", + indent(sb, level, "pub fn %s(&mut self, value: &[%s]) {\n", formatFunctionName(name), - rustPrimitiveType, - arrayLength); + rustPrimitiveType); // NB: must create variable 'offset' before calling mutable self.get_buf_mut() indent(sb, level + 1, "let offset = self.%s;\n", getBufOffset(typeToken)); @@ -394,7 +393,11 @@ private static void generatePrimitiveEncoder( if (rustPrimitiveType.equals("u8")) { - indent(sb, level + 1, "buf.put_bytes_at(offset, value);\n"); + 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 + 1, "}\n"); indent(sb, level, "}\n\n"); return; } From 8684ba470f44d352d69642746ac74b5fc10727c1 Mon Sep 17 00:00:00 2001 From: Michael Ward Date: Wed, 18 Dec 2024 07:20:33 -0600 Subject: [PATCH 03/12] [Rust] updated some tests --- rust/tests/baseline_enum_from_str.rs | 21 +++++++++++---------- rust/tests/extension_test.rs | 4 ++-- 2 files changed, 13 insertions(+), 12 deletions(-) diff --git a/rust/tests/baseline_enum_from_str.rs b/rust/tests/baseline_enum_from_str.rs index 4e52fd4bf9..a111d28364 100644 --- a/rust/tests/baseline_enum_from_str.rs +++ b/rust/tests/baseline_enum_from_str.rs @@ -1,21 +1,22 @@ +use BoostType::{NullVal, KERS, NITROUS, SUPERCHARGER, TURBO}; use examples_baseline::{ boost_type::BoostType, }; #[test] fn test_boost_type_from_str() -> Result<(), ()> { - assert_eq!("TURBO".parse::()?, BoostType::TURBO, "Parse \"TURBO\" as BoostType"); - assert_eq!("SUPERCHARGER".parse::()?, BoostType::SUPERCHARGER, "Parse \"SUPERCHARGER\" as BoostType"); - assert_eq!("NITROUS".parse::()?, BoostType::NITROUS, "Parse \"NITROUS\" as BoostType"); - assert_eq!("KERS".parse::()?, BoostType::KERS, "Parse \"KERS\" as BoostType"); + assert_eq!("TURBO".parse::()?, TURBO, "Parse \"TURBO\" as BoostType"); + assert_eq!("SUPERCHARGER".parse::()?, SUPERCHARGER, "Parse \"SUPERCHARGER\" as BoostType"); + assert_eq!("NITROUS".parse::()?, NITROUS, "Parse \"NITROUS\" as BoostType"); + assert_eq!("KERS".parse::()?, KERS, "Parse \"KERS\" as BoostType"); - assert_eq!("Turbo".parse::()?, BoostType::NullVal, "Parse \"Turbo\" as BoostType"); - assert_eq!("Supercharger".parse::()?, BoostType::NullVal, "Parse \"Supercharger\" as BoostType"); - assert_eq!("Nitrous".parse::()?, BoostType::NullVal, "Parse \"Nitrous\" as BoostType"); - assert_eq!("Kers".parse::()?, BoostType::NullVal, "Parse \"Kers\" as BoostType"); + assert_eq!("Turbo".parse::()?, NullVal, "Parse \"Turbo\" as BoostType"); + assert_eq!("Supercharger".parse::()?, NullVal, "Parse \"Supercharger\" as BoostType"); + assert_eq!("Nitrous".parse::()?, NullVal, "Parse \"Nitrous\" as BoostType"); + assert_eq!("Kers".parse::()?, NullVal, "Parse \"Kers\" as BoostType"); - assert_eq!("AA".parse::()?, BoostType::NullVal, "Parse \"AA\" as BoostType"); - assert_eq!("".parse::().unwrap(), BoostType::NullVal, "Parse \"\" as BoostType"); + assert_eq!("AA".parse::()?, NullVal, "Parse \"AA\" as BoostType"); + assert_eq!("".parse::().unwrap(), NullVal, "Parse \"\" as BoostType"); Ok(()) } diff --git a/rust/tests/extension_test.rs b/rust/tests/extension_test.rs index d7258bc39b..ef91354999 100644 --- a/rust/tests/extension_test.rs +++ b/rust/tests/extension_test.rs @@ -187,7 +187,7 @@ fn encode_car_from_scratch() -> SbeResult<(usize, Vec)> { car.available(BooleanType::T); car.code(Model::A); car.some_numbers(&[0, 1, 2, 3]); - car.vehicle_code(&[97, 98, 99, 100, 101, 102]); // abcdef + car.vehicle_code(b"abcdef_extra_is_ignored"); // abcdef extras.set_cruise_control(true); extras.set_sports_pack(true); @@ -197,7 +197,7 @@ fn encode_car_from_scratch() -> SbeResult<(usize, Vec)> { let mut engine = car.engine_encoder(); engine.capacity(2000); engine.num_cylinders(4); - engine.manufacturer_code(&[49, 50, 51]); // 123 + engine.manufacturer_code(b"123"); engine.efficiency(35); engine.booster_enabled(BooleanType::T); let mut booster = engine.booster_encoder(); From abdd406d420da25ae7b5f2445627e3872bde2749 Mon Sep 17 00:00:00 2001 From: Michael Ward Date: Wed, 18 Dec 2024 23:15:16 -0600 Subject: [PATCH 04/12] [Rust] updated codegen to create additional function for primitive arrays that will accept an "impl Iterator". This allows an arbitrary number of items to be passed in, which will guarantee the correct number of items are encoded (defined 'nullValue' will be used where appropriate) --- rust/tests/extension_test.rs | 2 +- .../sbe/generation/rust/RustGenerator.java | 143 +++++++++++------- 2 files changed, 89 insertions(+), 56 deletions(-) diff --git a/rust/tests/extension_test.rs b/rust/tests/extension_test.rs index ef91354999..2de897272f 100644 --- a/rust/tests/extension_test.rs +++ b/rust/tests/extension_test.rs @@ -187,7 +187,7 @@ fn encode_car_from_scratch() -> SbeResult<(usize, Vec)> { car.available(BooleanType::T); car.code(Model::A); car.some_numbers(&[0, 1, 2, 3]); - car.vehicle_code(b"abcdef_extra_is_ignored"); // abcdef + car.vehicle_code_from_iter(b"abcdef_extra_is_ignored".iter().map(|x| *x)); // abcdef extras.set_cruise_control(true); extras.set_sports_pack(true); diff --git a/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/RustGenerator.java b/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/RustGenerator.java index 3706cb8c64..b06f5b1dd1 100644 --- a/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/RustGenerator.java +++ b/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/RustGenerator.java @@ -361,7 +361,23 @@ static void generateEncoderVarData( } } - private static void generatePrimitiveEncoder( + private static void generateRustDoc( + final StringBuilder sb, + final int level, + final Token typeToken, + final Encoding encoding) throws IOException + { + 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, "/// - characterEncoding: %s\n", encoding.characterEncoding()); + indent(sb, level, "/// - semanticType: %s\n", encoding.semanticType()); + indent(sb, level, "/// - encodedOffset: %d\n", typeToken.offset()); + indent(sb, level, "/// - encodedLength: %d\n", typeToken.encodedLength()); + indent(sb, level, "/// - version: %d\n", typeToken.version()); + } + + private static void generatePrimitiveArrayEncoder( final StringBuilder sb, final int level, final Token typeToken, @@ -371,37 +387,29 @@ private static void generatePrimitiveEncoder( final PrimitiveType primitiveType = encoding.primitiveType(); final String rustPrimitiveType = rustTypeName(primitiveType); final int arrayLength = typeToken.arrayLength(); - if (arrayLength > 1) - { - indent(sb, level, "/// primitive array field '%s'\n", name); - 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, "/// - characterEncoding: %s\n", encoding.characterEncoding()); - indent(sb, level, "/// - semanticType: %s\n", encoding.semanticType()); - indent(sb, level, "/// - encodedOffset: %d\n", typeToken.offset()); - indent(sb, level, "/// - encodedLength: %d\n", typeToken.encodedLength()); - indent(sb, level, "/// - version: %d\n", typeToken.version()); - indent(sb, level, "#[inline]\n"); - indent(sb, level, "pub fn %s(&mut self, value: &[%s]) {\n", - formatFunctionName(name), - rustPrimitiveType); - // NB: must create variable 'offset' before calling mutable self.get_buf_mut() - 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, "/// primitive array field '%s'\n", name); + generateRustDoc(sb, level, typeToken, encoding); + indent(sb, level, "#[inline]\n"); + indent(sb, level, "pub fn %s(&mut self, value: &[%s]) {\n", + formatFunctionName(name), rustPrimitiveType); - 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_u8);\n", encoding.applicableNullValue()); - indent(sb, level + 1, "}\n"); - indent(sb, level, "}\n\n"); - return; - } + // NB: must create variable 'offset' before calling mutable self.get_buf_mut() + indent(sb, level + 1, "debug_assert_eq!(%d, value.len());\n", arrayLength); + indent(sb, level + 1, "let offset = self.%s;\n", getBufOffset(typeToken)); + indent(sb, level + 1, "let buf = self.get_buf_mut();\n"); + 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_u8);\n", encoding.applicableNullValue()); + indent(sb, level + 1, "}\n"); + indent(sb, level, "}\n\n"); + } + else + { for (int i = 0; i < arrayLength; i++) { if (i == 0) @@ -419,34 +427,59 @@ private static void generatePrimitiveEncoder( indent(sb, level, "}\n\n"); } - else + + 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) {\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_%s)).take(%d);\n", + encoding.applicableNullValue(), rustPrimitiveType, 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"); + } + + private static void generatePrimitiveEncoder( + final StringBuilder sb, + final int level, + final Token typeToken, + final String name) throws IOException + { + final int arrayLength = typeToken.arrayLength(); + if (arrayLength > 1) { - if (encoding.presence() == Encoding.Presence.CONSTANT) - { - indent(sb, level, "// skipping CONSTANT %s\n\n", name); - } - else - { - indent(sb, level, "/// primitive field '%s'\n", name); - 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, "/// - characterEncoding: %s\n", encoding.characterEncoding()); - indent(sb, level, "/// - semanticType: %s\n", encoding.semanticType()); - indent(sb, level, "/// - encodedOffset: %d\n", typeToken.offset()); - indent(sb, level, "/// - encodedLength: %d\n", typeToken.encodedLength()); - indent(sb, level, "/// - version: %d\n", typeToken.version()); - indent(sb, level, "#[inline]\n"); - indent(sb, level, "pub fn %s(&mut self, value: %s) {\n", - formatFunctionName(name), - rustPrimitiveType); - - // NB: must create variable 'offset' before calling mutable self.get_buf_mut() - 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"); - } + generatePrimitiveArrayEncoder(sb, level, typeToken, name); + return; + } + + final Encoding encoding = typeToken.encoding(); + if (encoding.presence() == Encoding.Presence.CONSTANT) + { + indent(sb, level, "// skipping CONSTANT %s\n\n", name); + return; } + + final PrimitiveType primitiveType = encoding.primitiveType(); + final String rustPrimitiveType = rustTypeName(primitiveType); + + indent(sb, level, "/// primitive field '%s'\n", name); + generateRustDoc(sb, level, typeToken, encoding); + indent(sb, level, "#[inline]\n"); + indent(sb, level, "pub fn %s(&mut self, value: %s) {\n", + formatFunctionName(name), rustPrimitiveType); + + // NB: must create variable 'offset' before calling mutable self.get_buf_mut() + 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( From 97ba5382c4ef33d474fb26789c55e9bdc1f8cbc5 Mon Sep 17 00:00:00 2001 From: Elvis Wang Date: Fri, 15 Nov 2024 16:37:18 +0800 Subject: [PATCH 05/12] [Rust] generate at_most_*_items_from_slice setter for fixed sized primitive array in message --- build.gradle | 1 + rust/Cargo.toml | 1 + rust/tests/fixed_sized_primitive_array.rs | 511 ++++++++++++++++++ .../fixed-sized-primitive-array-types.xml | 58 ++ 4 files changed, 571 insertions(+) create mode 100644 rust/tests/fixed_sized_primitive_array.rs create mode 100644 sbe-tool/src/test/resources/fixed-sized-primitive-array-types.xml diff --git a/build.gradle b/build.gradle index 6a20ee7201..59a1f41042 100644 --- a/build.gradle +++ b/build.gradle @@ -654,6 +654,7 @@ tasks.register('generateRustTestCodecs', JavaExec) { 'sbe-tool/src/test/resources/issue984.xml', 'sbe-tool/src/test/resources/issue987.xml', 'sbe-tool/src/test/resources/issue1028.xml', + 'sbe-tool/src/test/resources/fixed-sized-primitive-array-types.xml', 'sbe-tool/src/test/resources/example-bigendian-test-schema.xml', 'sbe-tool/src/test/resources/nested-composite-name.xml', ] diff --git a/rust/Cargo.toml b/rust/Cargo.toml index f15d4d2f6d..2d4f3d4a49 100644 --- a/rust/Cargo.toml +++ b/rust/Cargo.toml @@ -19,6 +19,7 @@ issue_987 = { path = "../generated/rust/issue987" } issue_1028 = { path = "../generated/rust/issue1028" } baseline_bigendian = { path = "../generated/rust/baseline-bigendian" } nested_composite_name = { path = "../generated/rust/nested-composite-name" } +fixed_sized_primitive_array = { path = "../generated/rust/fixed_sized_primitive_array" } [dev-dependencies] criterion = "0.5" diff --git a/rust/tests/fixed_sized_primitive_array.rs b/rust/tests/fixed_sized_primitive_array.rs new file mode 100644 index 0000000000..dd5380e641 --- /dev/null +++ b/rust/tests/fixed_sized_primitive_array.rs @@ -0,0 +1,511 @@ +use fixed_sized_primitive_array::{ + demo_codec::{DemoDecoder, DemoEncoder}, + message_header_codec::{MessageHeaderDecoder, ENCODED_LENGTH}, + ReadBuf, WriteBuf, +}; + +fn create_encoder(buffer: &mut Vec) -> DemoEncoder { + let encoder = DemoEncoder::default().wrap(WriteBuf::new(buffer.as_mut_slice()), ENCODED_LENGTH); + let mut header = encoder.header(0); + header.parent().unwrap() +} + +#[test] +fn test_encode_then_decode_u8_slice() { + let test_data = [ + b"" as &[u8], + b"0" as &[u8], + b"01" as &[u8], + b"012" as &[u8], + b"0123" as &[u8], + b"01234" as &[u8], + b"012345" as &[u8], + b"0123456" as &[u8], + b"01234567" as &[u8], + b"012345678" as &[u8], + b"0123456789" as &[u8], + b"0123456789A" as &[u8], + b"0123456789AB" as &[u8], + b"0123456789ABC" as &[u8], + b"0123456789ABCD" as &[u8], + b"0123456789ABCDE" as &[u8], + b"0123456789ABCDEF" as &[u8], + b"0123456789abcdef" as &[u8], + b"0123456789abcdef0" as &[u8], + b"0123456789abcdef01" as &[u8], + b"0123456789abcdef012" as &[u8], + b"0123456789abcdef0123" as &[u8], + b"0123456789abcdef01234" as &[u8], + b"0123456789abcdef012345" as &[u8], + b"0123456789abcdef0123456" as &[u8], + b"0123456789abcdef01234567" as &[u8], + b"0123456789abcdef012345678" as &[u8], + b"0123456789abcdef0123456789" as &[u8], + b"0123456789abcdef0123456789A" as &[u8], + b"0123456789abcdef0123456789AB" as &[u8], + b"0123456789abcdef0123456789ABC" as &[u8], + b"0123456789abcdef0123456789ABCD" as &[u8], + b"0123456789abcdef0123456789ABCDE" as &[u8], + b"0123456789abcdef0123456789ABCDEF" as &[u8], + ]; + + // + // + // + // + // + // + // + // + macro_rules! run_encode_then_decode_for_array_of_u8_len_16 { + ($encode_func:expr, $decode_func:expr, $i_null:expr) => { + for each_slice in test_data { + let encode_func = $encode_func; + let decode_func = $decode_func; + + let cur_len = each_slice.len(); + let effective_len = cur_len.min(16); + + // encode... + let mut buffer = vec![1u8; 1024]; + let mut encoder = create_encoder(&mut buffer); + + encode_func(&mut encoder, each_slice); + + // decode... + let buf = ReadBuf::new(buffer.as_slice()); + let header = MessageHeaderDecoder::default().wrap(buf, 0); + + let decoder = DemoDecoder::default().header(header, 0); + let decoded = decode_func(&decoder); + for each_idx in 0..effective_len { + assert_eq!( + each_slice[each_idx], decoded[each_idx], + "Item mismatched at {}/{}", + each_idx, cur_len + ); + } + let null_value = $i_null; + for each_idx in effective_len..16 { + assert_eq!( + decoded[each_idx], null_value, + "Item should be NULL at {}/{}", + each_idx, cur_len + ); + } + } + }; + } + + run_encode_then_decode_for_array_of_u8_len_16!( + DemoEncoder::fixed_16_char_at_most_16_items_from_slice, + DemoDecoder::fixed_16_char, + 0 + ); + run_encode_then_decode_for_array_of_u8_len_16!( + DemoEncoder::fixed_16_ascii_char_at_most_16_items_from_slice, + DemoDecoder::fixed_16_ascii_char, + 0 + ); + run_encode_then_decode_for_array_of_u8_len_16!( + DemoEncoder::fixed_16_gb_18030_char_at_most_16_items_from_slice, + DemoDecoder::fixed_16_gb_18030_char, + 0 + ); + run_encode_then_decode_for_array_of_u8_len_16!( + DemoEncoder::fixed_16_utf_8_char_at_most_16_items_from_slice, + DemoDecoder::fixed_16_utf_8_char, + 0 + ); + run_encode_then_decode_for_array_of_u8_len_16!( + DemoEncoder::fixed_16_u8_at_most_16_items_from_slice, + DemoDecoder::fixed_16_u8, + u8::MAX + ); + run_encode_then_decode_for_array_of_u8_len_16!( + DemoEncoder::fixed_16_ascii_u8_at_most_16_items_from_slice, + DemoDecoder::fixed_16_ascii_u8, + u8::MAX + ); + run_encode_then_decode_for_array_of_u8_len_16!( + DemoEncoder::fixed_16_gb_18030_u8_at_most_16_items_from_slice, + DemoDecoder::fixed_16_gb_18030_u8, + u8::MAX + ); + run_encode_then_decode_for_array_of_u8_len_16!( + DemoEncoder::fixed_16_utf_8_u8_at_most_16_items_from_slice, + DemoDecoder::fixed_16_utf_8_u8, + u8::MAX + ); +} + +#[test] +fn test_encode_then_decode_non_u8_signed_primitive_slice() { + // + // + // + // + macro_rules! run_encode_then_decode_for_array_of_u8_len_16 { + ($encode_func:expr, $decode_func:expr, $i_type:ty, $i_null:expr) => { + let test_data = [ + &[] as &[$i_type], + &[1 as $i_type] as &[$i_type], + &[0 as $i_type] as &[$i_type], + &[-1 as $i_type] as &[$i_type], + &[-1, 1 as $i_type] as &[$i_type], + &[-1, 0, 1 as $i_type] as &[$i_type], + &[-2, -1, 1, 2 as $i_type] as &[$i_type], + &[-2, -1, 0, 1, 2 as $i_type] as &[$i_type], + &[-3, -2, -1, 1, 2, 3 as $i_type] as &[$i_type], + &[-3, -2, -1, 0, 1, 2, 3 as $i_type] as &[$i_type], + &[-4, -3, -2, -1, 1, 2, 3, 4 as $i_type] as &[$i_type], + &[-4, -3, -2, -1, 0, 1, 2, 3, 4 as $i_type] as &[$i_type], + &[-5, -4, -3, -2, -1, 1, 2, 3, 4, 5 as $i_type] as &[$i_type], + &[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5 as $i_type] as &[$i_type], + &[-6, -5, -4, -3, -2, -1, 1, 2, 3, 4, 5, 6 as $i_type] as &[$i_type], + &[-6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6 as $i_type] as &[$i_type], + &[-7, -6, -5, -4, -3, -2, -1, 1, 2, 3, 4, 5, 6, 7 as $i_type] as &[$i_type], + &[ + -7, + -6, + -5, + -4, + -3, + -2, + -1, + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 as $i_type, + ] as &[$i_type], + &[ + -8, + -7, + -6, + -5, + -4, + -3, + -2, + -1, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 as $i_type, + ] as &[$i_type], + &[ + -8, + -7, + -6, + -5, + -4, + -3, + -2, + -1, + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 as $i_type, + ] as &[$i_type], + &[ + -9, + -8, + -7, + -6, + -5, + -4, + -3, + -2, + -1, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 as $i_type, + ] as &[$i_type], + &[ + -9, + -8, + -7, + -6, + -5, + -4, + -3, + -2, + -1, + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 as $i_type, + ] as &[$i_type], + ]; + for each_slice in test_data { + let encode_func = $encode_func; + let decode_func = $decode_func; + + let cur_len = each_slice.len(); + let effective_len = cur_len.min(16); + + // encode... + let mut buffer = vec![1u8; 1024]; + let mut encoder = create_encoder(&mut buffer); + + encode_func(&mut encoder, &each_slice); + + // decode... + let buf = ReadBuf::new(buffer.as_slice()); + let header = MessageHeaderDecoder::default().wrap(buf, 0); + + let decoder = DemoDecoder::default().header(header, 0); + let decoded = decode_func(&decoder); + for each_idx in 0..effective_len { + assert_eq!( + each_slice[each_idx], + decoded[each_idx], + "Item mismatched at {}/{} for {}", + each_idx, + cur_len, + stringify!($i_type) + ); + } + let null_value = $i_null; + for each_idx in effective_len..16 { + assert_eq!( + decoded[each_idx], + null_value, + "Item should be null at {}/{} for {}", + each_idx, + cur_len, + stringify!($i_type) + ); + } + } + }; + } + + run_encode_then_decode_for_array_of_u8_len_16!( + DemoEncoder::fixed_16_i8_at_most_16_items_from_slice, + DemoDecoder::fixed_16_i8, + i8, + i8::MIN + ); + run_encode_then_decode_for_array_of_u8_len_16!( + DemoEncoder::fixed_16_i16_at_most_16_items_from_slice, + DemoDecoder::fixed_16_i16, + i16, + i16::MIN + ); + run_encode_then_decode_for_array_of_u8_len_16!( + DemoEncoder::fixed_16_i32_at_most_16_items_from_slice, + DemoDecoder::fixed_16_i32, + i32, + i32::MIN + ); + run_encode_then_decode_for_array_of_u8_len_16!( + DemoEncoder::fixed_16_i64_at_most_16_items_from_slice, + DemoDecoder::fixed_16_i64, + i64, + i64::MIN + ); +} + +#[test] +fn test_encode_then_decode_non_u8_unsigned_primitive_slice() { + // + // + macro_rules! run_encode_then_decode_for_array_of_u8_len_16 { + ($encode_func:expr, $decode_func:expr, $i_type:ty, $i_null:expr) => { + let test_data = [ + &[] as &[$i_type], + &[1 as $i_type] as &[$i_type], + &[0 as $i_type] as &[$i_type], + &[11 as $i_type] as &[$i_type], + &[11, 1 as $i_type] as &[$i_type], + &[11, 0, 1 as $i_type] as &[$i_type], + &[12, 11, 1, 2 as $i_type] as &[$i_type], + &[12, 11, 0, 1, 2 as $i_type] as &[$i_type], + &[13, 12, 11, 1, 2, 3 as $i_type] as &[$i_type], + &[13, 12, 11, 0, 1, 2, 3 as $i_type] as &[$i_type], + &[14, 13, 12, 11, 1, 2, 3, 4 as $i_type] as &[$i_type], + &[14, 13, 12, 11, 0, 1, 2, 3, 4 as $i_type] as &[$i_type], + &[15, 14, 13, 12, 11, 1, 2, 3, 4, 5 as $i_type] as &[$i_type], + &[15, 14, 13, 12, 11, 0, 1, 2, 3, 4, 5 as $i_type] as &[$i_type], + &[16, 15, 14, 13, 12, 11, 1, 2, 3, 4, 5, 6 as $i_type] as &[$i_type], + &[16, 15, 14, 13, 12, 11, 0, 1, 2, 3, 4, 5, 6 as $i_type] as &[$i_type], + &[17, 16, 15, 14, 13, 12, 11, 1, 2, 3, 4, 5, 6, 7 as $i_type] as &[$i_type], + &[ + 17, + 16, + 15, + 14, + 13, + 12, + 11, + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 as $i_type, + ] as &[$i_type], + &[ + 18, + 17, + 16, + 15, + 14, + 13, + 12, + 11, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 as $i_type, + ] as &[$i_type], + &[ + 18, + 17, + 16, + 15, + 14, + 13, + 12, + 11, + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 as $i_type, + ] as &[$i_type], + &[ + 19, + 18, + 17, + 16, + 15, + 14, + 13, + 12, + 11, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 as $i_type, + ] as &[$i_type], + &[ + 19, + 18, + 17, + 16, + 15, + 14, + 13, + 12, + 11, + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 as $i_type, + ] as &[$i_type], + ]; + for each_slice in test_data { + let encode_func = $encode_func; + let decode_func = $decode_func; + + let cur_len = each_slice.len(); + let effective_len = cur_len.min(16); + + // encode... + let mut buffer = vec![1u8; 1024]; + let mut encoder = create_encoder(&mut buffer); + + encode_func(&mut encoder, &each_slice); + + // decode... + let buf = ReadBuf::new(buffer.as_slice()); + let header = MessageHeaderDecoder::default().wrap(buf, 0); + + let decoder = DemoDecoder::default().header(header, 0); + let decoded = decode_func(&decoder); + for each_idx in 0..effective_len { + assert_eq!( + each_slice[each_idx], + decoded[each_idx], + "Item mismatched at {}/{} for {}", + each_idx, + cur_len, + stringify!($i_type) + ); + } + let null_value = $i_null; + for each_idx in effective_len..16 { + assert_eq!( + decoded[each_idx], + null_value, + "Item should be null at {}/{} for {}", + each_idx, + cur_len, + stringify!($i_type) + ); + } + } + }; + } + + run_encode_then_decode_for_array_of_u8_len_16!( + DemoEncoder::fixed_16_u16_at_most_16_items_from_slice, + DemoDecoder::fixed_16_u16, + u16, + u16::MAX + ); + run_encode_then_decode_for_array_of_u8_len_16!( + DemoEncoder::fixed_16_u32_at_most_16_items_from_slice, + DemoDecoder::fixed_16_u32, + u32, + u32::MAX + ); + // run_encode_then_decode_for_array_of_u8_len_16!(DemoEncoder::fixed_16_u64_at_most_16_items_from_slice, DemoDecoder::fixed_16_i64, i64, u64::MAX); +} diff --git a/sbe-tool/src/test/resources/fixed-sized-primitive-array-types.xml b/sbe-tool/src/test/resources/fixed-sized-primitive-array-types.xml new file mode 100644 index 0000000000..719715d6b5 --- /dev/null +++ b/sbe-tool/src/test/resources/fixed-sized-primitive-array-types.xml @@ -0,0 +1,58 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + From 1b89155564e3e51b0850eb6b81795d2238afa5f7 Mon Sep 17 00:00:00 2001 From: Elvis Wang Date: Fri, 15 Nov 2024 17:52:31 +0800 Subject: [PATCH 06/12] [Rust] add padded support for slice setter for primitive array field --- rust/tests/fixed_sized_primitive_array.rs | 597 ++++++++++++++++-- .../fixed-sized-primitive-array-types.xml | 4 +- 2 files changed, 547 insertions(+), 54 deletions(-) diff --git a/rust/tests/fixed_sized_primitive_array.rs b/rust/tests/fixed_sized_primitive_array.rs index dd5380e641..440afd7b89 100644 --- a/rust/tests/fixed_sized_primitive_array.rs +++ b/rust/tests/fixed_sized_primitive_array.rs @@ -58,7 +58,7 @@ fn test_encode_then_decode_u8_slice() { // // macro_rules! run_encode_then_decode_for_array_of_u8_len_16 { - ($encode_func:expr, $decode_func:expr, $i_null:expr) => { + ($encode_func:expr, $decode_func:expr) => { for each_slice in test_data { let encode_func = $encode_func; let decode_func = $decode_func; @@ -67,7 +67,7 @@ fn test_encode_then_decode_u8_slice() { let effective_len = cur_len.min(16); // encode... - let mut buffer = vec![1u8; 1024]; + let mut buffer = vec![0u8; 1024]; let mut encoder = create_encoder(&mut buffer); encode_func(&mut encoder, each_slice); @@ -85,11 +85,10 @@ fn test_encode_then_decode_u8_slice() { each_idx, cur_len ); } - let null_value = $i_null; for each_idx in effective_len..16 { assert_eq!( - decoded[each_idx], null_value, - "Item should be NULL at {}/{}", + decoded[each_idx], 0, + "Item should be ZERO at {}/{}", each_idx, cur_len ); } @@ -99,43 +98,35 @@ 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, - DemoDecoder::fixed_16_char, - 0 + DemoDecoder::fixed_16_char ); run_encode_then_decode_for_array_of_u8_len_16!( DemoEncoder::fixed_16_ascii_char_at_most_16_items_from_slice, - DemoDecoder::fixed_16_ascii_char, - 0 + DemoDecoder::fixed_16_ascii_char ); run_encode_then_decode_for_array_of_u8_len_16!( DemoEncoder::fixed_16_gb_18030_char_at_most_16_items_from_slice, - DemoDecoder::fixed_16_gb_18030_char, - 0 + DemoDecoder::fixed_16_gb_18030_char ); run_encode_then_decode_for_array_of_u8_len_16!( DemoEncoder::fixed_16_utf_8_char_at_most_16_items_from_slice, - DemoDecoder::fixed_16_utf_8_char, - 0 + DemoDecoder::fixed_16_utf_8_char ); run_encode_then_decode_for_array_of_u8_len_16!( DemoEncoder::fixed_16_u8_at_most_16_items_from_slice, - DemoDecoder::fixed_16_u8, - u8::MAX + DemoDecoder::fixed_16_u8 ); run_encode_then_decode_for_array_of_u8_len_16!( DemoEncoder::fixed_16_ascii_u8_at_most_16_items_from_slice, - DemoDecoder::fixed_16_ascii_u8, - u8::MAX + DemoDecoder::fixed_16_ascii_u8 ); run_encode_then_decode_for_array_of_u8_len_16!( DemoEncoder::fixed_16_gb_18030_u8_at_most_16_items_from_slice, - DemoDecoder::fixed_16_gb_18030_u8, - u8::MAX + DemoDecoder::fixed_16_gb_18030_u8 ); run_encode_then_decode_for_array_of_u8_len_16!( DemoEncoder::fixed_16_utf_8_u8_at_most_16_items_from_slice, - DemoDecoder::fixed_16_utf_8_u8, - u8::MAX + DemoDecoder::fixed_16_utf_8_u8 ); } @@ -145,8 +136,8 @@ fn test_encode_then_decode_non_u8_signed_primitive_slice() { // // // - macro_rules! run_encode_then_decode_for_array_of_u8_len_16 { - ($encode_func:expr, $decode_func:expr, $i_type:ty, $i_null:expr) => { + macro_rules! run_encode_then_decode_for_array_of_signed_len_16 { + ($encode_func:expr, $decode_func:expr, $i_type:ty) => { let test_data = [ &[] as &[$i_type], &[1 as $i_type] as &[$i_type], @@ -269,7 +260,7 @@ fn test_encode_then_decode_non_u8_signed_primitive_slice() { let effective_len = cur_len.min(16); // encode... - let mut buffer = vec![1u8; 1024]; + let mut buffer = vec![0u8; 1024]; let mut encoder = create_encoder(&mut buffer); encode_func(&mut encoder, &each_slice); @@ -290,12 +281,11 @@ fn test_encode_then_decode_non_u8_signed_primitive_slice() { stringify!($i_type) ); } - let null_value = $i_null; for each_idx in effective_len..16 { assert_eq!( decoded[each_idx], - null_value, - "Item should be null at {}/{} for {}", + 0, + "Item should be ZERO at {}/{} for {}", each_idx, cur_len, stringify!($i_type) @@ -305,29 +295,25 @@ fn test_encode_then_decode_non_u8_signed_primitive_slice() { }; } - run_encode_then_decode_for_array_of_u8_len_16!( + run_encode_then_decode_for_array_of_signed_len_16!( DemoEncoder::fixed_16_i8_at_most_16_items_from_slice, DemoDecoder::fixed_16_i8, - i8, - i8::MIN + i8 ); - run_encode_then_decode_for_array_of_u8_len_16!( + run_encode_then_decode_for_array_of_signed_len_16!( DemoEncoder::fixed_16_i16_at_most_16_items_from_slice, DemoDecoder::fixed_16_i16, - i16, - i16::MIN + i16 ); - run_encode_then_decode_for_array_of_u8_len_16!( + run_encode_then_decode_for_array_of_signed_len_16!( DemoEncoder::fixed_16_i32_at_most_16_items_from_slice, DemoDecoder::fixed_16_i32, - i32, - i32::MIN + i32 ); - run_encode_then_decode_for_array_of_u8_len_16!( + run_encode_then_decode_for_array_of_signed_len_16!( DemoEncoder::fixed_16_i64_at_most_16_items_from_slice, DemoDecoder::fixed_16_i64, - i64, - i64::MIN + i64 ); } @@ -335,8 +321,8 @@ fn test_encode_then_decode_non_u8_signed_primitive_slice() { fn test_encode_then_decode_non_u8_unsigned_primitive_slice() { // // - macro_rules! run_encode_then_decode_for_array_of_u8_len_16 { - ($encode_func:expr, $decode_func:expr, $i_type:ty, $i_null:expr) => { + macro_rules! run_encode_then_decode_for_array_of_unsigned_len_16 { + ($encode_func:expr, $decode_func:expr, $i_type:ty) => { let test_data = [ &[] as &[$i_type], &[1 as $i_type] as &[$i_type], @@ -459,10 +445,10 @@ fn test_encode_then_decode_non_u8_unsigned_primitive_slice() { let effective_len = cur_len.min(16); // encode... - let mut buffer = vec![1u8; 1024]; + let mut buffer = vec![0u8; 1024]; let mut encoder = create_encoder(&mut buffer); - encode_func(&mut encoder, &each_slice); + encode_func(&mut encoder, each_slice); // decode... let buf = ReadBuf::new(buffer.as_slice()); @@ -480,12 +466,11 @@ fn test_encode_then_decode_non_u8_unsigned_primitive_slice() { stringify!($i_type) ); } - let null_value = $i_null; for each_idx in effective_len..16 { assert_eq!( decoded[each_idx], - null_value, - "Item should be null at {}/{} for {}", + 0, + "Item should be ZERO at {}/{} for {}", each_idx, cur_len, stringify!($i_type) @@ -495,17 +480,525 @@ fn test_encode_then_decode_non_u8_unsigned_primitive_slice() { }; } - run_encode_then_decode_for_array_of_u8_len_16!( + run_encode_then_decode_for_array_of_unsigned_len_16!( DemoEncoder::fixed_16_u16_at_most_16_items_from_slice, DemoDecoder::fixed_16_u16, - u16, - u16::MAX + u16 ); - run_encode_then_decode_for_array_of_u8_len_16!( + run_encode_then_decode_for_array_of_unsigned_len_16!( DemoEncoder::fixed_16_u32_at_most_16_items_from_slice, DemoDecoder::fixed_16_u32, + u32 + ); + run_encode_then_decode_for_array_of_unsigned_len_16!( + DemoEncoder::fixed_16_u64_at_most_16_items_from_slice, + DemoDecoder::fixed_16_u64, + u64 + ); +} + +#[test] +fn test_encode_then_decode_u8_slice_padded() { + let test_data = [ + b"" as &[u8], + b"0" as &[u8], + b"01" as &[u8], + b"012" as &[u8], + b"0123" as &[u8], + b"01234" as &[u8], + b"012345" as &[u8], + b"0123456" as &[u8], + b"01234567" as &[u8], + b"012345678" as &[u8], + b"0123456789" as &[u8], + b"0123456789A" as &[u8], + b"0123456789AB" as &[u8], + b"0123456789ABC" as &[u8], + b"0123456789ABCD" as &[u8], + b"0123456789ABCDE" as &[u8], + b"0123456789ABCDEF" as &[u8], + b"0123456789abcdef" as &[u8], + b"0123456789abcdef0" as &[u8], + b"0123456789abcdef01" as &[u8], + b"0123456789abcdef012" as &[u8], + b"0123456789abcdef0123" as &[u8], + b"0123456789abcdef01234" as &[u8], + b"0123456789abcdef012345" as &[u8], + b"0123456789abcdef0123456" as &[u8], + b"0123456789abcdef01234567" as &[u8], + b"0123456789abcdef012345678" as &[u8], + b"0123456789abcdef0123456789" as &[u8], + b"0123456789abcdef0123456789A" as &[u8], + b"0123456789abcdef0123456789AB" as &[u8], + b"0123456789abcdef0123456789ABC" as &[u8], + b"0123456789abcdef0123456789ABCD" as &[u8], + b"0123456789abcdef0123456789ABCDE" as &[u8], + b"0123456789abcdef0123456789ABCDEF" as &[u8], + ]; + + // + // + // + // + // + // + // + // + macro_rules! run_encode_then_decode_for_array_of_u8_len_16 { + ($encode_func:expr, $decode_func:expr, $i_padded:expr) => { + for each_slice in test_data { + let encode_func = $encode_func; + let decode_func = $decode_func; + let padded_value = $i_padded; + + let cur_len = each_slice.len(); + let effective_len = cur_len.min(16); + + // encode... + let mut buffer = vec![0u8; 1024]; + let mut encoder = create_encoder(&mut buffer); + + encode_func(&mut encoder, each_slice, padded_value); + + // decode... + let buf = ReadBuf::new(buffer.as_slice()); + let header = MessageHeaderDecoder::default().wrap(buf, 0); + + let decoder = DemoDecoder::default().header(header, 0); + let decoded = decode_func(&decoder); + for each_idx in 0..effective_len { + assert_eq!( + each_slice[each_idx], decoded[each_idx], + "Item mismatched at {}/{}", + each_idx, cur_len + ); + } + for each_idx in effective_len..16 { + assert_eq!( + decoded[each_idx], padded_value, + "Item should be padded at {}/{}", + each_idx, cur_len + ); + } + } + }; + } + + run_encode_then_decode_for_array_of_u8_len_16!( + DemoEncoder::fixed_16_char_at_most_16_items_from_slice_padded, + DemoDecoder::fixed_16_char, + 30 + ); + run_encode_then_decode_for_array_of_u8_len_16!( + DemoEncoder::fixed_16_ascii_char_at_most_16_items_from_slice_padded, + DemoDecoder::fixed_16_ascii_char, + 30 + ); + run_encode_then_decode_for_array_of_u8_len_16!( + DemoEncoder::fixed_16_gb_18030_char_at_most_16_items_from_slice_padded, + DemoDecoder::fixed_16_gb_18030_char, + 30 + ); + run_encode_then_decode_for_array_of_u8_len_16!( + DemoEncoder::fixed_16_utf_8_char_at_most_16_items_from_slice_padded, + DemoDecoder::fixed_16_utf_8_char, + 30 + ); + run_encode_then_decode_for_array_of_u8_len_16!( + DemoEncoder::fixed_16_u8_at_most_16_items_from_slice_padded, + DemoDecoder::fixed_16_u8, + 30 + ); + run_encode_then_decode_for_array_of_u8_len_16!( + DemoEncoder::fixed_16_ascii_u8_at_most_16_items_from_slice_padded, + DemoDecoder::fixed_16_ascii_u8, + 30 + ); + run_encode_then_decode_for_array_of_u8_len_16!( + DemoEncoder::fixed_16_gb_18030_u8_at_most_16_items_from_slice_padded, + DemoDecoder::fixed_16_gb_18030_u8, + 30 + ); + run_encode_then_decode_for_array_of_u8_len_16!( + DemoEncoder::fixed_16_utf_8_u8_at_most_16_items_from_slice_padded, + DemoDecoder::fixed_16_utf_8_u8, + 30 + ); +} + +#[test] +fn test_encode_then_decode_non_u8_signed_primitive_slice_padded() { + // + // + // + // + macro_rules! run_encode_then_decode_for_array_of_signed_len_16 { + ($encode_func:expr, $decode_func:expr, $i_type:ty, $i_padded:expr) => { + let test_data = [ + &[] as &[$i_type], + &[1 as $i_type] as &[$i_type], + &[0 as $i_type] as &[$i_type], + &[-1 as $i_type] as &[$i_type], + &[-1, 1 as $i_type] as &[$i_type], + &[-1, 0, 1 as $i_type] as &[$i_type], + &[-2, -1, 1, 2 as $i_type] as &[$i_type], + &[-2, -1, 0, 1, 2 as $i_type] as &[$i_type], + &[-3, -2, -1, 1, 2, 3 as $i_type] as &[$i_type], + &[-3, -2, -1, 0, 1, 2, 3 as $i_type] as &[$i_type], + &[-4, -3, -2, -1, 1, 2, 3, 4 as $i_type] as &[$i_type], + &[-4, -3, -2, -1, 0, 1, 2, 3, 4 as $i_type] as &[$i_type], + &[-5, -4, -3, -2, -1, 1, 2, 3, 4, 5 as $i_type] as &[$i_type], + &[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5 as $i_type] as &[$i_type], + &[-6, -5, -4, -3, -2, -1, 1, 2, 3, 4, 5, 6 as $i_type] as &[$i_type], + &[-6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6 as $i_type] as &[$i_type], + &[-7, -6, -5, -4, -3, -2, -1, 1, 2, 3, 4, 5, 6, 7 as $i_type] as &[$i_type], + &[ + -7, + -6, + -5, + -4, + -3, + -2, + -1, + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 as $i_type, + ] as &[$i_type], + &[ + -8, + -7, + -6, + -5, + -4, + -3, + -2, + -1, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 as $i_type, + ] as &[$i_type], + &[ + -8, + -7, + -6, + -5, + -4, + -3, + -2, + -1, + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 as $i_type, + ] as &[$i_type], + &[ + -9, + -8, + -7, + -6, + -5, + -4, + -3, + -2, + -1, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 as $i_type, + ] as &[$i_type], + &[ + -9, + -8, + -7, + -6, + -5, + -4, + -3, + -2, + -1, + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 as $i_type, + ] as &[$i_type], + ]; + for each_slice in test_data { + let encode_func = $encode_func; + let decode_func = $decode_func; + let padded_value = $i_padded; + + let cur_len = each_slice.len(); + let effective_len = cur_len.min(16); + + // encode... + let mut buffer = vec![0u8; 1024]; + let mut encoder = create_encoder(&mut buffer); + + encode_func(&mut encoder, each_slice, padded_value); + + // decode... + let buf = ReadBuf::new(buffer.as_slice()); + let header = MessageHeaderDecoder::default().wrap(buf, 0); + + let decoder = DemoDecoder::default().header(header, 0); + let decoded = decode_func(&decoder); + for each_idx in 0..effective_len { + assert_eq!( + each_slice[each_idx], + decoded[each_idx], + "Item mismatched at {}/{} for {}", + each_idx, + cur_len, + stringify!($i_type) + ); + } + for each_idx in effective_len..16 { + assert_eq!( + decoded[each_idx], + padded_value, + "Item should be padded at {}/{} for {}", + each_idx, + cur_len, + stringify!($i_type) + ); + } + } + }; + } + + run_encode_then_decode_for_array_of_signed_len_16!( + DemoEncoder::fixed_16_i8_at_most_16_items_from_slice_padded, + DemoDecoder::fixed_16_i8, + i8, + -31 + ); + run_encode_then_decode_for_array_of_signed_len_16!( + DemoEncoder::fixed_16_i16_at_most_16_items_from_slice_padded, + DemoDecoder::fixed_16_i16, + i16, + -31 + ); + run_encode_then_decode_for_array_of_signed_len_16!( + DemoEncoder::fixed_16_i32_at_most_16_items_from_slice_padded, + DemoDecoder::fixed_16_i32, + i32, + -31 + ); + run_encode_then_decode_for_array_of_signed_len_16!( + DemoEncoder::fixed_16_i64_at_most_16_items_from_slice_padded, + DemoDecoder::fixed_16_i64, + i64, + -31 + ); +} + +#[test] +fn test_encode_then_decode_non_u8_unsigned_primitive_slice_padded() { + // + // + // + macro_rules! run_encode_then_decode_for_array_of_unsigned_len_16 { + ($encode_func:expr, $decode_func:expr, $i_type:ty, $i_padded:expr) => { + let test_data = [ + &[] as &[$i_type], + &[1 as $i_type] as &[$i_type], + &[0 as $i_type] as &[$i_type], + &[11 as $i_type] as &[$i_type], + &[11, 1 as $i_type] as &[$i_type], + &[11, 0, 1 as $i_type] as &[$i_type], + &[12, 11, 1, 2 as $i_type] as &[$i_type], + &[12, 11, 0, 1, 2 as $i_type] as &[$i_type], + &[13, 12, 11, 1, 2, 3 as $i_type] as &[$i_type], + &[13, 12, 11, 0, 1, 2, 3 as $i_type] as &[$i_type], + &[14, 13, 12, 11, 1, 2, 3, 4 as $i_type] as &[$i_type], + &[14, 13, 12, 11, 0, 1, 2, 3, 4 as $i_type] as &[$i_type], + &[15, 14, 13, 12, 11, 1, 2, 3, 4, 5 as $i_type] as &[$i_type], + &[15, 14, 13, 12, 11, 0, 1, 2, 3, 4, 5 as $i_type] as &[$i_type], + &[16, 15, 14, 13, 12, 11, 1, 2, 3, 4, 5, 6 as $i_type] as &[$i_type], + &[16, 15, 14, 13, 12, 11, 0, 1, 2, 3, 4, 5, 6 as $i_type] as &[$i_type], + &[17, 16, 15, 14, 13, 12, 11, 1, 2, 3, 4, 5, 6, 7 as $i_type] as &[$i_type], + &[ + 17, + 16, + 15, + 14, + 13, + 12, + 11, + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 as $i_type, + ] as &[$i_type], + &[ + 18, + 17, + 16, + 15, + 14, + 13, + 12, + 11, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 as $i_type, + ] as &[$i_type], + &[ + 18, + 17, + 16, + 15, + 14, + 13, + 12, + 11, + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 as $i_type, + ] as &[$i_type], + &[ + 19, + 18, + 17, + 16, + 15, + 14, + 13, + 12, + 11, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 as $i_type, + ] as &[$i_type], + &[ + 19, + 18, + 17, + 16, + 15, + 14, + 13, + 12, + 11, + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 as $i_type, + ] as &[$i_type], + ]; + for each_slice in test_data { + let encode_func = $encode_func; + let decode_func = $decode_func; + let padded_value = $i_padded; + + let cur_len = each_slice.len(); + let effective_len = cur_len.min(16); + + // encode... + let mut buffer = vec![0u8; 1024]; + let mut encoder = create_encoder(&mut buffer); + + encode_func(&mut encoder, each_slice, padded_value); + + // decode... + let buf = ReadBuf::new(buffer.as_slice()); + let header = MessageHeaderDecoder::default().wrap(buf, 0); + + let decoder = DemoDecoder::default().header(header, 0); + let decoded = decode_func(&decoder); + for each_idx in 0..effective_len { + assert_eq!( + each_slice[each_idx], + decoded[each_idx], + "Item mismatched at {}/{} for {}", + each_idx, + cur_len, + stringify!($i_type) + ); + } + for each_idx in effective_len..16 { + assert_eq!( + decoded[each_idx], + padded_value, + "Item should be padded at {}/{} for {}", + each_idx, + cur_len, + stringify!($i_type) + ); + } + } + }; + } + + run_encode_then_decode_for_array_of_unsigned_len_16!( + DemoEncoder::fixed_16_u16_at_most_16_items_from_slice_padded, + DemoDecoder::fixed_16_u16, + u16, + 1024u16 + ); + run_encode_then_decode_for_array_of_unsigned_len_16!( + DemoEncoder::fixed_16_u32_at_most_16_items_from_slice_padded, + DemoDecoder::fixed_16_u32, u32, - u32::MAX + 10000000u32 + ); + run_encode_then_decode_for_array_of_unsigned_len_16!( + DemoEncoder::fixed_16_u64_at_most_16_items_from_slice_padded, + DemoDecoder::fixed_16_u64, + u64, + 20241115173301u64 ); - // run_encode_then_decode_for_array_of_u8_len_16!(DemoEncoder::fixed_16_u64_at_most_16_items_from_slice, DemoDecoder::fixed_16_i64, i64, u64::MAX); } diff --git a/sbe-tool/src/test/resources/fixed-sized-primitive-array-types.xml b/sbe-tool/src/test/resources/fixed-sized-primitive-array-types.xml index 719715d6b5..359f1becd3 100644 --- a/sbe-tool/src/test/resources/fixed-sized-primitive-array-types.xml +++ b/sbe-tool/src/test/resources/fixed-sized-primitive-array-types.xml @@ -32,7 +32,7 @@ - + @@ -53,6 +53,6 @@ - + From bab473ea91fbd7157e2bddd1e49615a3d166979f Mon Sep 17 00:00:00 2001 From: Elvis Wang Date: Mon, 16 Dec 2024 15:44:08 +0800 Subject: [PATCH 07/12] [Rust] simplify impl of generated slice aware methods --- rust/tests/fixed_sized_primitive_array.rs | 266 ++++++++++++------ .../fixed-sized-primitive-array-types.xml | 39 ++- 2 files changed, 213 insertions(+), 92 deletions(-) diff --git a/rust/tests/fixed_sized_primitive_array.rs b/rust/tests/fixed_sized_primitive_array.rs index 440afd7b89..43e82f347d 100644 --- a/rust/tests/fixed_sized_primitive_array.rs +++ b/rust/tests/fixed_sized_primitive_array.rs @@ -4,14 +4,16 @@ use fixed_sized_primitive_array::{ ReadBuf, WriteBuf, }; -fn create_encoder(buffer: &mut Vec) -> DemoEncoder { - let encoder = DemoEncoder::default().wrap(WriteBuf::new(buffer.as_mut_slice()), ENCODED_LENGTH); +fn create_encoder(buffer: &mut [u8]) -> DemoEncoder { + let encoder = DemoEncoder::default().wrap(WriteBuf::new(buffer), ENCODED_LENGTH); let mut header = encoder.header(0); header.parent().unwrap() } #[test] fn test_encode_then_decode_u8_slice() { + let uninit = 1u8; + let test_data = [ b"" as &[u8], b"0" as &[u8], @@ -58,20 +60,25 @@ fn test_encode_then_decode_u8_slice() { // // macro_rules! run_encode_then_decode_for_array_of_u8_len_16 { - ($encode_func:expr, $decode_func:expr) => { + ($encode_func:expr, $decode_func:expr, $end_encode_func:expr, $end_decode_func:expr) => { for each_slice in test_data { let encode_func = $encode_func; let decode_func = $decode_func; + let end_encode_func = $end_encode_func; + let end_decode_func = $end_decode_func; let cur_len = each_slice.len(); let effective_len = cur_len.min(16); // encode... - let mut buffer = vec![0u8; 1024]; + let mut buffer = [uninit; 1024]; let mut encoder = create_encoder(&mut buffer); encode_func(&mut encoder, each_slice); + let end = 1i32; + end_encode_func(&mut encoder, end); + // decode... let buf = ReadBuf::new(buffer.as_slice()); let header = MessageHeaderDecoder::default().wrap(buf, 0); @@ -87,57 +94,77 @@ fn test_encode_then_decode_u8_slice() { } for each_idx in effective_len..16 { assert_eq!( - decoded[each_idx], 0, - "Item should be ZERO at {}/{}", + decoded[each_idx], uninit, + "Item should not be padded ZERO at {}/{}", each_idx, cur_len ); } + let decoded_end = end_decode_func(&decoder); + assert_eq!(decoded_end, end, "End Item should equal",); } }; } run_encode_then_decode_for_array_of_u8_len_16!( DemoEncoder::fixed_16_char_at_most_16_items_from_slice, - DemoDecoder::fixed_16_char + 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, - DemoDecoder::fixed_16_ascii_char + 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, - DemoDecoder::fixed_16_gb_18030_char + 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, - DemoDecoder::fixed_16_utf_8_char + 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, - DemoDecoder::fixed_16_u8 + 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, - DemoDecoder::fixed_16_ascii_u8 + 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, - DemoDecoder::fixed_16_gb_18030_u8 + 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, - DemoDecoder::fixed_16_utf_8_u8 + DemoDecoder::fixed_16_utf_8_u8, + DemoEncoder::fixed_16_utf_8u_8_end, + DemoDecoder::fixed_16_utf_8u_8_end ); } #[test] fn test_encode_then_decode_non_u8_signed_primitive_slice() { + let uninit = 1u8; + // // // // macro_rules! run_encode_then_decode_for_array_of_signed_len_16 { - ($encode_func:expr, $decode_func:expr, $i_type:ty) => { + ($encode_func:expr, $decode_func:expr, $end_encode_func:expr, $end_decode_func:expr, $i_type:ty, $existed:expr) => { let test_data = [ &[] as &[$i_type], &[1 as $i_type] as &[$i_type], @@ -252,19 +279,27 @@ fn test_encode_then_decode_non_u8_signed_primitive_slice() { 9 as $i_type, ] as &[$i_type], ]; + + let existed = $existed; + for each_slice in test_data { let encode_func = $encode_func; let decode_func = $decode_func; + let end_encode_func = $end_encode_func; + let end_decode_func = $end_decode_func; let cur_len = each_slice.len(); let effective_len = cur_len.min(16); // encode... - let mut buffer = vec![0u8; 1024]; + let mut buffer = [uninit; 1024]; let mut encoder = create_encoder(&mut buffer); encode_func(&mut encoder, &each_slice); + let end = 1i32; + end_encode_func(&mut encoder, end); + // decode... let buf = ReadBuf::new(buffer.as_slice()); let header = MessageHeaderDecoder::default().wrap(buf, 0); @@ -284,13 +319,15 @@ fn test_encode_then_decode_non_u8_signed_primitive_slice() { for each_idx in effective_len..16 { assert_eq!( decoded[each_idx], - 0, - "Item should be ZERO at {}/{} for {}", + existed, + "Item should not be padded ZERO at {}/{} for {}", each_idx, cur_len, stringify!($i_type) ); } + let decoded_end = end_decode_func(&decoder); + assert_eq!(decoded_end, end, "End Item should equal",); } }; } @@ -298,31 +335,41 @@ 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, DemoDecoder::fixed_16_i8, - 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, DemoDecoder::fixed_16_i16, - 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, DemoDecoder::fixed_16_i32, - 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, DemoDecoder::fixed_16_i64, - i64 + DemoEncoder::fixed_16_i64_end, + DemoDecoder::fixed_16_i64_end, + i64, i64::from_le_bytes([uninit, uninit, uninit, uninit, uninit, uninit, uninit, uninit]) ); } #[test] fn test_encode_then_decode_non_u8_unsigned_primitive_slice() { + let uninit = 1u8; + // // macro_rules! run_encode_then_decode_for_array_of_unsigned_len_16 { - ($encode_func:expr, $decode_func:expr, $i_type:ty) => { + ($encode_func:expr, $decode_func:expr, $end_encode_func:expr, $end_decode_func:expr, $i_type:ty, $existed:expr) => { let test_data = [ &[] as &[$i_type], &[1 as $i_type] as &[$i_type], @@ -437,19 +484,27 @@ fn test_encode_then_decode_non_u8_unsigned_primitive_slice() { 9 as $i_type, ] as &[$i_type], ]; + + let existed = $existed; + for each_slice in test_data { let encode_func = $encode_func; let decode_func = $decode_func; + let end_encode_func = $end_encode_func; + let end_decode_func = $end_decode_func; let cur_len = each_slice.len(); let effective_len = cur_len.min(16); // encode... - let mut buffer = vec![0u8; 1024]; + let mut buffer = [uninit; 1024]; let mut encoder = create_encoder(&mut buffer); encode_func(&mut encoder, each_slice); + let end = 1i32; + end_encode_func(&mut encoder, end); + // decode... let buf = ReadBuf::new(buffer.as_slice()); let header = MessageHeaderDecoder::default().wrap(buf, 0); @@ -466,16 +521,19 @@ fn test_encode_then_decode_non_u8_unsigned_primitive_slice() { stringify!($i_type) ); } + for each_idx in effective_len..16 { assert_eq!( decoded[each_idx], - 0, - "Item should be ZERO at {}/{} for {}", + existed, + "Item should not be padded ZERO at {}/{} for {}", each_idx, cur_len, stringify!($i_type) ); } + let decoded_end = end_decode_func(&decoder); + assert_eq!(decoded_end, end, "End Item should equal",); } }; } @@ -483,22 +541,33 @@ 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, DemoDecoder::fixed_16_u16, - 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, DemoDecoder::fixed_16_u32, - 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, DemoDecoder::fixed_16_u64, - u64 + DemoEncoder::fixed_16_u64_end, + DemoDecoder::fixed_16_u64_end, + u64, + u64::from_le_bytes([uninit, uninit, uninit, uninit, uninit, uninit, uninit, uninit]) ); } #[test] fn test_encode_then_decode_u8_slice_padded() { + let uninit = 1u8; + let test_data = [ b"" as &[u8], b"0" as &[u8], @@ -545,20 +614,24 @@ fn test_encode_then_decode_u8_slice_padded() { // // macro_rules! run_encode_then_decode_for_array_of_u8_len_16 { - ($encode_func:expr, $decode_func:expr, $i_padded:expr) => { + ($encode_func:expr, $decode_func:expr, $end_encode_func:expr, $end_decode_func:expr,) => { for each_slice in test_data { let encode_func = $encode_func; let decode_func = $decode_func; - let padded_value = $i_padded; + let end_encode_func = $end_encode_func; + let end_decode_func = $end_decode_func; let cur_len = each_slice.len(); let effective_len = cur_len.min(16); // encode... - let mut buffer = vec![0u8; 1024]; + let mut buffer = [uninit; 1024]; let mut encoder = create_encoder(&mut buffer); - encode_func(&mut encoder, each_slice, padded_value); + encode_func(&mut encoder, each_slice); + + let end = 1i32; + end_encode_func(&mut encoder, end); // decode... let buf = ReadBuf::new(buffer.as_slice()); @@ -575,65 +648,77 @@ fn test_encode_then_decode_u8_slice_padded() { } for each_idx in effective_len..16 { assert_eq!( - decoded[each_idx], padded_value, - "Item should be padded at {}/{}", + decoded[each_idx], 0, + "Item should be padded ZERO at {}/{}", each_idx, cur_len ); } + let decoded_end = end_decode_func(&decoder); + assert_eq!(decoded_end, end, "End Item should equal",); } }; } run_encode_then_decode_for_array_of_u8_len_16!( - DemoEncoder::fixed_16_char_at_most_16_items_from_slice_padded, + DemoEncoder::fixed_16_char_at_most_16_items_from_slice_padded_with_zero, DemoDecoder::fixed_16_char, - 30 + 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, + DemoEncoder::fixed_16_ascii_char_at_most_16_items_from_slice_padded_with_zero, DemoDecoder::fixed_16_ascii_char, - 30 + 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, + DemoEncoder::fixed_16_gb_18030_char_at_most_16_items_from_slice_padded_with_zero, DemoDecoder::fixed_16_gb_18030_char, - 30 + 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, + DemoEncoder::fixed_16_utf_8_char_at_most_16_items_from_slice_padded_with_zero, DemoDecoder::fixed_16_utf_8_char, - 30 + 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, + DemoEncoder::fixed_16_u8_at_most_16_items_from_slice_padded_with_zero, DemoDecoder::fixed_16_u8, - 30 + 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, + DemoEncoder::fixed_16_ascii_u8_at_most_16_items_from_slice_padded_with_zero, DemoDecoder::fixed_16_ascii_u8, - 30 + 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, + DemoEncoder::fixed_16_gb_18030_u8_at_most_16_items_from_slice_padded_with_zero, DemoDecoder::fixed_16_gb_18030_u8, - 30 + 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, + DemoEncoder::fixed_16_utf_8_u8_at_most_16_items_from_slice_padded_with_zero, DemoDecoder::fixed_16_utf_8_u8, - 30 + DemoEncoder::fixed_16_utf_8u_8_end, + DemoDecoder::fixed_16_utf_8u_8_end, ); } #[test] fn test_encode_then_decode_non_u8_signed_primitive_slice_padded() { + let uninit = 1u8; + // // // // macro_rules! run_encode_then_decode_for_array_of_signed_len_16 { - ($encode_func:expr, $decode_func:expr, $i_type:ty, $i_padded:expr) => { + ($encode_func:expr, $decode_func:expr, $end_encode_func:expr, $end_decode_func:expr, $i_type:ty,) => { let test_data = [ &[] as &[$i_type], &[1 as $i_type] as &[$i_type], @@ -751,16 +836,20 @@ fn test_encode_then_decode_non_u8_signed_primitive_slice_padded() { for each_slice in test_data { let encode_func = $encode_func; let decode_func = $decode_func; - let padded_value = $i_padded; + let end_encode_func = $end_encode_func; + let end_decode_func = $end_decode_func; let cur_len = each_slice.len(); let effective_len = cur_len.min(16); // encode... - let mut buffer = vec![0u8; 1024]; + let mut buffer = [uninit; 1024]; let mut encoder = create_encoder(&mut buffer); - encode_func(&mut encoder, each_slice, padded_value); + encode_func(&mut encoder, each_slice); + + let end = 1i32; + end_encode_func(&mut encoder, end); // decode... let buf = ReadBuf::new(buffer.as_slice()); @@ -781,50 +870,58 @@ fn test_encode_then_decode_non_u8_signed_primitive_slice_padded() { for each_idx in effective_len..16 { assert_eq!( decoded[each_idx], - padded_value, - "Item should be padded at {}/{} for {}", + 0, + "Item should be padded ZERO at {}/{} for {}", each_idx, cur_len, stringify!($i_type) ); } + let decoded_end = end_decode_func(&decoder); + assert_eq!(decoded_end, end, "End Item should equal",); } }; } run_encode_then_decode_for_array_of_signed_len_16!( - DemoEncoder::fixed_16_i8_at_most_16_items_from_slice_padded, + DemoEncoder::fixed_16_i8_at_most_16_items_from_slice_padded_with_zero, DemoDecoder::fixed_16_i8, + DemoEncoder::fixed_16_i8_end, + DemoDecoder::fixed_16_i8_end, i8, - -31 ); run_encode_then_decode_for_array_of_signed_len_16!( - DemoEncoder::fixed_16_i16_at_most_16_items_from_slice_padded, + DemoEncoder::fixed_16_i16_at_most_16_items_from_slice_padded_with_zero, DemoDecoder::fixed_16_i16, + DemoEncoder::fixed_16_i16_end, + DemoDecoder::fixed_16_i16_end, i16, - -31 ); run_encode_then_decode_for_array_of_signed_len_16!( - DemoEncoder::fixed_16_i32_at_most_16_items_from_slice_padded, + DemoEncoder::fixed_16_i32_at_most_16_items_from_slice_padded_with_zero, DemoDecoder::fixed_16_i32, + DemoEncoder::fixed_16_i32_end, + DemoDecoder::fixed_16_i32_end, i32, - -31 ); run_encode_then_decode_for_array_of_signed_len_16!( - DemoEncoder::fixed_16_i64_at_most_16_items_from_slice_padded, + DemoEncoder::fixed_16_i64_at_most_16_items_from_slice_padded_with_zero, DemoDecoder::fixed_16_i64, + DemoEncoder::fixed_16_i64_end, + DemoDecoder::fixed_16_i64_end, i64, - -31 ); } #[test] fn test_encode_then_decode_non_u8_unsigned_primitive_slice_padded() { + let uninit = 1u8; + // // // macro_rules! run_encode_then_decode_for_array_of_unsigned_len_16 { - ($encode_func:expr, $decode_func:expr, $i_type:ty, $i_padded:expr) => { + ($encode_func:expr, $decode_func:expr, $end_encode_func:expr, $end_decode_func:expr, $i_type:ty) => { let test_data = [ &[] as &[$i_type], &[1 as $i_type] as &[$i_type], @@ -942,16 +1039,20 @@ fn test_encode_then_decode_non_u8_unsigned_primitive_slice_padded() { for each_slice in test_data { let encode_func = $encode_func; let decode_func = $decode_func; - let padded_value = $i_padded; + let end_encode_func = $end_encode_func; + let end_decode_func = $end_decode_func; let cur_len = each_slice.len(); let effective_len = cur_len.min(16); // encode... - let mut buffer = vec![0u8; 1024]; + let mut buffer = [uninit; 1024]; let mut encoder = create_encoder(&mut buffer); - encode_func(&mut encoder, each_slice, padded_value); + encode_func(&mut encoder, each_slice); + + let end = 1i32; + end_encode_func(&mut encoder, end); // decode... let buf = ReadBuf::new(buffer.as_slice()); @@ -972,33 +1073,38 @@ fn test_encode_then_decode_non_u8_unsigned_primitive_slice_padded() { for each_idx in effective_len..16 { assert_eq!( decoded[each_idx], - padded_value, - "Item should be padded at {}/{} for {}", + 0, + "Item should be padded ZERO at {}/{} for {}", each_idx, cur_len, stringify!($i_type) ); } + let decoded_end = end_decode_func(&decoder); + assert_eq!(decoded_end, end, "End Item should equal",); } }; } run_encode_then_decode_for_array_of_unsigned_len_16!( - DemoEncoder::fixed_16_u16_at_most_16_items_from_slice_padded, + DemoEncoder::fixed_16_u16_at_most_16_items_from_slice_padded_with_zero, DemoDecoder::fixed_16_u16, - u16, - 1024u16 + 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, + DemoEncoder::fixed_16_u32_at_most_16_items_from_slice_padded_with_zero, DemoDecoder::fixed_16_u32, - u32, - 10000000u32 + 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, + DemoEncoder::fixed_16_u64_at_most_16_items_from_slice_padded_with_zero, DemoDecoder::fixed_16_u64, - u64, - 20241115173301u64 + DemoEncoder::fixed_16_u64_end, + DemoDecoder::fixed_16_u64_end, + u64 ); } diff --git a/sbe-tool/src/test/resources/fixed-sized-primitive-array-types.xml b/sbe-tool/src/test/resources/fixed-sized-primitive-array-types.xml index 359f1becd3..62f3b9a5b0 100644 --- a/sbe-tool/src/test/resources/fixed-sized-primitive-array-types.xml +++ b/sbe-tool/src/test/resources/fixed-sized-primitive-array-types.xml @@ -37,22 +37,37 @@ - - - + + + + + + + - - - + + + + + + + - - - + + + + + + + - - - + + + + + + From a322d9fa78c6a1a54124895cdea3c0673d875e75 Mon Sep 17 00:00:00 2001 From: Michael Ward Date: Fri, 20 Dec 2024 11:14:29 -0600 Subject: [PATCH 08/12] merging in PR --- rust/tests/fixed_sized_primitive_array.rs | 72 +++++++++---------- .../sbe/generation/rust/RustGenerator.java | 33 +++++---- .../sbe/generation/rust/RustUtil.java | 6 ++ .../sbe/generation/rust/RustUtilTest.java | 3 +- 4 files changed, 62 insertions(+), 52 deletions(-) diff --git a/rust/tests/fixed_sized_primitive_array.rs b/rust/tests/fixed_sized_primitive_array.rs index 43e82f347d..9b8b3a3c47 100644 --- a/rust/tests/fixed_sized_primitive_array.rs +++ b/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,7 +539,7 @@ 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, @@ -547,7 +547,7 @@ fn test_encode_then_decode_non_u8_unsigned_primitive_slice() { 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, @@ -555,7 +555,7 @@ fn test_encode_then_decode_non_u8_unsigned_primitive_slice() { 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, diff --git a/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/RustGenerator.java b/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/RustGenerator.java index b06f5b1dd1..eb9234ecb2 100644 --- a/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/RustGenerator.java +++ b/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"); diff --git a/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/RustUtil.java b/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/RustUtil.java index 43b9c8ba8a..ae55de1e9e 100644 --- a/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/RustUtil.java +++ b/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/RustUtil.java @@ -17,6 +17,7 @@ import org.agrona.Verify; import uk.co.real_logic.sbe.PrimitiveType; +import uk.co.real_logic.sbe.PrimitiveValue; import uk.co.real_logic.sbe.generation.Generators; import uk.co.real_logic.sbe.generation.rust.RustGenerator.CodecType; import uk.co.real_logic.sbe.ir.Encoding; @@ -65,6 +66,11 @@ static String rustTypeName(final PrimitiveType primitiveType) return TYPE_NAME_BY_PRIMITIVE_TYPE_MAP.get(primitiveType); } + static String generateRustLiteral(final PrimitiveType type, final PrimitiveValue value) + { + return generateRustLiteral(type, value.toString()); + } + static String generateRustLiteral(final PrimitiveType type, final String value) { Verify.notNull(type, "type"); diff --git a/sbe-tool/src/test/java/uk/co/real_logic/sbe/generation/rust/RustUtilTest.java b/sbe-tool/src/test/java/uk/co/real_logic/sbe/generation/rust/RustUtilTest.java index d6d7652b83..34fa845fa9 100644 --- a/sbe-tool/src/test/java/uk/co/real_logic/sbe/generation/rust/RustUtilTest.java +++ b/sbe-tool/src/test/java/uk/co/real_logic/sbe/generation/rust/RustUtilTest.java @@ -88,6 +88,7 @@ void generateRustLiteralsForUnsignedPrimitiveNulls() assertEquals("0xff_u8", generateRustLiteral(UINT8, UINT8.nullValue().toString())); assertEquals("0xffff_u16", generateRustLiteral(UINT16, UINT16.nullValue().toString())); assertEquals("0xffffffff_u32", generateRustLiteral(UINT32, UINT32.nullValue().toString())); + assertEquals("0xffffffffffffffff_u64", generateRustLiteral(UINT64, UINT64.nullValue())); assertEquals("0xffffffffffffffff_u64", generateRustLiteral(UINT64, UINT64.nullValue().toString())); } @@ -100,7 +101,7 @@ void generateRustLiteralNullPrimitiveTypeParam() @Test void generateRustLiteralNullValueParam() { - assertThrows(NullPointerException.class, () -> generateRustLiteral(INT8, null)); + assertThrows(NullPointerException.class, () -> generateRustLiteral(INT8, (String) null)); } @Test From 8527a1072b444b40c7c813e92f8f77a74070176a Mon Sep 17 00:00:00 2001 From: Michael Ward Date: Mon, 23 Dec 2024 09:22:53 -0600 Subject: [PATCH 09/12] [Rust] updated generator to create "_from_iter" and "_zero_padded" functions for primitive array --- rust/tests/extension_test.rs | 2 +- rust/tests/fixed_sized_primitive_array.rs | 42 ++++---- .../sbe/generation/rust/RustGenerator.java | 100 ++++++++++++++---- 3 files changed, 100 insertions(+), 44 deletions(-) diff --git a/rust/tests/extension_test.rs b/rust/tests/extension_test.rs index 2de897272f..ab62a7715c 100644 --- a/rust/tests/extension_test.rs +++ b/rust/tests/extension_test.rs @@ -187,7 +187,7 @@ fn encode_car_from_scratch() -> SbeResult<(usize, Vec)> { 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); diff --git a/rust/tests/fixed_sized_primitive_array.rs b/rust/tests/fixed_sized_primitive_array.rs index 9b8b3a3c47..8542e3d488 100644 --- a/rust/tests/fixed_sized_primitive_array.rs +++ b/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, diff --git a/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/RustGenerator.java b/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/RustGenerator.java index eb9234ecb2..6412649ecc 100644 --- a/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/RustGenerator.java +++ b/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) {\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) {\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( From 16c95aed0037f301c2a6ea26c33d87bcee70eec1 Mon Sep 17 00:00:00 2001 From: Michael Ward Date: Mon, 23 Dec 2024 09:25:49 -0600 Subject: [PATCH 10/12] [Rust] updated generator to create "_from_iter" and "_zero_padded" functions for primitive array --- .../uk/co/real_logic/sbe/generation/rust/RustGenerator.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/RustGenerator.java b/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/RustGenerator.java index 6412649ecc..87d2172862 100644 --- a/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/RustGenerator.java +++ b/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/RustGenerator.java @@ -436,7 +436,7 @@ private static void generatePrimitiveArrayZeroPaddedEncoder( 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 + 1, "self.%s_from_iter(iter);\n", formatFunctionName(name)); indent(sb, level, "}\n\n"); } From 3063dd5f36dc6181bde006aee2623c45cae1e7e5 Mon Sep 17 00:00:00 2001 From: Michael Ward Date: Mon, 23 Dec 2024 09:32:57 -0600 Subject: [PATCH 11/12] fixed formatting issues --- .../sbe/generation/rust/RustGenerator.java | 18 +++++++++--------- .../sbe/generation/rust/RustUtilTest.java | 2 +- 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/RustGenerator.java b/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/RustGenerator.java index 87d2172862..0efc5f97f8 100644 --- a/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/RustGenerator.java +++ b/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/RustGenerator.java @@ -384,10 +384,10 @@ private static void generateRustDoc( } private static void generatePrimitiveArrayFromIterEncoder( - final StringBuilder sb, - final int level, - final Token typeToken, - final String name) throws IOException + final StringBuilder sb, + final int level, + final Token typeToken, + final String name) throws IOException { final Encoding encoding = typeToken.encoding(); final PrimitiveType primitiveType = encoding.primitiveType(); @@ -397,7 +397,7 @@ private static void generatePrimitiveArrayFromIterEncoder( generateRustDoc(sb, level, typeToken, encoding); indent(sb, level, "#[inline]\n"); indent(sb, level, "pub fn %s_from_iter(&mut self, iter: impl Iterator) {\n", - formatFunctionName(name), rustPrimitiveType); + 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"); @@ -417,10 +417,10 @@ private static void generatePrimitiveArrayFromIterEncoder( } private static void generatePrimitiveArrayZeroPaddedEncoder( - final StringBuilder sb, - final int level, - final Token typeToken, - final String name) throws IOException + final StringBuilder sb, + final int level, + final Token typeToken, + final String name) throws IOException { final Encoding encoding = typeToken.encoding(); final PrimitiveType primitiveType = encoding.primitiveType(); diff --git a/sbe-tool/src/test/java/uk/co/real_logic/sbe/generation/rust/RustUtilTest.java b/sbe-tool/src/test/java/uk/co/real_logic/sbe/generation/rust/RustUtilTest.java index 34fa845fa9..6092fb5d48 100644 --- a/sbe-tool/src/test/java/uk/co/real_logic/sbe/generation/rust/RustUtilTest.java +++ b/sbe-tool/src/test/java/uk/co/real_logic/sbe/generation/rust/RustUtilTest.java @@ -101,7 +101,7 @@ void generateRustLiteralNullPrimitiveTypeParam() @Test void generateRustLiteralNullValueParam() { - assertThrows(NullPointerException.class, () -> generateRustLiteral(INT8, (String) null)); + assertThrows(NullPointerException.class, () -> generateRustLiteral(INT8, (String)null)); } @Test From 5b27775d6b3bf8730b8f015a20e17de38bb88f67 Mon Sep 17 00:00:00 2001 From: Michael Ward Date: Tue, 24 Dec 2024 09:18:18 -0600 Subject: [PATCH 12/12] removed unused format argument --- .../uk/co/real_logic/sbe/generation/rust/RustGenerator.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/RustGenerator.java b/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/RustGenerator.java index 0efc5f97f8..d56c680d28 100644 --- a/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/RustGenerator.java +++ b/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/rust/RustGenerator.java @@ -459,8 +459,7 @@ private static void generatePrimitiveArrayEncoder( if (primitiveType.size() == 1) { - indent(sb, level + 1, "buf.put_%s_at(offset + index, value);\n", - rustPrimitiveType, primitiveType.size()); + indent(sb, level + 1, "buf.put_%s_at(offset + index, value);\n", rustPrimitiveType); } else {