How to use

GenerationUtil

in

uk.co.real_logic.sbe.ir

private void generateGroups(final StringBuilder sb, final List<Token> tokens, final String prefix)
{
  for (int i = 0, size = tokens.size(); i < size; i++)
  {
    final Token groupToken = tokens.get(i);
    if (groupToken.signal() != Signal.BEGIN_GROUP)
    {
      throw new IllegalStateException("tokens must begin with BEGIN_GROUP: token=" + groupToken);
    }
    // Make a unique Group name by adding our parent
    final String groupName = prefix + formatTypeName(groupToken.name());
    ++i;
    final int groupHeaderTokenCount = tokens.get(i).componentTokenCount();
    i += groupHeaderTokenCount;
    final List<Token> fields = new ArrayList<>();
    i = collectFields(tokens, i, fields);
    generateFields(sb, groupName, fields);
    final List<Token> groups = new ArrayList<>();
    i = collectGroups(tokens, i, groups);
    generateGroups(sb, groups, groupName);
    final List<Token> varData = new ArrayList<>();
    i = collectVarData(tokens, i, varData);
    generateVarData(sb, formatTypeName(groupName), varData);
  }
}

  public static MessageComponents collectMessageComponents(final List<Token> tokens)
  {
    final Token msgToken = tokens.get(0);
    final List<Token> messageBody = GenerationUtil.getMessageBody(tokens);

    int i = 0;
    final List<Token> fields = new ArrayList<>();
    i = GenerationUtil.collectFields(messageBody, i, fields);

    final List<Token> groups = new ArrayList<>();
    i = GenerationUtil.collectGroups(messageBody, i, groups);

    final List<Token> varData = new ArrayList<>();
    GenerationUtil.collectVarData(messageBody, i, varData);

    return new MessageComponents(msgToken, fields, groups, varData);
  }
}

public static int collectVarData(final List<Token> tokens, final int index, final List<Token> varData)
{
  return collect(Signal.BEGIN_VAR_DATA, tokens, index, varData);
}

private void generateEnum(final List<Token> tokens) throws IOException
{
  final Token enumToken = tokens.get(0);
  final String enumName = formatClassName(enumToken.applicableTypeName());
  try (Writer out = outputManager.createOutput(enumName))
  {
    out.append(generateEnumFileHeader(ir.applicableNamespace()));
    out.append(generateEnumDeclaration(enumName, enumToken));
    out.append(generateEnumValues(getMessageBody(tokens)));
    out.append(generateEnumBody(enumToken, enumName));
    out.append(generateEnumLookupMethod(getMessageBody(tokens), enumName));
    out.append("}\n");
  }
}

public void generate() throws IOException
{
  generateMessageHeaderStub();
  generateTypeStubs();
  for (final List<Token> tokens : ir.messages())
  {
    final Token msgToken = tokens.get(0);
    final List<Token> messageBody = getMessageBody(tokens);
    int offset = 0;
    final List<Token> rootFields = new ArrayList<>();
    offset = collectRootFields(messageBody, offset, rootFields);
    final List<Token> groups = new ArrayList<>();
    offset = collectGroups(messageBody, offset, groups);
    final List<Token> varData = messageBody.subList(offset, messageBody.size());
    generateDecoder(groups, rootFields, varData, msgToken);
    generateEncoder(groups, rootFields, varData, msgToken);
  }
}

private CharSequence generateChoiceDecoders(final List<Token> tokens)
{
  return concatTokens(
    tokens,
    Signal.CHOICE,
    (token) ->
    {
      final String choiceName = formatPropertyName(token.name());
      final Encoding encoding = token.encoding();
      final String choiceBitIndex = encoding.constValue().toString();
      final String byteOrderStr = byteOrderString(encoding);
      final PrimitiveType primitiveType = encoding.primitiveType();
      final String argType = bitsetArgType(primitiveType);
      return String.format("\n" +
        "%1$s" +
        "    public boolean %2$s()\n" +
        "    {\n" +
        "        return %3$s;\n" +
        "    }\n\n" +
        "    public static boolean %2$s(final %4$s value)\n" +
        "    {\n" +
        "        return %5$s;\n" +
        "    }\n",
        generateOptionDecodeJavadoc(INDENT, token),
        choiceName,
        generateChoiceGet(primitiveType, choiceBitIndex, byteOrderStr),
        argType,
        generateStaticChoiceGet(primitiveType, choiceBitIndex));
    });
}

