feat(rust): recursively call nullify_optional_fields on composites

Author: Leonardo Arcari

rust/tests/optional_field_nullify_test.rs

@@ -387,33 +387,46 @@ fn nullify_optional_fields_sets_optional_enum_field_to_null_value() -> TestResul
     control_encoder.optional_enum_opt(Some(OenEnumType::One));
     // This field is required, even if its enum type encoding is optional.
     control_encoder.required_enum_from_optional_type(OenOptionalEncodingEnumType::Alpha);
+    let mut control_composite = control_encoder.optional_composite_encoder();
+    control_composite.optional_counter_opt(Some(77));
+    let _control_encoder = control_composite.parent()?;
 
     let control_decoder = decode_optional_enum_nullify(control_buffer.as_slice());
     assert_eq!(OenEnumType::One, control_decoder.optional_enum());
     assert_eq!(
         OenOptionalEncodingEnumType::Alpha,
         control_decoder.required_enum_from_optional_type()
     );
+    let control_composite = control_decoder.optional_composite_decoder();
+    assert_eq!(Some(77), control_composite.optional_counter());
 
     let mut none_buffer = vec![0u8; 256];
     let mut none_encoder = create_optional_enum_nullify_encoder(&mut none_buffer);
     none_encoder.optional_enum_opt(None);
     none_encoder.required_enum_from_optional_type(OenOptionalEncodingEnumType::Beta);
+    let mut none_composite = none_encoder.optional_composite_encoder();
+    none_composite.optional_counter_opt(None);
+    let _none_encoder = none_composite.parent()?;
 
     let none_decoder = decode_optional_enum_nullify(none_buffer.as_slice());
     assert_eq!(OenEnumType::NullVal, none_decoder.optional_enum());
     assert_eq!(
         OenOptionalEncodingEnumType::Beta,
         none_decoder.required_enum_from_optional_type()
     );
+    let none_composite = none_decoder.optional_composite_decoder();
+    assert_eq!(None, none_composite.optional_counter());
 
     let mut nullified_buffer = vec![0u8; 256];
     let mut nullified_encoder = create_optional_enum_nullify_encoder(&mut nullified_buffer);
     nullified_encoder.optional_enum_opt(Some(OenEnumType::Two));
     nullified_encoder.required_enum_from_optional_type(OenOptionalEncodingEnumType::Beta);
+    let mut nullified_composite = nullified_encoder.optional_composite_encoder();
+    nullified_composite.optional_counter_opt(Some(88));
+    nullified_encoder = nullified_composite.parent()?;
     // This is the behavior under test: nullify should route through *_opt(None)
-    // only for field-optional members, so `optional_enum` becomes NullVal while
-    // the required field remains unchanged even if its enum type encoding is optional.
+    // and recurse into composite fields, so `optional_enum` and composite optional
+    // members become null while required fields remain unchanged.
     nullified_encoder.nullify_optional_fields();
 
     let nullified_decoder = decode_optional_enum_nullify(nullified_buffer.as_slice());
@@ -422,6 +435,8 @@ fn nullify_optional_fields_sets_optional_enum_field_to_null_value() -> TestResul
         OenOptionalEncodingEnumType::Beta,
         nullified_decoder.required_enum_from_optional_type()
     );
+    let nullified_composite = nullified_decoder.optional_composite_decoder();
+    assert_eq!(None, nullified_composite.optional_counter());
 
     Ok(())
 }

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

@@ -72,8 +72,8 @@ void generate(
 
         if (codecType == Encoder)
         {
-            final List<String> optionalFields = RustGenerator.getNullifyOptionalFields(fields);
-            RustGenerator.appendImplEncoderTrait(sb, msgTypeName, optionalFields);
+            final RustGenerator.NullifyTargets nullifyTargets = RustGenerator.getNullifyTargets(fields);
+            RustGenerator.appendImplEncoderTrait(sb, msgTypeName, nullifyTargets);
         }
         else
         {

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

@@ -82,6 +82,17 @@ interface ParentDef
         SubGroup addSubGroup(String name, int level, Token groupToken);
     }
 
+    static final class NullifyTargets
+    {
+        final List<String> optionalFields = new ArrayList<>();
+        final List<String> compositeFieldEncoders = new ArrayList<>();
+
+        boolean isEmpty()
+        {
+            return optionalFields.isEmpty() && compositeFieldEncoders.isEmpty();
+        }
+    }
+
     private final Ir ir;
     private final RustOutputManager outputManager;
     private final String crateVersion;
@@ -224,9 +235,9 @@ static String getBufOffset(final Token token)
         return "offset";
     }
 
