How to use uk.co.real_logic.sbe.ir

private static PrimitiveValue constOrNotPresentValue(final Token token, final int actingVersion)
{
  if (token.isConstantEncoding())
  {
    return token.encoding().constValue();
  }
  else if (token.isOptionalEncoding() && actingVersion < token.version())
  {
    return token.encoding().applicableNullValue();
  }
  return null;
}

private void encodeTokenList(final List<Token> tokenList)
{
  for (final Token token : tokenList)
  {
    write(buffer, encodeToken(token));
  }
}

  private static Ir decodeIr(final ByteBuffer buffer)
  {
    try (IrDecoder irDecoder = new IrDecoder(buffer))
    {
      return irDecoder.decode();
    }
  }
}

public int encode()
{
  Verify.notNull(ir, "ir");
  write(buffer, encodeFrame());
  encodeTokenList(ir.headerStructure().tokens());
  ir.messages().forEach(this::encodeTokenList);
  return totalLength;
}

private CharSequence generateEnumValues(final List<Token> tokens, final Token encodingToken)
{
  final StringBuilder sb = new StringBuilder();
  final Encoding encoding = encodingToken.encoding();
  for (final Token token : tokens)
  {
    sb.append(INDENT).append(INDENT).append(token.name()).append(" = ")
     .append(token.encoding().constValue()).append(",\n");
  }
  final PrimitiveValue nullVal = encoding.applicableNullValue();
  sb.append(INDENT).append(INDENT).append("NULL_VALUE = ").append(nullVal).append("\n");
  return sb;
}

  private static Token dummyToken(final Signal signal, final String name)
  {
    return new Token(
      signal,
      name,
      name,
      name,
      0,
      0,
      0,
      0,
      0,
      1,
      new Encoding.Builder().primitiveType(PrimitiveType.INT32).build());
  }
}

public void generateMessageHeaderStub() throws IOException
{
  generateComposite(ir.headerStructure().tokens());
}

private static PrimitiveType findPrimitiveByTokenName(final List<Token> tokens, final String targetName)
{
  return findPrimitiveTokenByTokenName(tokens, targetName).encoding().primitiveType();
}

private void generateCompositeFlyweightHeader(
  final Token token,
  final String typeName,
  final Writer out,
  final String buffer,
  final String fqBuffer,
  final String implementsString) throws IOException
{
  out.append(generateFileHeader(ir.applicableNamespace(), fqBuffer));
  out.append(generateDeclaration(typeName, implementsString, token));
  out.append(generateFixedFlyweightCode(typeName, token.encodedLength(), buffer));
}

public boolean isOptionalEncoding()
{
  return encoding.presence() == OPTIONAL;
}

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 static PrimitiveValue constOrNotPresentValue(final Token token, final int actingVersion)
{
  final Encoding encoding = token.encoding();
  if (token.isConstantEncoding())
  {
    return encoding.constValue();
  }
  else if (token.isOptionalEncoding() && actingVersion < token.version())
  {
    return encoding.applicableNullValue();
  }
  return null;
}

  private static Ir decodeIr(final ByteBuffer buffer)
  {
    try (IrDecoder irDecoder = new IrDecoder(buffer))
    {
      return irDecoder.decode();
    }
  }
}

public void generateMessageHeaderStub() throws IOException
{
  generateComposite(ir.headerStructure().tokens());
}

private static String primitiveTypeName(final Token token)
{
  return javaTypeName(token.encoding().primitiveType());
}

public boolean isConstantEncoding()
{
  return encoding.presence() == CONSTANT;
}

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

  private static Ir decodeIr(final ByteBuffer buffer)
  {
    try (IrDecoder irDecoder = new IrDecoder(buffer))
    {
      return irDecoder.decode();
    }
  }
}

public void generateMessageHeaderStub() throws IOException
{
  generateComposite(ir.headerStructure().tokens());
}

public static int collectGroups(final List<Token> tokens, final int index, final List<Token> groups)
{
  return collect(Signal.BEGIN_GROUP, tokens, index, groups);
}