public void generate() throws IOException
{
  generateMessageHeaderStub();
  final List<String> typesToInclude = generateTypeStubs();
  for (final List<Token> tokens : ir.messages())
  {
    final Token msgToken = tokens.get(0);
    final String className = formatClassName(msgToken.name());
    try (final Writer out = outputManager.createOutput(className))
    {
      out.append(generateFileHeader(ir.applicableNamespace().replace('.', '_'), className, typesToInclude));
      out.append(generateClassDeclaration(className));
      out.append(generateMessageFlyweightCode(className, msgToken));
      final List<Token> messageBody = tokens.subList(1, tokens.size() - 1);
      int offset = 0;
      final List<Token> rootFields = new ArrayList<>();
      offset = collectRootFields(messageBody, offset, rootFields);
      out.append(generateFields(className, rootFields, BASE_INDENT));
      final List<Token> groups = new ArrayList<>();
      offset = collectGroups(messageBody, offset, groups);
      final StringBuilder sb = new StringBuilder();
      generateGroups(sb, groups, 0, BASE_INDENT);
      out.append(sb);
      final List<Token> varData = messageBody.subList(offset, messageBody.size());
      out.append(generateVarData(varData));
      out.append("};\n}\n#endif\n");
    }
  }
}

groupName,
parentMessageClassName,
findSubGroupNames(subGroupTokens),
indent,
dimensionHeaderLen);

private void generateComposite(final List<Token> tokens) throws IOException
{
  final Token token = tokens.get(0);
  final String compositeName = formatClassName(token.name());
  final String decoderName = decoderName(compositeName);
  final String encoderName = encoderName(compositeName);
  final List<Token> messageBody = getMessageBody(tokens);
  try (final Writer out = outputManager.createOutput(decoderName))
  {
    generateFixedFlyweightHeader(token, decoderName, out, readOnlyBuffer, fullReadOnlyBuffer);
    out.append(concatEncodingTokens(messageBody,
      (tok) -> generatePrimitiveDecoder(tok.name(), tok, BASE_INDENT)));
    out.append("}\n");
  }
  try (final Writer out = outputManager.createOutput(encoderName))
  {
    generateFixedFlyweightHeader(token, encoderName, out, mutableBuffer, fullMutableBuffer);
    out.append(concatEncodingTokens(messageBody,
      (tok) -> generatePrimitiveEncoder(encoderName, tok.name(), tok, BASE_INDENT)));
    out.append("}\n");
  }
}

Separators.FIELD.appendToGeneratedBuilder(sb, indent, "builder");
i = findEndSignal(groups, i, Signal.END_GROUP, groupToken.name());

private static void generateEnum(final List<Token> enumTokens, final OutputManager outputManager)
  throws IOException
{
  final String originalEnumName = enumTokens.get(0).applicableTypeName();
  final String enumRustName = formatTypeName(originalEnumName);
  try (Writer writer = outputManager.createOutput("Enum " + enumRustName))
  {
    final List<Token> messageBody = getMessageBody(enumTokens);
    if (messageBody.isEmpty())
    {
      throw new IllegalArgumentException("No valid values provided for enum " + originalEnumName);
    }
    writer.append("#[derive(Clone,Copy,Debug,PartialEq,Eq,PartialOrd,Ord,Hash)]").append("\n");
    final String rustReprTypeName = rustTypeName(messageBody.get(0).encoding().primitiveType());
    writer.append(format("#[repr(%s)]",
      rustReprTypeName)).append("\n");
    writer.append("pub enum ").append(enumRustName).append(" {\n");
    for (final Token token : messageBody)
    {
      final Encoding encoding = token.encoding();
      final String literal = generateRustLiteral(encoding.primitiveType(), encoding.constValue().toString());
      indent(writer, 1).append(token.name())
        .append(" = ")
        .append(literal)
        .append(",\n");
    }
    writer.append("}\n");
  }
}