-    static List<String> getNullifyOptionalFields(final List<Token> tokens)
+    static NullifyTargets getNullifyTargets(final List<Token> tokens)
     {
-        final List<String> optionalFields = new ArrayList<>();
+        final NullifyTargets targets = new NullifyTargets();
         Generators.forEachField(
             tokens,
             (fieldToken, typeToken) ->
@@ -237,16 +248,20 @@ static List<String> getNullifyOptionalFields(final List<Token> tokens)
                 {
                     if (isOptionalPrimitiveScalar(typeToken))
                     {
-                        optionalFields.add(fieldName);
+                        targets.optionalFields.add(fieldName);
                     }
                 }
                 else if (signal == BEGIN_ENUM &&
                     isOptionalEnum(typeToken, fieldToken))
                 {
-                    optionalFields.add(fieldName);
+                    targets.optionalFields.add(fieldName);
+                }
+                else if (signal == Signal.BEGIN_COMPOSITE)
+                {
+                    targets.compositeFieldEncoders.add(compositeEncoderAccessorName(fieldToken.name()));
                 }
             });
-        return optionalFields;
+        return targets;
     }
 
     static void generateEncoderFields(
@@ -297,17 +312,53 @@ static void generateEncoderFields(
     static void generateNullifyOptionalFieldsMethod(
         final Appendable out,
         final int level,
-        final List<String> optionalFields) throws IOException
+        final NullifyTargets targets) throws IOException
     {
         indent(out, level, "/// Set all optional fields to their null values.\n");
         indent(out, level, "#[inline]\n");
         indent(out, level, "pub fn nullify_optional_fields(&mut self) -> &mut Self {\n");
-        for (final String field : optionalFields)
+        appendNullifyOptionalFieldsBody(out, level + 1, targets);
+        indent(out, level + 1, "self\n");
+        indent(out, level, "}\n\n");
+    }
+
+    private static void appendNullifyOptionalFieldsBody(
+        final Appendable out,
+        final int level,
+        final NullifyTargets targets) throws IOException
+    {
+        for (final String field : targets.optionalFields)
         {
-            indent(out, level + 1, "self.%s_opt(None);\n", field);
+            indent(out, level, "self.%s_opt(None);\n", field);
         }
+
+        for (final String compositeFieldEncoder : targets.compositeFieldEncoders)
+        {
+            indent(out, level, "{\n");
+            indent(out, level + 1, "let mut composite_encoder = core::mem::take(self).%s();\n", compositeFieldEncoder);
+            indent(out, level + 1, "composite_encoder.nullify_optional_fields();\n");
+            indent(out, level + 1, "*self = composite_encoder.parent().expect(\"parent missing\");\n");
+            indent(out, level, "}\n");
+        }
+    }
+
+    private static void appendTraitNullifyOptionalFieldsMethod(
+        final Appendable out,
+        final int level,
+        final NullifyTargets targets) throws IOException
+    {
+        if (targets.isEmpty())
+        {
+            return;
+        }
+
+        indent(out, 0, "\n");
+        indent(out, level, "/// Set all optional fields to their 'null' values.\n");
+        indent(out, level, "#[inline]\n");
+        indent(out, level, "fn nullify_optional_fields(&mut self) -> &mut Self {\n");
+        appendNullifyOptionalFieldsBody(out, level + 1, targets);
         indent(out, level + 1, "self\n");
-        indent(out, level, "}\n\n");
+        indent(out, level, "}\n");
     }
 
     private static boolean isOptionalPrimitiveScalar(final Token typeToken)
@@ -327,6 +378,11 @@ private static String rustEnumType(final Token typeToken)
         return format("%s::%s", toLowerSnakeCase(enumTypeName), formatStructName(enumTypeName));
     }
 
