Add support for set helper methods; constant-presence primitives in fields, composites, and groups

Author: ZackPierce

rust/car_example/src/main.rs

@@ -51,6 +51,9 @@ fn decode_car_and_assert_expected_content(buffer: &[u8]) -> CodecResult<()> {
  assert_eq!(0u16, h.version);
  println!("Header read");
 
+ assert_eq!(Model::C, CarFields::discounted_model());
+ assert_eq!(9000u16, Engine::max_rpm());
+ assert_eq!("Petrol", Engine::fuel());
 
  let mut found_fuel_figures = Vec::<FuelFigure>::with_capacity(EXPECTED_FUEL_FIGURES.len());
 
@@ -60,6 +63,10 @@ fn decode_car_and_assert_expected_content(buffer: &[u8]) -> CodecResult<()> {
  assert_eq!(BooleanType::T, fields.available);
  assert_eq!([97_i8, 98, 99, 100, 101, 102], fields.vehicle_code); // abcdef
  assert_eq!([0_u32, 1, 2, 3, 4], fields.some_numbers);
+ assert_eq!(6, fields.extras.0);
+ assert!(fields.extras.get_cruise_control());
+ assert!(fields.extras.get_sports_pack());
+ assert!(!fields.extras.get_sun_roof());
 
  let dec_perf_figures_header = match dec_fuel_figures_header.fuel_figures_individually()? {
  Either::Left(mut dec_ff_members) => {
@@ -153,7 +160,10 @@ fn encode_car_from_scratch() -> CodecResult<Vec<u8>> {
  fields.code = Model::A;
  fields.vehicle_code = [97_i8, 98, 99, 100, 101, 102]; // abcdef
  fields.some_numbers = [0_u32, 1, 2, 3, 4];
- fields.extras = OptionalExtras(6);
+ fields.extras = OptionalExtras::new();
+ fields.extras.set_cruise_control(true)
+ .set_sports_pack(true)
+ .set_sun_roof(false);
  fields.engine = Engine {
  capacity: 2000,
  num_cylinders: 4,

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

@@ -92,9 +92,11 @@ private void generateGroupFieldRepresentations(
  for (final GroupTreeNode node : groupTree)
  {
  appendStructHeader(appendable, node.contextualName + "Member", true);
- appendStructFields(appendable, node.fields);
+ appendStructFields(appendable, node.simpleNamedFields);
  appendable.append("}\n");
 
+ generateConstantAccessorImpl(appendable, node.contextualName + "Member", node.rawFields);
+
  generateGroupFieldRepresentations(appendable, node.groups);
  }
 
@@ -128,7 +130,8 @@ private static Optional<FieldsRepresentationSummary> generateFieldsRepresentatio
  appendStructHeader(writer, representationStruct, true);
  appendStructFields(writer, namedFieldTokens);
  writer.append("}\n");
- // TODO - also implement constants
+
+ generateConstantAccessorImpl(writer, representationStruct, components.fields);
  }
  final int numBytes = components.fields.stream()
  .filter(t -> !t.isConstantEncoding())
@@ -161,8 +164,38 @@ private static void generateSingleBitSet(final List<Token> tokens, final OutputM
  writer.append("#[repr(C,packed)]\n");
  final String rustPrimitiveType = rustTypeName(beginToken.encoding().primitiveType());
  writer.append(format("pub struct %s(pub %s);%n", setType, rustPrimitiveType));
+ writer.append(format("impl %s {\n", setType));
+ indent(writer, 1, "pub fn new() -> Self {\n");
+ indent(writer, 2, "%s(0)\n", setType);
+ indent(writer, 1, "}\n");
 
- // TODO - implementation to extract named choices with methods
+ indent(writer, 1, "pub fn clear(&mut self) -> &mut Self {\n");
+ indent(writer, 2, "self.0 = 0;\n");
+ indent(writer, 2, "self\n");
+ indent(writer, 1, "}\n");
+ for (final Token token : tokens)
+ {
+ if (Signal.CHOICE != token.signal())
+ {
+ continue;
+ }
+ final String choiceName = formatMethodName(token.name());
+ final Encoding encoding = token.encoding();
+ final String choiceBitIndex = encoding.constValue().toString();
+ indent(writer, 1, "pub fn get_%s(&self) -> bool {\n", choiceName);
+ indent(writer, 2, "0 != self.0 & (1 << %s)\n", choiceBitIndex);
+ indent(writer, 1, "}\n", choiceName);
+
+ indent(writer, 1, "pub fn set_%s(&mut self, value: bool) -> &mut Self {\n", choiceName);
+ indent(writer, 2, "self.0 = if value {\n", choiceBitIndex);
+ indent(writer, 3, "self.0 | (1 << %s)\n", choiceBitIndex);
+ indent(writer, 2, "} else {\n");
+ indent(writer, 3, "self.0 & !(1 << %s)\n", choiceBitIndex);
+ indent(writer, 2, "};\n");
+ indent(writer, 2, "self\n");
+ indent(writer, 1, "}\n", choiceName);
+ }
+ writer.append("}\n");
  }
 
  }
@@ -695,7 +728,6 @@ private static List<GroupTreeNode> buildGroupTrees(final String parentTypeName,
 
  final List<Token> fields = new ArrayList<>();
  i = collectFields(groupsTokens, i, fields);
- final List<NamedToken> namedFields = NamedToken.gatherNamedFieldTokens(fields);
 
  final List<Token> childGroups = new ArrayList<>();
  i = collectGroups(groupsTokens, i, childGroups);
@@ -711,7 +743,7 @@ private static List<GroupTreeNode> buildGroupTrees(final String parentTypeName,
  numInGroupType,
  blockLengthType,
  blockLength,
- namedFields,
+ fields,
  varDataSummaries
  );
  groups.add(node);
@@ -746,7 +778,8 @@ static class GroupTreeNode
  final PrimitiveType numInGroupType;
  final PrimitiveType blockLengthType;
  final int blockLength;
- final List<NamedToken> fields;
+ final List<Token> rawFields;
+ final List<NamedToken> simpleNamedFields;
  final List<GroupTreeNode> groups = new ArrayList<>();
  final List<VarDataSummary> varData;
 
@@ -756,7 +789,7 @@ static class GroupTreeNode
  final PrimitiveType numInGroupType,
  final PrimitiveType blockLengthType,
  final int blockLength,
- final List<NamedToken> fields,
+ final List<Token> fields,
  final List<VarDataSummary> varData)
  {
  this.parent = parent;
@@ -765,7 +798,8 @@ static class GroupTreeNode
  this.numInGroupType = numInGroupType;
  this.blockLengthType = blockLengthType;
  this.blockLength = blockLength;
- this.fields = fields;
+ this.rawFields = fields;
+ this.simpleNamedFields = NamedToken.gatherNamedFieldTokens(fields);
  this.varData = varData;
  parent.ifPresent(p -> p.addChild(this));
  }
@@ -1231,10 +1265,7 @@ private static void generateSingleComposite(final List<Token> tokens, final Outp
  appendStructFields(writer, splitTokens.nonConstantEncodingTokens);
  writer.append("}\n");
 
- if (!splitTokens.constantEncodingTokens.isEmpty())
- {
- generateCompositeImplForConstants(formattedTypeName, writer, splitTokens.constantEncodingTokens);
- }
+ generateConstantAccessorImpl(writer, formattedTypeName, getMessageBody(tokens));
  }
  }
 
@@ -1351,20 +1382,42 @@ private static String getRustTypeForPrimitivePossiblyArray(final Token encodingT
  return rustType;
  }
 
- private static void generateCompositeImplForConstants(final String formattedTypeName,
- final Writer writer,
- final List<Token> deferredConstantTokens) throws IOException
+ private static void generateConstantAccessorImpl(final Appendable writer, final String formattedTypeName,
+ final List<Token> unfilteredFields) throws IOException
  {
  writer.append(format("%nimpl %s {%n", formattedTypeName));
- for (final Token constantToken : deferredConstantTokens)
+ for (int i = 0; i < unfilteredFields.size(); )
  {
+ final Token fieldToken = unfilteredFields.get(i);
+ final String name = fieldToken.name();
+ final int componentTokenCount = fieldToken.componentTokenCount();
+ final Token signalToken;
+ if (fieldToken.signal() == BEGIN_FIELD)
+ {
+ if (i > unfilteredFields.size() - 1)
+ {
+ throw new ArrayIndexOutOfBoundsException("BEGIN_FIELD token should be followed by content tokens");
+ }
+ signalToken = unfilteredFields.get(i + 1);
+ } else
+ {
+ signalToken = fieldToken;
+ }
+
+ // Either the field must be marked directly as constant
+ // or it must wrap something that is fully constant
+ if (!(fieldToken.isConstantEncoding() || signalToken.isConstantEncoding()))
+ {
+ i += componentTokenCount;
+ continue;
+ }
  final String constantRustTypeName;
  final String constantRustExpression;
- switch (constantToken.signal())
+ switch (signalToken.signal())
  {
  case ENCODING:
- final String rawValue = constantToken.encoding().constValue().toString();
- if (constantToken.encoding().primitiveType() == PrimitiveType.CHAR)
+ final String rawValue = signalToken.encoding().constValue().toString();
+ if (signalToken.encoding().primitiveType() == PrimitiveType.CHAR)
  {
  // Special case string handling
  constantRustTypeName = "&'static str";
@@ -1373,32 +1426,54 @@ private static void generateCompositeImplForConstants(final String formattedType
 
  } else
  {
- final String constantRustPrimitiveType = RustUtil.rustTypeName(constantToken.encoding()
-  .primitiveType());
- constantRustTypeName = getRustTypeForPrimitivePossiblyArray(constantToken,
-  constantRustPrimitiveType);
- constantRustExpression = generateRustLiteral(constantToken.encoding().primitiveType(),
-  rawValue);
+ final String constantRustPrimitiveType = RustUtil.rustTypeName(signalToken.encoding()
+ .primitiveType());
+ constantRustTypeName = getRustTypeForPrimitivePossiblyArray(signalToken,
+ constantRustPrimitiveType);
+ constantRustExpression = generateRustLiteral(signalToken.encoding().primitiveType(),
+ rawValue);
  }
  break;
  case BEGIN_ENUM:
- // TODO - implement constant enums
- throw new IllegalStateException(format("Unsupported constant presence enum or bitset property " +
- "%s", constantToken.toString()));
+ final String enumType = formatTypeName(signalToken.applicableTypeName());
+ String enumValue = null;
+ for (int j = i; j < unfilteredFields.size(); j++)
+ {
+ final Token searchAhead = unfilteredFields.get(j);
+ if (searchAhead.signal() == VALID_VALUE)
+ {
+ enumValue = searchAhead.name();
+ break;
+ }
+ }
+ if (enumValue == null)
+ {
+ throw new IllegalStateException("Found a constant enum field with incomplete token content");
+ }
+ constantRustTypeName = enumType;
+ constantRustExpression = enumType + "::" + enumValue;
+ break;
  case BEGIN_SET:
  case BEGIN_COMPOSITE:
  default:
  throw new IllegalStateException(format("Unsupported constant presence property " +
-  "%s", constantToken.toString()));
+ "%s", fieldToken.toString()));
  }
- writer.append("\n").append(INDENT).append("#[inline]\n").append(INDENT);
- writer.append(format("pub fn %s() -> %s {%n", formatMethodName(constantToken.name()),
- constantRustTypeName));
- indent(writer, 2).append(constantRustExpression).append("\n");
- indent(writer).append("}\n");
+ appendConstAccessor(writer, name, constantRustTypeName, constantRustExpression);
+ i += componentTokenCount;
  }
 
  writer.append("}\n");
  }
 
+ private static void appendConstAccessor(final Appendable writer, final String name,
+ final String rustTypeName, final String rustExpression) throws IOException
+ {
+ writer.append("\n").append(INDENT).append("#[inline]\n").append(INDENT);
+ writer.append(format("pub fn %s() -> %s {%n", formatMethodName(name),
+ rustTypeName));
+ indent(writer, 2).append(rustExpression).append("\n");
+ indent(writer).append("}\n");
+ }
+
 }

sbe-tool/src/test/java/uk/co/real_logic/sbe/generation/rust/RustGeneratorTest.java

@@ -143,7 +143,7 @@ public void fullGenerateBroadUseCase() throws IOException, InterruptedException
  " C = 67i8,\n" +
  "}\n";
  assertTrue(generatedRust.contains(expectedCharTypeDeclaration));
- assertRustBuildable(generatedRust, Optional.of(BROAD_USE_CASES_SCHEMA));
+ assertRustBuildable(generatedRust, Optional.of("example-schema"));
  }
 
  private File writeCargoFolderWrapper(final String name, final String generatedRust, final File folder) throws
@@ -236,6 +236,7 @@ public void checkValidRustFromAllExampleSchema() throws IOException, Interrupted
  "example-schema",
  "FixBinary",
  "group-with-data-schema",
+ "group-with-constant-fields",
  "issue435",
  "message-block-length-test",
  NESTED_GROUP_SCHEMA,
@@ -248,4 +249,58 @@ public void checkValidRustFromAllExampleSchema() throws IOException, Interrupted
 
 
  }