private CharSequence generateChoiceEncoders(final String bitSetClassName, final List<Token> tokens)
  return concatTokens(
    tokens,
    Signal.CHOICE,

public void generate() throws IOException
{
  generateMessageHeaderStub();
  final List<String> typesToInclude = generateTypeStubs();
  for (final List<Token> tokens : ir.messages())
  {
    final Token msgToken = tokens.get(0);
    final String className = formatClassName(msgToken.name());
    try (final Writer out = outputManager.createOutput(className))
    {
      out.append(generateFileHeader(ir.applicableNamespace().replace('.', '_'), typesToInclude));
      out.append(generateClassDeclaration(className));
      out.append(generateMessageFlyweightCode(msgToken));
      final List<Token> messageBody = tokens.subList(1, tokens.size() - 1);
      int offset = 0;
      final List<Token> rootFields = new ArrayList<>();
      offset = collectRootFields(messageBody, offset, rootFields);
      out.append(generateFields(className, rootFields, BASE_INDENT));
      final List<Token> groups = new ArrayList<>();
      offset = collectGroups(messageBody, offset, groups);
      final StringBuilder sb = new StringBuilder();
      generateGroups(sb, groups, 0, BASE_INDENT);
      out.append(sb);
      final List<Token> varData = messageBody.subList(offset, messageBody.size());
      out.append(generateVarData(varData));
    }
  }
}

groupName,
parentMessageClassName,
findSubGroupNames(subGroupTokens),
ind,
dimensionHeaderSize);

Separators.FIELD.appendToGeneratedBuilder(sb, indent, "builder");
i = findEndSignal(groups, i, Signal.END_GROUP, groupToken.name());

private void generateGroups(
  final StringBuilder sb,
  final String parentMessageClassName,
  final List<Token> tokens,
  final String indent)
{
  for (int i = 0, size = tokens.size(); i < size; i++)
  {
    final Token groupToken = tokens.get(i);
    if (groupToken.signal() != Signal.BEGIN_GROUP)
    {
      throw new IllegalStateException("tokens must begin with BEGIN_GROUP: token=" + groupToken);
    }
    final String groupName = groupToken.name();
    sb.append(generateGroupProperty(groupName, groupToken, indent + INDENT));
    generateGroupClassHeader(sb, groupName, parentMessageClassName, tokens, i, indent + INDENT);
    i++;
    i += tokens.get(i).componentTokenCount();
    final List<Token> fields = new ArrayList<>();
    i = collectFields(tokens, i, fields);
    sb.append(generateFields(fields, indent + INDENT));
    final List<Token> groups = new ArrayList<>();
    i = collectGroups(tokens, i, groups);
    generateGroups(sb, parentMessageClassName, groups, indent + INDENT);
    final List<Token> varData = new ArrayList<>();
    i = collectVarData(tokens, i, varData);
    sb.append(generateVarData(varData, indent + INDENT + INDENT));
    sb.append(indent).append(INDENT + "}\n");
  }
}

public void generate() throws IOException
{
  generateTypeStubs();
  generateMessageHeaderStub();
  for (final List<Token> tokens : ir.messages())
  {
    final Token msgToken = tokens.get(0);
    final List<Token> messageBody = getMessageBody(tokens);
    int i = 0;
    final List<Token> fields = new ArrayList<>();
    i = collectFields(messageBody, i, fields);
    final List<Token> groups = new ArrayList<>();
    i = collectGroups(messageBody, i, groups);
    final List<Token> varData = new ArrayList<>();
    collectVarData(messageBody, i, varData);
    generateDecoder(BASE_INDENT, fields, groups, varData, msgToken);
    generateEncoder(BASE_INDENT, fields, groups, varData, msgToken);
  }
}

private static void generateSingleComposite(final List<Token> tokens, final OutputManager outputManager)
  throws IOException
{
  final Token beginToken = tokens.get(0);
  final String originalTypeName = beginToken.applicableTypeName();
  final String formattedTypeName = formatTypeName(originalTypeName);
  final SplitCompositeTokens splitTokens = SplitCompositeTokens.splitInnerTokens(tokens);
  try (Writer writer = outputManager.createOutput(formattedTypeName))
  {
    appendStructHeader(writer, formattedTypeName, true);
    appendStructFields(writer, splitTokens.nonConstantEncodingTokens());
    writer.append("}\n");
    generateConstantAccessorImpl(writer, formattedTypeName, getMessageBody(tokens));
  }
}

public static CharSequence concatEncodingTokens(
  final List<Token> tokens, final Function<Token, CharSequence> mapper)
{
  return concatTokens(tokens, Signal.ENCODING, mapper);
}

public static int collectFields(final List<Token> tokens, final int index, final List<Token> fields)
{
  return collect(Signal.BEGIN_FIELD, tokens, index, fields);
}