[Rust] Updated code generator to resolve Issue #984

build.gradle

@@ -588,6 +588,7 @@ tasks.register('generateRustTestCodecs', JavaExec) {
     args = ['sbe-tool/src/test/resources/issue435.xml',
             'sbe-tool/src/test/resources/issue895.xml',
             'sbe-tool/src/test/resources/issue972.xml',
+            'sbe-tool/src/test/resources/issue984.xml',
             'sbe-tool/src/test/resources/example-bigendian-test-schema.xml',
             'sbe-tool/src/test/resources/nested-composite-name.xml',
     ]

rust/Cargo.toml

@@ -14,6 +14,7 @@ examples_uk_co_real_logic_sbe_benchmarks_fix = { path = "../generated/rust/uk_co
 issue_435 = { path = "../generated/rust/issue435" }
 issue_895 = { path = "../generated/rust/issue895" }
 issue_972 = { path = "../generated/rust/issue972" }
+issue_984 = { path = "../generated/rust/issue984" }
 baseline_bigendian = { path = "../generated/rust/baseline-bigendian" }
 nested_composite_name = { path = "../generated/rust/nested-composite-name" }
 

rust/benches/car_benchmark.rs

@@ -1,6 +1,12 @@
-use car_codec::encoder::*;
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
-use examples_uk_co_real_logic_sbe_benchmarks::*;
+use examples_uk_co_real_logic_sbe_benchmarks::{
+    boolean_type::BooleanType,
+    car_codec::{decoder::*, encoder::*},
+    message_header_codec::MessageHeaderDecoder,
+    model::Model,
+    optional_extras::OptionalExtras,
+    *,
+};
 
 const MANUFACTURER: &[u8] = b"MANUFACTURER";
 const MODEL: &[u8] = b"MODEL";
@@ -36,8 +42,8 @@ fn encode(state: &mut State) -> SbeResult<usize> {
     car.model_year(2005);
     car.serial_number(12345);
     car.available(BooleanType::T);
-    car.vehicle_code([97, 98, 99, 100, 101, 102]); // abcdef
-    car.some_numbers([0, 1, 2, 3, 4]);
+    car.vehicle_code(&[97, 98, 99, 100, 101, 102]); // abcdef
+    car.some_numbers(&[0, 1, 2, 3, 4]);
 
     extras.set_sports_pack(true);
     extras.set_sun_roof(true);
@@ -46,7 +52,7 @@ fn encode(state: &mut State) -> SbeResult<usize> {
     let mut engine = car.engine_encoder();
     engine.capacity(4200);
     engine.num_cylinders(8);
-    engine.manufacturer_code([97, 98, 99]); // abc
+    engine.manufacturer_code(&[97, 98, 99]); // abc
 
     car = engine.parent()?;
     fuel_figures = car.fuel_figures_encoder(3, fuel_figures);

rust/benches/md_benchmark.rs

@@ -1,6 +1,12 @@
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
-use examples_uk_co_real_logic_sbe_benchmarks_fix::*;
-use market_data_incremental_refresh_trades_codec::encoder::*;
+use examples_uk_co_real_logic_sbe_benchmarks_fix::{
+    market_data_incremental_refresh_trades_codec::{encoder::*, *},
+    match_event_indicator::*,
+    md_update_action::*,
+    message_header_codec::*,
+    side::*,
+    *,
+};
 
 struct State {
     buffer: Vec<u8>,

rust/tests/issue_435_test.rs

@@ -1,7 +1,6 @@
-use ::issue_435::*;
 use issue_435::{
     enum_ref::EnumRef, issue_435_codec::*, message_header_codec::MessageHeaderDecoder,
-    set_ref::SetRef,
+    set_ref::SetRef, *,
 };
 
 fn create_encoder(buffer: &mut Vec<u8>) -> Issue435Encoder {

rust/tests/issue_984_test.rs

@@ -0,0 +1,47 @@
+use issue_984::{
+    message_header_codec::MessageHeaderDecoder,
+    simple_message_codec::{encoder::MyGroupEncoder, *},
+    *,
+};
+
+fn create_encoder(buffer: &mut Vec<u8>) -> SimpleMessageEncoder {
+    let simple_msg = SimpleMessageEncoder::default().wrap(
+        WriteBuf::new(buffer.as_mut_slice()),
+        message_header_codec::ENCODED_LENGTH,
+    );
+    let mut header = simple_msg.header(0);
+    header.parent().unwrap()
+}
+
+#[test]
+fn round_trip() -> SbeResult<()> {
+    // encode...
+    let mut buffer = vec![0u8; 256];
+    let mut simple_msg_encoder = create_encoder(&mut buffer);
+    simple_msg_encoder.id(1985);
+
+    let mut my_grp_encoder = simple_msg_encoder.my_group_encoder(1, MyGroupEncoder::default());
+    my_grp_encoder.advance()?;
+    my_grp_encoder.f1(&[1, 2, 3, 4]);
+    my_grp_encoder.f2(&[1, 2, 3, 4, 5]);
+    my_grp_encoder.f3(&[1, 2, 3, 4, 5, 6]);
+
+    // decode...
+    let buf = ReadBuf::new(buffer.as_slice());
+    let header = MessageHeaderDecoder::default().wrap(buf, 0);
+    assert_eq!(SBE_BLOCK_LENGTH, header.block_length());
+    assert_eq!(SBE_SCHEMA_VERSION, header.version());
+    assert_eq!(SBE_TEMPLATE_ID, header.template_id());
+    assert_eq!(SBE_SCHEMA_ID, header.schema_id());
+
+    let simple_msg_decoder = SimpleMessageDecoder::default().header(header);
+    assert_eq!(1985, simple_msg_decoder.id());
+    let mut grp_decoder = simple_msg_decoder.my_group_decoder();
+    assert_eq!(1, grp_decoder.count());
+    grp_decoder.advance()?;
+
+    assert_eq!([1, 2, 3, 4], grp_decoder.f1());
+    assert_eq!([1, 2, 3, 4, 5], grp_decoder.f2());
+    assert_eq!([1, 2, 3, 4, 5, 6], grp_decoder.f3());
+    Ok(())
+}

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

@@ -35,19 +35,23 @@ class LibRsDef
 {
     private final RustOutputManager outputManager;
     private final ByteOrder byteOrder;
+    private final String schemaVersionType;
 
     /**
      * Create a new 'lib.rs' for the library being generated
      *
-     * @param outputManager for generating the codecs to.
-     * @param byteOrder for the Encoding.
+     * @param outputManager     for generating the codecs to.
+     * @param byteOrder         for the Encoding.
+     * @param schemaVersionType for acting_version type
      */
     LibRsDef(
         final RustOutputManager outputManager,
-        final ByteOrder byteOrder)
+        final ByteOrder byteOrder,
+        final String schemaVersionType)
     {
         this.outputManager = outputManager;
         this.byteOrder = byteOrder;
+        this.schemaVersionType = schemaVersionType;
     }
 
     void generate() throws IOException
@@ -82,7 +86,7 @@ void generate() throws IOException
             generateEitherEnum(libRs);
 
             generateEncoderTraits(libRs);
-            generateDecoderTraits(libRs);
+            generateDecoderTraits(schemaVersionType, libRs);
 
             generateReadBuf(libRs, byteOrder);
             generateWriteBuf(libRs, byteOrder);
@@ -101,8 +105,12 @@ static void generateEncoderTraits(final Writer writer) throws IOException
         indent(writer, 0, "}\n\n");
     }
 
-    static void generateDecoderTraits(final Writer writer) throws IOException
+    static void generateDecoderTraits(final String schemaVersionType, final Writer writer) throws IOException
     {
+        indent(writer, 0, "pub trait ActingVersion {\n");
+        indent(writer, 1, "fn acting_version(&self) -> %s;\n", schemaVersionType);
+        indent(writer, 0, "}\n\n");
+
         indent(writer, 0, "pub trait Reader<'a>: Sized {\n");
         indent(writer, 1, "fn get_buf(&self) -> &ReadBuf<'a>;\n");
         indent(writer, 0, "}\n\n");

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

@@ -76,7 +76,7 @@ void generate(
         }
         else
         {
-            RustGenerator.appendImplDecoderTrait(sb, msgTypeName);
+            RustGenerator.appendImplDecoderTrait(schemaVersionType(), sb, msgTypeName);
         }
 
         RustGenerator.appendImplWithLifetimeHeader(sb, msgTypeName); // impl start
@@ -92,7 +92,7 @@ void generate(
             appendMessageHeaderDecoderFn(sb);
 
             RustGenerator.generateDecoderFields(sb, fields, 2);
-            RustGenerator.generateDecoderGroups(sb, groups, 2, this);
+            RustGenerator.generateDecoderGroups(schemaVersionType(), sb, groups, 2, this);
             RustGenerator.generateDecoderVarData(sb, varData, 2, false);
         }
         else