+
+ @Test
+ public void constantFieldsCase() throws IOException, InterruptedException
+ {
+ final String rust = fullGenerateForResource(outputManager, "group-with-constant-fields");
+ assertContainsSharedImports(rust);
+ final String expectedCharTypeDeclaration =
+ "#[derive(Clone,Copy,Debug,PartialEq,Eq,PartialOrd,Ord,Hash)]\n" +
+ "#[repr(i8)]\n" +
+ "pub enum Model {\n" +
+ " A = 65i8,\n" +
+ " B = 66i8,\n" +
+ " C = 67i8,\n" +
+ "}\n";
+ assertContains(rust, expectedCharTypeDeclaration);
+ final String expectedComposite =
+ "pub struct CompositeWithConst {\n" +
+ " pub w:u8,\n" +
+ "}";
+ assertContains(rust, expectedComposite);
+ assertContains(rust, "impl CompositeWithConst {");
+ assertContains(rust, " pub fn x() -> u8 {\n" +
+ " 250u8\n }");
+ assertContains(rust, " pub fn y() -> u16 {\n" +
+ " 9000u16\n }");
+ assertContains(rust, "pub struct ConstantsGaloreFields {\n" +
+ " pub a:u8,\n" +
+ " pub e:CompositeWithConst,\n}");
+ assertContains(rust, "impl ConstantsGaloreFields {");
+ assertContains(rust, " pub fn b() -> u16 {\n" +
+ " 9000u16\n }");
+ assertContains(rust, " pub fn c() -> Model {\n" +
+ " Model::C\n }");
+ assertContains(rust, " pub fn d() -> u16 {\n" +
+ " 9000u16\n }");
+ assertContains(rust, "pub struct ConstantsGaloreFMember {\n" +
+ " pub g:u8,\n" +
+ " pub h:CompositeWithConst,\n}");
+ assertContains(rust, "impl ConstantsGaloreFMember {");
+ assertContains(rust, " pub fn i() -> u16 {\n" +
+ " 9000u16\n }");
+ assertContains(rust, " pub fn j() -> u16 {\n" +
+ " 9000u16\n }");
+ assertContains(rust, " pub fn k() -> Model {\n" +
+ " Model::C\n }");
+ assertContains(rust, " pub fn l() -> &'static str {\n" +
+ " \"Huzzah\"\n }");
+ assertRustBuildable(rust, Optional.of("group-with-constant-fields"));
+ }
+
+ private static void assertContains(final String haystack, final String needle)
+ {
+ assertTrue(String.format("Did not contain %s", needle), haystack.contains(needle));
+ }
 }