private static Token findPrimitiveTokenByTokenName(final List<Token> tokens, final String targetName) { for (final Token token : tokens) { if (targetName.equalsIgnoreCase(token.name()) && token.encoding() != null && token.encoding().primitiveType() != null) { return token; } } throw new IllegalStateException(format("%s not specified for group", targetName)); }
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 void generateOptionalInitPrimitive( final StringBuilder sb, final String varName, final Token token) { final Encoding encoding = token.encoding(); // Optional items get initialized to their NullValue sb.append(String.format( "\t%1$s = %2$s\n", varName, generateNullValueLiteral(encoding.primitiveType(), encoding))); }
private void generateCharacterEncoding( final StringBuilder sb, final String typeName, final String propertyName, final Token token) { if (token.encoding().primitiveType() == CHAR && token.arrayLength() > 1) { sb.append(String.format( "\nfunc (%1$s *%2$s) %3$sCharacterEncoding() string {\n" + "\treturn \"%4$s\"\n" + "}\n", Character.toLowerCase(typeName.charAt(0)), typeName, propertyName, token.encoding().characterEncoding())); } }
private void captureEncodings(final List<Token> tokens) { for (final Token token : tokens) { switch (token.name()) { case BLOCK_LENGTH: blockLengthType = token.encoding().primitiveType(); break; case TEMPLATE_ID: templateIdType = token.encoding().primitiveType(); break; case SCHEMA_ID: schemaIdType = token.encoding().primitiveType(); break; case SCHEMA_VERSION: schemaVersionType = token.encoding().primitiveType(); break; } } }
private static String primitiveTypeName(final Token token) { return javaTypeName(token.encoding().primitiveType()); }
private static PrimitiveType findPrimitiveByTokenName(final List<Token> tokens, final String targetName) { return findPrimitiveTokenByTokenName(tokens, targetName).encoding().primitiveType(); }
private CharSequence generateEnumValues(final List<Token> tokens, final Token encodingToken) { final StringBuilder sb = new StringBuilder(); final Encoding encoding = encodingToken.encoding(); sb.append( " enum Value \n" + " {\n"); for (final Token token : tokens) { final CharSequence constVal = generateLiteral( token.encoding().primitiveType(), token.encoding().constValue().toString()); sb.append(" ").append(token.name()).append(" = ").append(constVal).append(",\n"); } sb.append(String.format( " NULL_VALUE = %1$s", generateLiteral(encoding.primitiveType(), encoding.applicableNullValue().toString()))); sb.append("\n };\n\n"); return sb; }
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 CharSequence generateChoices(final List<Token> tokens) { final StringBuilder sb = new StringBuilder(); for (final Token token : tokens) { if (token.signal() == Signal.CHOICE) { final String choiceName = toUpperFirstChar(token.applicableTypeName()); final String choiceBitPosition = token.encoding().constValue().toString(); final int choiceValue = (int)Math.pow(2, Integer.parseInt(choiceBitPosition)); sb.append(String.format(INDENT + INDENT + "%s = %s,\n", choiceName, choiceValue)); } } return sb; }
private void generateBitSet(final List<Token> tokens) throws IOException { final Token enumToken = tokens.get(0); final String enumName = CSharpUtil.formatClassName(enumToken.applicableTypeName()); try (Writer out = outputManager.createOutput(enumName)) { out.append(generateFileHeader(ir.applicableNamespace())); final String enumPrimitiveType = cSharpTypeName(enumToken.encoding().primitiveType()); out.append(generateEnumDeclaration(enumName, enumPrimitiveType, true)); out.append(generateChoices(tokens.subList(1, tokens.size() - 1))); out.append(INDENT + "}\n"); out.append("}\n"); } }
private void generateEnum(final List<Token> tokens) throws IOException { final Token enumToken = tokens.get(0); final String enumName = CSharpUtil.formatClassName(enumToken.applicableTypeName()); try (Writer out = outputManager.createOutput(enumName)) { out.append(generateFileHeader(ir.applicableNamespace())); final String enumPrimitiveType = cSharpTypeName(enumToken.encoding().primitiveType()); out.append(generateEnumDeclaration(enumName, enumPrimitiveType, false)); out.append(generateEnumValues(tokens.subList(1, tokens.size() - 1), enumToken)); out.append(INDENT + "}\n"); out.append("}\n"); } }
private static long readEncodingAsLong( final DirectBuffer buffer, final int bufferIndex, final Token typeToken, final int actingVersion) { final PrimitiveValue constOrNotPresentValue = constOrNotPresentValue(typeToken, actingVersion); if (null != constOrNotPresentValue) { return constOrNotPresentValue.longValue(); } return Types.getLong(buffer, bufferIndex, typeToken.encoding()); }
private static long readEncodingAsLong( final DirectBuffer buffer, final int bufferIndex, final Token typeToken, final int actingVersion) { final PrimitiveValue constOrNotPresentValue = constOrNotPresentValue(typeToken, actingVersion); if (null != constOrNotPresentValue) { return constOrNotPresentValue.longValue(); } return Types.getLong(buffer, bufferIndex, typeToken.encoding()); } }
private CharSequence generateChoiceClear(final String bitSetClassName, final Token token) { final StringBuilder sb = new StringBuilder(); final Encoding encoding = token.encoding(); final String literalValue = generateLiteral(encoding.primitiveType(), "0"); final String byteOrderStr = byteOrderString(encoding); sb.append(String.format("\n" + " public %s clear()\n" + " {\n" + " %s;\n" + " return this;\n" + " }\n", bitSetClassName, generatePut(encoding.primitiveType(), "offset", literalValue, byteOrderStr))); return sb; }
private CharSequence generatePrimitiveFieldMetaData( final String propertyName, final Token token, final String indent) { final PrimitiveType primitiveType = token.encoding().primitiveType(); final String typeName = cSharpTypeName(primitiveType); return String.format( "\n" + indent + "public const %1$s %2$sNullValue = %3$s;\n" + indent + "public const %1$s %2$sMinValue = %4$s;\n" + indent + "public const %1$s %2$sMaxValue = %5$s;\n", typeName, toUpperFirstChar(propertyName), generateLiteral(primitiveType, token.encoding().applicableNullValue().toString()), generateLiteral(primitiveType, token.encoding().applicableMinValue().toString()), generateLiteral(primitiveType, token.encoding().applicableMaxValue().toString())); }
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 void generateVarData( final StringBuilder sb, final String typeName, final List<Token> tokens) { for (int i = 0, size = tokens.size(); i < size;) { final Token token = tokens.get(i); if (token.signal() != Signal.BEGIN_VAR_DATA) { throw new IllegalStateException("tokens must begin with BEGIN_VAR_DATA: token=" + token); } final String propertyName = toUpperFirstChar(token.name()); final Token lengthToken = Generators.findFirst("length", tokens, i); final int lengthOfLengthField = lengthToken.encodedLength(); final Token varDataToken = Generators.findFirst("varData", tokens, i); final String characterEncoding = varDataToken.encoding().characterEncoding(); generateFieldMetaAttributeMethod(sb, typeName, propertyName, token); generateVarDataDescriptors(sb, token, typeName, propertyName, characterEncoding, lengthOfLengthField); i += token.componentTokenCount(); } }
private void assertEqual(final Token lhs, final Token rhs) { assertThat(lhs.name(), is(rhs.name())); assertThat(lhs.version(), is(rhs.version())); assertThat(lhs.offset(), is(rhs.offset())); assertThat((long)lhs.id(), is((long)rhs.id())); assertThat(lhs.signal(), is(rhs.signal())); assertThat(lhs.encodedLength(), is(rhs.encodedLength())); assertThat(lhs.encoding().byteOrder(), is(rhs.encoding().byteOrder())); assertThat(lhs.encoding().primitiveType(), is(rhs.encoding().primitiveType())); assertThat(lhs.encoding().presence(), is(rhs.encoding().presence())); assertThat(lhs.encoding().constValue(), is(rhs.encoding().constValue())); assertThat(lhs.encoding().minValue(), is(rhs.encoding().minValue())); assertThat(lhs.encoding().maxValue(), is(rhs.encoding().maxValue())); assertThat(lhs.encoding().nullValue(), is(rhs.encoding().nullValue())); assertThat(lhs.encoding().characterEncoding(), is(rhs.encoding().characterEncoding())); assertThat(lhs.encoding().epoch(), is(rhs.encoding().epoch())); assertThat(lhs.encoding().timeUnit(), is(rhs.encoding().timeUnit())); assertThat(lhs.encoding().semanticType(), is(rhs.encoding().semanticType())); }
private CharSequence generatePrimitivePropertyEncode( final String containingClassName, final String propertyName, final Token token, final String indent) { final Encoding encoding = token.encoding(); final String javaTypeName = javaTypeName(encoding.primitiveType()); final int offset = token.offset(); final String byteOrderStr = byteOrderString(encoding); return String.format( "\n" + indent + " public %s %s(final %s value)\n" + indent + " {\n" + indent + " %s;\n" + indent + " return this;\n" + indent + " }\n\n", formatClassName(containingClassName), formatPropertyName(propertyName), javaTypeName, generatePut(encoding.primitiveType(), "offset + " + offset, "value", byteOrderStr)); }