+    private static String compositeEncoderAccessorName(final String name)
+    {
+        return toLowerSnakeCase(encoderName(name));
+    }
+
     static void generateEncoderGroups(
         final StringBuilder sb,
         final List<Token> tokens,
@@ -734,7 +790,7 @@ private static void generateCompositeEncoder(
         final Token typeToken,
         final String name) throws IOException
     {
-        final String encoderName = toLowerSnakeCase(encoderName(name));
+        final String encoderName = compositeEncoderAccessorName(name);
         final String encoderTypeName = format("%s::%s",
             codecModName(typeToken.referencedName() == null ? typeToken.name() : typeToken.referencedName()),
             encoderName(formatStructName(typeToken.applicableTypeName())));
@@ -1381,7 +1437,7 @@ private static void generateSingleBitSet(
     static void appendImplEncoderTrait(
         final Appendable out,
         final String typeName,
-        final List<String> optionalFields) throws IOException
+        final NullifyTargets targets) throws IOException
     {
         indent(out, 1, "impl<%s> %s for %s {\n", BUF_LIFETIME, withBufLifetime("Writer"), withBufLifetime(typeName));
         indent(out, 2, "#[inline]\n");
@@ -1401,19 +1457,7 @@ static void appendImplEncoderTrait(
         indent(out, 3, "self.limit = limit;\n");
         indent(out, 2, "}\n");
 
-        if (!optionalFields.isEmpty())
-        {
-            indent(out, 0, "\n");
-            indent(out, 2, "/// Set all optional fields to their 'null' values.\n");
-            indent(out, 2, "#[inline]\n");
-            indent(out, 2, "fn nullify_optional_fields(&mut self) -> &mut Self {\n");
-            for (final String field : optionalFields)
-            {
-                indent(out, 3, "self.%s_opt(None);\n", field);
-            }
-            indent(out, 3, "self\n");
-            indent(out, 2, "}\n");
-        }
+        appendTraitNullifyOptionalFieldsMethod(out, 2, targets);
 
         indent(out, 1, "}\n\n");
     }
@@ -1686,7 +1730,7 @@ static void appendImplEncoderForComposite(
         final Appendable out,
         final int level,
         final String name,
-        final List<String> optionalFields) throws IOException
+        final NullifyTargets targets) throws IOException
     {
         appendImplWriterForComposite(out, level, name);
 
@@ -1702,19 +1746,7 @@ static void appendImplEncoderForComposite(
         indent(out, level + 2, "self.parent.as_mut().expect(\"parent missing\").set_limit(limit);\n");
         indent(out, level + 1, "}\n");
 
-        if (!optionalFields.isEmpty())
-        {
-            indent(out, 0, "\n");
-            indent(out, 2, "/// Set all optional fields to their 'null' values.\n");
-            indent(out, 2, "#[inline]\n");
-            indent(out, 2, "fn nullify_optional_fields(&mut self) -> &mut Self {\n");
-            for (final String field : optionalFields)
-            {
-                indent(out, 3, "self.%s_opt(None);\n", field);
-            }
-            indent(out, 3, "self\n");
-            indent(out, 2, "}\n");
-        }
+        appendTraitNullifyOptionalFieldsMethod(out, 2, targets);
 
         indent(out, level, "}\n\n");
     }
@@ -1800,7 +1832,7 @@ private static void generateCompositeEncoder(
         indent(out, 3, "self.parent.take().ok_or(SbeErr::ParentNotSet)\n");
         indent(out, 2, "}\n\n");
 
-        final List<String> optionalFields = new ArrayList<>();
+        final NullifyTargets nullifyTargets = new NullifyTargets();
         for (int i = 1, end = tokens.size() - 1; i < end; )
         {
             final Token encodingToken = tokens.get(i);
@@ -1814,22 +1846,23 @@ private static void generateCompositeEncoder(
                     {
                         generateOptionalPrimitiveEncoder(sb, 2, encodingToken, encodingToken.name(),
                             encodingToken.encoding());
-                        optionalFields.add(formatFunctionName(encodingToken.name()));
+                        nullifyTargets.optionalFields.add(formatFunctionName(encodingToken.name()));
                     }
                     break;
                 case BEGIN_ENUM:
                     generateEnumEncoder(sb, 2, encodingToken, encodingToken, encodingToken.name());
                     if (isOptionalEnum(encodingToken, encodingToken))
                     {
                         generateOptionalEnumEncoder(sb, 2, encodingToken, encodingToken.name());
-                        optionalFields.add(formatFunctionName(encodingToken.name()));
+                        nullifyTargets.optionalFields.add(formatFunctionName(encodingToken.name()));
                     }
                     break;
                 case BEGIN_SET:
                     generateBitSetEncoder(sb, 2, encodingToken, encodingToken.name());
                     break;
                 case BEGIN_COMPOSITE:
                     generateCompositeEncoder(sb, 2, encodingToken, encodingToken.name());
+                    nullifyTargets.compositeFieldEncoders.add(compositeEncoderAccessorName(encodingToken.name()));
                     break;
                 default:
                     break;
@@ -1839,7 +1872,7 @@ private static void generateCompositeEncoder(
             i += encodingToken.componentTokenCount();
         }
 
-        generateNullifyOptionalFieldsMethod(out, 2, optionalFields);
+        generateNullifyOptionalFieldsMethod(out, 2, nullifyTargets);
         indent(out, 1, "}\n"); // end impl
         indent(out, 0, "} // end encoder mod \n");
     }

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

@@ -72,8 +72,8 @@ void generateEncoder(
         indent(sb, level, "initial_limit: usize,\n");
         indent(sb, level - 1, "}\n\n");
 
-        final List<String> optionalFields = RustGenerator.getNullifyOptionalFields(fields);
-        RustGenerator.appendImplEncoderForComposite(sb, level - 1, name, optionalFields);
+        final RustGenerator.NullifyTargets nullifyTargets = RustGenerator.getNullifyTargets(fields);
+        RustGenerator.appendImplEncoderForComposite(sb, level - 1, name, nullifyTargets);
 
         // define impl...
         indent(sb, level - 1, "impl<'a, P> %s<P> where P: Encoder<'a> + Default {\n", name);

sbe-tool/src/test/resources/optional_enum_nullify.xml

@@ -23,9 +23,13 @@
             <validValue name="Alpha">3</validValue>
             <validValue name="Beta">4</validValue>
         </enum>
+        <composite name="OptionalComposite">
+            <type name="optionalCounter" primitiveType="uint16" presence="optional" nullValue="0"/>
+        </composite>
     </types>
     <sbe:message name="optionalEnumNullify" id="1" description="optional enum nullify test">
         <field name="optionalEnum" type="EnumType" id="1" presence="optional"/>
         <field name="requiredEnumFromOptionalType" type="OptionalEncodingEnumType" id="2"/>
+        <field name="optionalComposite" type="OptionalComposite" id="3"/>
     </sbe:message>
 </sbe:messageSchema>