This is an automated email from the ASF dual-hosted git repository. cdutz pushed a commit to branch feature/mspec-ng in repository https://gitbox.apache.org/repos/asf/plc4x.git
commit c319a6d23875f7704b9d073565b3617c0a0d2f56 Author: cdutz <[email protected]> AuthorDate: Mon Nov 1 09:05:20 2021 +0100 - Made plc4go code-generation execute again (Doesn't produce working code yet) --- code-generation/language-go/pom.xml | 39 ---- .../language/go/GoLanguageTemplateHelper.java | 225 ++++++++++++--------- .../templates/go/data-io-template.go.ftlh | 14 +- .../resources/templates/go/enum-template.go.ftlh | 6 +- .../resources/templates/go/model-template.go.ftlh | 141 ++++++------- .../language-go/src/test/resources/plc4go/pom.xml | 33 --- 6 files changed, 203 insertions(+), 255 deletions(-) diff --git a/code-generation/language-go/pom.xml b/code-generation/language-go/pom.xml index d73e417..00b512a 100644 --- a/code-generation/language-go/pom.xml +++ b/code-generation/language-go/pom.xml @@ -34,45 +34,6 @@ <build> <plugins> - <plugin> - <groupId>org.apache.maven.plugins</groupId> - <artifactId>maven-invoker-plugin</artifactId> - <version>3.2.2</version> - <executions> - <execution> - <id>integration-test</id> - <goals> - <!-- Install the current project artifacts into the maven local repo, so they can be used in the test --> - <goal>install</goal> - <!-- Execute the maven builds defines in src/test/resources --> - <goal>integration-test</goal> - <!-- Checks the results of the maven builds --> - <goal>verify</goal> - </goals> - <configuration> - <debug>true</debug> - <localRepositoryPath>${project.build.directory}/local-repo</localRepositoryPath> - <projectsDirectory>src/test/resources</projectsDirectory> - <cloneProjectsTo>${project.build.directory}/integration-tests</cloneProjectsTo> - <settingsFile>src/test/resources/settings.xml</settingsFile> - <extraArtifacts> - <extraArtifact>org.apache.plc4x.plugins:plc4x-code-generation-language-base:${plc4x-code-generation.version}</extraArtifact> - <extraArtifact>org.apache.plc4x.plugins:plc4x-maven-plugin:${plc4x-code-generation.version}</extraArtifact> - <extraArtifact>org.apache.plc4x.plugins:plc4x-code-generation-protocol-base:${plc4x-code-generation.version}</extraArtifact> - <extraArtifact>org.apache.plc4x.plugins:plc4x-code-generation-types-base:${plc4x-code-generation.version}</extraArtifact> - <extraArtifact>org.apache.plc4x.plugins:plc4x-code-generation-types-base:${plc4x-code-generation.version}</extraArtifact> - </extraArtifacts> - <pomIncludes> - <pomInclude>*/pom.xml</pomInclude> - </pomIncludes> - <!-- The goals we will be executing in the test-projects --> - <goals> - <goal>test</goal> - </goals> - </configuration> - </execution> - </executions> - </plugin> </plugins> </build> diff --git a/code-generation/language-go/src/main/java/org/apache/plc4x/language/go/GoLanguageTemplateHelper.java b/code-generation/language-go/src/main/java/org/apache/plc4x/language/go/GoLanguageTemplateHelper.java index fe9e7d2..22e50a6 100644 --- a/code-generation/language-go/src/main/java/org/apache/plc4x/language/go/GoLanguageTemplateHelper.java +++ b/code-generation/language-go/src/main/java/org/apache/plc4x/language/go/GoLanguageTemplateHelper.java @@ -275,8 +275,12 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp return "optional".equals(field.getTypeName()) || (field.getType().isComplexTypeReference() && !isEnumField(field)); } - public String getReadBufferReadMethodCall(String logicalName, SimpleTypeReference simpleTypeReference) { - return getReadBufferReadMethodCall(logicalName, simpleTypeReference, null, null); + public String getSpecialReadBufferReadMethodCall(String logicalName, SimpleTypeReference simpleTypeReference, TypedField field) { + return getReadBufferReadMethodCall(logicalName, simpleTypeReference, null, field); + } + + public String getReadBufferReadMethodCall(String logicalName, SimpleTypeReference simpleTypeReference, TypedField field) { + return getReadBufferReadMethodCall(logicalName, simpleTypeReference, null, field); } @Override @@ -399,8 +403,7 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp return "writeBuffer.WriteFloat64(\"" + logicalName + "\", " + floatTypeReference.getSizeInBits() + ", " + fieldName + writerArgsString + ")"; } return "writeBuffer.WriteBigFloat(\"" + logicalName + "\", " + floatTypeReference.getSizeInBits() + ", " + fieldName + writerArgsString + ")"; - case STRING: - case VSTRING: + case STRING: { StringTypeReference stringTypeReference = (StringTypeReference) simpleTypeReference; final Term encodingTerm = field.getEncoding().orElse(new DefaultStringLiteral("UTF-8")); if (!(encodingTerm instanceof StringLiteral)) { @@ -410,6 +413,19 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp String length = Integer.toString(simpleTypeReference.getSizeInBits()); return "writeBuffer.WriteString(\"" + logicalName + "\", uint8(" + length + "), \"" + encoding + "\", " + fieldName + writerArgsString + ")"; + } + case VSTRING: { + VstringTypeReference vstringTypeReference = (VstringTypeReference) simpleTypeReference; + final Term encodingTerm = field.getEncoding().orElse(new DefaultStringLiteral("UTF-8")); + if (!(encodingTerm instanceof StringLiteral)) { + throw new RuntimeException("Encoding must be a quoted string value"); + } + String encoding = ((StringLiteral) encodingTerm).getValue(); + // TODO: Port this to use the expression term instead. + String length = Integer.toString(simpleTypeReference.getSizeInBits()); + return "writeBuffer.WriteString(\"" + logicalName + "\", uint8(" + length + "), \"" + + encoding + "\", " + fieldName + writerArgsString + ")"; + } } throw new FreemarkerException("Unsupported base type" + simpleTypeReference.getBaseType()); } @@ -441,35 +457,35 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp } public String toParseExpression(TypedField field, Term term, List<Argument> parserArguments) { - return toTypedParseExpression((field != null) ? field.getType() : null, term, parserArguments); + return toTypedParseExpression(field, (field != null) ? field.getType() : null, term, parserArguments); } public String toSerializationExpression(TypedField field, Term term, List<Argument> serializerArguments) { - return toTypedSerializationExpression((field != null) ? field.getType() : null, term, serializerArguments); + return toTypedSerializationExpression(field, (field != null) ? field.getType() : null, term, serializerArguments); } - public String toBooleanParseExpression(Term term, List<Argument> parserArguments) { - return toTypedParseExpression(new DefaultBooleanTypeReference(), term, parserArguments); + public String toBooleanParseExpression(Field field, Term term, List<Argument> parserArguments) { + return toTypedParseExpression(field, new DefaultBooleanTypeReference(), term, parserArguments); } - public String toBooleanSerializationExpression(Term term, List<Argument> serializerArguments) { - return toTypedSerializationExpression(new DefaultBooleanTypeReference(), term, serializerArguments); + public String toBooleanSerializationExpression(Field field, Term term, List<Argument> serializerArguments) { + return toTypedSerializationExpression(field, new DefaultBooleanTypeReference(), term, serializerArguments); } - public String toIntegerParseExpression(int sizeInBits, Term term, List<Argument> parserArguments) { - return toTypedParseExpression(new DefaultIntegerTypeReference(SimpleTypeReference.SimpleBaseType.UINT, sizeInBits), term, parserArguments); + public String toIntegerParseExpression(Field field, int sizeInBits, Term term, List<Argument> parserArguments) { + return toTypedParseExpression(field, new DefaultIntegerTypeReference(SimpleTypeReference.SimpleBaseType.UINT, sizeInBits), term, parserArguments); } - public String toIntegerSerializationExpression(int sizeInBits, Term term, List<Argument> serializerArguments) { - return toTypedSerializationExpression(new DefaultIntegerTypeReference(SimpleTypeReference.SimpleBaseType.UINT, sizeInBits), term, serializerArguments); + public String toIntegerSerializationExpression(Field field, int sizeInBits, Term term, List<Argument> serializerArguments) { + return toTypedSerializationExpression(field, new DefaultIntegerTypeReference(SimpleTypeReference.SimpleBaseType.UINT, sizeInBits), term, serializerArguments); } - public String toTypedParseExpression(TypeReference fieldType, Term term, List<Argument> parserArguments) { - return toExpression(fieldType, term, parserArguments, null, false, fieldType != null && fieldType.isComplexTypeReference()); + public String toTypedParseExpression(Field field, TypeReference fieldType, Term term, List<Argument> parserArguments) { + return toExpression(field, fieldType, term, parserArguments, null, false, fieldType != null && fieldType.isComplexTypeReference()); } - public String toTypedSerializationExpression(TypeReference fieldType, Term term, List<Argument> serializerArguments) { - return toExpression(fieldType, term, null, serializerArguments, true, false); + public String toTypedSerializationExpression(Field field, TypeReference fieldType, Term term, List<Argument> serializerArguments) { + return toExpression(field, fieldType, term, null, serializerArguments, true, false); } String getCastExpressionForTypeReference(TypeReference typeReference) { @@ -482,39 +498,39 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp } } - private String toExpression(TypeReference fieldType, Term term, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, boolean suppressPointerAccess) { + private String toExpression(Field field, TypeReference fieldType, Term term, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, boolean suppressPointerAccess) { Tracer tracer = Tracer.start("toExpression"); if (term == null) { return ""; } if (term instanceof Literal) { - return toLiteralTermExpression(fieldType, term, parserArguments, serializerArguments, serialize, suppressPointerAccess, tracer); + return toLiteralTermExpression(field, fieldType, term, parserArguments, serializerArguments, serialize, suppressPointerAccess, tracer); } else if (term instanceof UnaryTerm) { - return toUnaryTermExpression(fieldType, (UnaryTerm) term, parserArguments, serializerArguments, serialize, tracer); + return toUnaryTermExpression(field, fieldType, (UnaryTerm) term, parserArguments, serializerArguments, serialize, tracer); } else if (term instanceof BinaryTerm) { - return toBinaryTermExpression(fieldType, (BinaryTerm) term, parserArguments, serializerArguments, serialize, tracer); + return toBinaryTermExpression(field, fieldType, (BinaryTerm) term, parserArguments, serializerArguments, serialize, tracer); } else if (term instanceof TernaryTerm) { - return toTernaryTermExpression(fieldType, (TernaryTerm) term, parserArguments, serializerArguments, serialize, tracer); + return toTernaryTermExpression(field, fieldType, (TernaryTerm) term, parserArguments, serializerArguments, serialize, tracer); } else { throw new RuntimeException("Unsupported Term type " + term.getClass().getName()); } } - private String toTernaryTermExpression(TypeReference fieldType, TernaryTerm ternaryTerm, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, Tracer tracer) { + private String toTernaryTermExpression(Field field, TypeReference fieldType, TernaryTerm ternaryTerm, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, Tracer tracer) { tracer = tracer.dive("ternary term instanceOf"); if ("if".equals(ternaryTerm.getOperation())) { Term a = ternaryTerm.getA(); Term b = ternaryTerm.getB(); Term c = ternaryTerm.getC(); - return tracer + "utils.InlineIf(" + toExpression(new DefaultBooleanTypeReference(), a, parserArguments, serializerArguments, serialize, false) + ", " + - "func() interface{} {return " + getCastExpressionForTypeReference(fieldType) + "(" + toExpression(fieldType, b, parserArguments, serializerArguments, serialize, false) + ")}, " + - "func() interface{} {return " + getCastExpressionForTypeReference(fieldType) + "(" + toExpression(fieldType, c, parserArguments, serializerArguments, serialize, false) + ")}).(" + getCastExpressionForTypeReference(fieldType) + ")"; + return tracer + "utils.InlineIf(" + toExpression(field, new DefaultBooleanTypeReference(), a, parserArguments, serializerArguments, serialize, false) + ", " + + "func() interface{} {return " + getCastExpressionForTypeReference(fieldType) + "(" + toExpression(field, fieldType, b, parserArguments, serializerArguments, serialize, false) + ")}, " + + "func() interface{} {return " + getCastExpressionForTypeReference(fieldType) + "(" + toExpression(field, fieldType, c, parserArguments, serializerArguments, serialize, false) + ")}).(" + getCastExpressionForTypeReference(fieldType) + ")"; } else { throw new RuntimeException("Unsupported ternary operation type " + ternaryTerm.getOperation()); } } - private String toBinaryTermExpression(TypeReference fieldType, BinaryTerm binaryTerm, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, Tracer tracer) { + private String toBinaryTermExpression(Field field, TypeReference fieldType, BinaryTerm binaryTerm, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, Tracer tracer) { tracer = tracer.dive("binary term instanceOf"); Term a = binaryTerm.getA(); Term b = binaryTerm.getB(); @@ -524,8 +540,8 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp tracer = tracer.dive("^"); emitRequiredImport("math"); return tracer + "Math.pow(" + - getCastExpressionForTypeReference(fieldType) + "(" + toExpression(fieldType, a, parserArguments, serializerArguments, serialize, false) + "), " + - getCastExpressionForTypeReference(fieldType) + "(" + toExpression(fieldType, b, parserArguments, serializerArguments, serialize, false) + "))"; + getCastExpressionForTypeReference(fieldType) + "(" + toExpression(field, fieldType, a, parserArguments, serializerArguments, serialize, false) + "), " + + getCastExpressionForTypeReference(fieldType) + "(" + toExpression(field, fieldType, b, parserArguments, serializerArguments, serialize, false) + "))"; // If we start casting for comparisons, equals or non equals, really messy things happen. case "==": case "!=": @@ -538,42 +554,42 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp // Except for doing a nil or not-nil check :-( // So in case of such a check, we need to suppress the pointer-access. boolean suppressPointerAccessOverride = (operation.equals("==") || operation.equals("!=")) && ((a instanceof NullLiteral) || (b instanceof NullLiteral)); - return tracer + "bool((" + toExpression(null, a, parserArguments, serializerArguments, serialize, suppressPointerAccessOverride) + ") " + + return tracer + "bool((" + toExpression(field, null, a, parserArguments, serializerArguments, serialize, suppressPointerAccessOverride) + ") " + operation + - " (" + toExpression(null, b, parserArguments, serializerArguments, serialize, suppressPointerAccessOverride) + "))"; + " (" + toExpression(field, null, b, parserArguments, serializerArguments, serialize, suppressPointerAccessOverride) + "))"; default: tracer = tracer.dive("default"); if (fieldType instanceof StringTypeReference) { tracer = tracer.dive("string type reference"); - return tracer + toExpression(fieldType, a, parserArguments, serializerArguments, serialize, false) + + return tracer + toExpression(field, fieldType, a, parserArguments, serializerArguments, serialize, false) + operation + " " + - toExpression(fieldType, b, parserArguments, serializerArguments, serialize, false); + toExpression(field, fieldType, b, parserArguments, serializerArguments, serialize, false); } - return tracer + getCastExpressionForTypeReference(fieldType) + "(" + toExpression(fieldType, a, parserArguments, serializerArguments, serialize, false) + ") " + + return tracer + getCastExpressionForTypeReference(fieldType) + "(" + toExpression(field, fieldType, a, parserArguments, serializerArguments, serialize, false) + ") " + operation + " " + - getCastExpressionForTypeReference(fieldType) + "(" + toExpression(fieldType, b, parserArguments, serializerArguments, serialize, false) + ")"; + getCastExpressionForTypeReference(fieldType) + "(" + toExpression(field, fieldType, b, parserArguments, serializerArguments, serialize, false) + ")"; } } - private String toUnaryTermExpression(TypeReference fieldType, UnaryTerm unaryTerm, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, Tracer tracer) { + private String toUnaryTermExpression(Field field, TypeReference fieldType, UnaryTerm unaryTerm, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, Tracer tracer) { tracer = tracer.dive("unary term instanceOf"); Term a = unaryTerm.getA(); switch (unaryTerm.getOperation()) { case "!": tracer = tracer.dive("case !"); - return tracer + "!(" + toExpression(fieldType, a, parserArguments, serializerArguments, serialize, false) + ")"; + return tracer + "!(" + toExpression(field, fieldType, a, parserArguments, serializerArguments, serialize, false) + ")"; case "-": tracer = tracer.dive("case -"); - return tracer + "-(" + getCastExpressionForTypeReference(fieldType) + "(" + toExpression(fieldType, a, parserArguments, serializerArguments, serialize, false) + "))"; + return tracer + "-(" + getCastExpressionForTypeReference(fieldType) + "(" + toExpression(field, fieldType, a, parserArguments, serializerArguments, serialize, false) + "))"; case "()": tracer = tracer.dive("case ()"); - return tracer + getCastExpressionForTypeReference(fieldType) + "(" + toExpression(fieldType, a, parserArguments, serializerArguments, serialize, false) + ")"; + return tracer + getCastExpressionForTypeReference(fieldType) + "(" + toExpression(field, fieldType, a, parserArguments, serializerArguments, serialize, false) + ")"; default: throw new RuntimeException("Unsupported unary operation type " + unaryTerm.getOperation()); } } - private String toLiteralTermExpression(TypeReference fieldType, Term term, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, boolean suppressPointerAccess, Tracer tracer) { + private String toLiteralTermExpression(Field field, TypeReference fieldType, Term term, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, boolean suppressPointerAccess, Tracer tracer) { tracer = tracer.dive("literal term instanceOf"); if (term instanceof NullLiteral) { tracer = tracer.dive("null literal instanceOf"); @@ -594,27 +610,27 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp return tracer + "\"" + ((StringLiteral) term).getValue() + "\""; } else if (term instanceof VariableLiteral) { tracer = tracer.dive("variable literal instanceOf"); - return tracer + toVariableExpression(fieldType, (VariableLiteral) term, parserArguments, serializerArguments, serialize, suppressPointerAccess); + return tracer + toVariableExpression(field, fieldType, (VariableLiteral) term, parserArguments, serializerArguments, serialize, suppressPointerAccess); } else { throw new RuntimeException("Unsupported Literal type " + term.getClass().getName()); } } - private String toVariableExpression(TypeReference typeReference, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, boolean suppressPointerAccess) { + private String toVariableExpression(Field field, TypeReference typeReference, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, boolean suppressPointerAccess) { Tracer tracer = Tracer.start("toVariableExpression"); if ("lengthInBytes".equals(variableLiteral.getName())) { return toLengthInBytesVariableExpression(typeReference, serialize, tracer); } else if ("lengthInBits".equals(variableLiteral.getName())) { return toLengthInBitsVariableExpression(typeReference, serialize, tracer); } else if ("_value".equals(variableLiteral.getName())) { - return toValueVariableExpression(typeReference, variableLiteral, parserArguments, serializerArguments, serialize, suppressPointerAccess, tracer); + return toValueVariableExpression(field, typeReference, variableLiteral, parserArguments, serializerArguments, serialize, suppressPointerAccess, tracer); } if ("length".equals(variableLiteral.getChild().map(VariableLiteral::getName).orElse(""))) { - return toLengthVariableExpression(variableLiteral, serialize, tracer); + return toLengthVariableExpression(field, variableLiteral, serialize, tracer); } // If this literal references an Enum type, then we have to output it differently. else if (getTypeDefinitions().get(variableLiteral.getName()) instanceof EnumTypeDefinition) { - return toEnumVariableExpression(typeReference, variableLiteral, parserArguments, serializerArguments, suppressPointerAccess, tracer); + return toEnumVariableExpression(field, typeReference, variableLiteral, parserArguments, serializerArguments, suppressPointerAccess, tracer); } // If we are accessing enum constants, these also need to be output differently. else if (thisType.isComplexTypeDefinition() @@ -625,7 +641,7 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp .isPresent() && (variableLiteral.getChild().isPresent()) ) { - return toConstantVariableExpression(typeReference, variableLiteral, parserArguments, serializerArguments, suppressPointerAccess, tracer); + return toConstantVariableExpression(field, typeReference, variableLiteral, parserArguments, serializerArguments, suppressPointerAccess, tracer); } // If we are accessing optional fields, (we might need to use pointer-access). else if (!serialize && thisType.isComplexTypeDefinition() @@ -635,7 +651,7 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp .filter(OptionalField.class::isInstance) .isPresent() ) { - return toOptionalVariableExpression(typeReference, variableLiteral, parserArguments, serializerArguments, suppressPointerAccess, tracer); + return toOptionalVariableExpression(field, typeReference, variableLiteral, parserArguments, serializerArguments, suppressPointerAccess, tracer); } // If we are accessing implicit fields, we need to rely on local variable instead. //else if (isVariableLiteralImplicitField(vl)) { @@ -647,19 +663,19 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp // CAST expressions are special as we need to add a ".class" to the second parameter in Java. else if ("CAST".equals(variableLiteral.getName())) { - return toCastVariableExpression(typeReference, variableLiteral, parserArguments, serializerArguments, serialize, suppressPointerAccess, tracer); + return toCastVariableExpression(field, typeReference, variableLiteral, parserArguments, serializerArguments, serialize, suppressPointerAccess, tracer); } else if ("STATIC_CALL".equals(variableLiteral.getName())) { - return toStaticCallVariableExpression(typeReference, variableLiteral, parserArguments, serializerArguments, serialize, suppressPointerAccess, tracer); + return toStaticCallVariableExpression(field, typeReference, variableLiteral, parserArguments, serializerArguments, serialize, suppressPointerAccess, tracer); } else if ("COUNT".equals(variableLiteral.getName())) { - return toCoundVariableExpression(typeReference, variableLiteral, parserArguments, serializerArguments, serialize, suppressPointerAccess, tracer); + return toCountVariableExpression(field, typeReference, variableLiteral, parserArguments, serializerArguments, serialize, suppressPointerAccess, tracer); } else if ("ARRAY_SIZE_IN_BYTES".equals(variableLiteral.getName())) { - return toArraySizeInBytesVariableExpression(typeReference, variableLiteral, parserArguments, serializerArguments, suppressPointerAccess, tracer); + return toArraySizeInBytesVariableExpression(field, typeReference, variableLiteral, parserArguments, serializerArguments, suppressPointerAccess, tracer); } else if ("CEIL".equals(variableLiteral.getName())) { - return toCeilVariableExpression(variableLiteral, parserArguments, serializerArguments, serialize, suppressPointerAccess, tracer); + return toCeilVariableExpression(field, variableLiteral, parserArguments, serializerArguments, serialize, suppressPointerAccess, tracer); } // All uppercase names are not fields, but utility methods. else if (variableLiteral.getName().equals(variableLiteral.getName().toUpperCase())) { - return toUppercaseVariableExpression(typeReference, variableLiteral, parserArguments, serializerArguments, serialize, suppressPointerAccess, tracer); + return toUppercaseVariableExpression(field, typeReference, variableLiteral, parserArguments, serializerArguments, serialize, suppressPointerAccess, tracer); } // If the current property references a discriminator value, we have to serialize it differently. @@ -683,7 +699,7 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp tracer = tracer.dive("complex"); ComplexTypeDefinition complexTypeDefinition = (ComplexTypeDefinition) typeDefinition; String childProperty = variableLiteral.getChild().orElseThrow(() -> new RuntimeException("complex needs a child")).getName(); - final Optional<Field> matchingDiscriminatorField = complexTypeDefinition.getFields().stream().filter(field -> (field instanceof DiscriminatorField) && ((DiscriminatorField) field).getName().equals(childProperty)).findFirst(); + final Optional<Field> matchingDiscriminatorField = complexTypeDefinition.getFields().stream().filter(curField -> (curField instanceof DiscriminatorField) && ((DiscriminatorField) curField).getName().equals(childProperty)).findFirst(); if (matchingDiscriminatorField.isPresent()) { return tracer + "Cast" + getLanguageTypeNameForTypeReference(complexTypeReference) + "(" + variableLiteral.getName() + ").Child." + StringUtils.capitalize(childProperty) + "()"; } @@ -710,7 +726,7 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp tracer = tracer.dive("serialization argument"); return tracer + variableLiteral.getName() + variableLiteral.getChild() - .map(child -> "." + toVariableExpression(typeReference, child, parserArguments, serializerArguments, false, suppressPointerAccess)) + .map(child -> "." + toVariableExpression(field, typeReference, child, parserArguments, serializerArguments, false, suppressPointerAccess)) .orElse(""); } String indexCall = ""; @@ -721,11 +737,11 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp } return tracer + (serialize ? "m." + StringUtils.capitalize(variableLiteral.getName()) : variableLiteral.getName()) + indexCall + variableLiteral.getChild() - .map(child -> "." + StringUtils.capitalize(toVariableExpression(typeReference, child, parserArguments, serializerArguments, false, suppressPointerAccess))) + .map(child -> "." + StringUtils.capitalize(toVariableExpression(field, typeReference, child, parserArguments, serializerArguments, false, suppressPointerAccess))) .orElse(""); } - private String toUppercaseVariableExpression(TypeReference typeReference, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, boolean suppressPointerAccess, Tracer tracer) { + private String toUppercaseVariableExpression(Field field, TypeReference typeReference, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, boolean suppressPointerAccess, Tracer tracer) { tracer = tracer.dive("utility medhods"); StringBuilder sb = new StringBuilder(variableLiteral.getName()); if (variableLiteral.getArgs().isPresent()) { @@ -735,7 +751,7 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp if (!firstArg) { sb.append(", "); } - sb.append(toExpression(typeReference, arg, parserArguments, serializerArguments, serialize, suppressPointerAccess)); + sb.append(toExpression(field, typeReference, arg, parserArguments, serializerArguments, serialize, suppressPointerAccess)); firstArg = false; } sb.append(")"); @@ -744,21 +760,21 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp sb.append("[").append(variableLiteral.getIndex()).append("]"); } return tracer + sb.toString() + variableLiteral.getChild() - .map(child -> "." + toVariableExpression(typeReference, child, parserArguments, serializerArguments, false, suppressPointerAccess)) + .map(child -> "." + toVariableExpression(field, typeReference, child, parserArguments, serializerArguments, false, suppressPointerAccess)) .orElse(""); } - private String toCeilVariableExpression(VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, boolean suppressPointerAccess, Tracer tracer) { + private String toCeilVariableExpression(Field field, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, boolean suppressPointerAccess, Tracer tracer) { tracer = tracer.dive("ceil"); Term va = variableLiteral.getArgs().orElseThrow(() -> new RuntimeException("CEIL needs at least one arg")) .stream().findFirst().orElseThrow(IllegalStateException::new); // The Ceil function expects 64 bit floating point values. TypeReference tr = new DefaultFloatTypeReference(SimpleTypeReference.SimpleBaseType.FLOAT, 64); emitRequiredImport("math"); - return tracer + "math.Ceil(" + toExpression(tr, va, parserArguments, serializerArguments, serialize, suppressPointerAccess) + ")"; + return tracer + "math.Ceil(" + toExpression(field, tr, va, parserArguments, serializerArguments, serialize, suppressPointerAccess) + ")"; } - private String toArraySizeInBytesVariableExpression(TypeReference typeReference, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean suppressPointerAccess, Tracer tracer) { + private String toArraySizeInBytesVariableExpression(Field field, TypeReference typeReference, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean suppressPointerAccess, Tracer tracer) { tracer = tracer.dive("array size in bytes"); VariableLiteral va = variableLiteral.getArgs() .orElseThrow(() -> new RuntimeException("ARRAY_SIZE_IN_BYTES needs at least one arg")) @@ -779,14 +795,14 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp } StringBuilder sb = new StringBuilder(); if (isSerializerArg) { - sb.append(va.getName()).append(va.getChild().map(child -> "." + toVariableExpression(typeReference, child, parserArguments, serializerArguments, true, suppressPointerAccess)).orElse("")); + sb.append(va.getName()).append(va.getChild().map(child -> "." + toVariableExpression(field, typeReference, child, parserArguments, serializerArguments, true, suppressPointerAccess)).orElse("")); } else { - sb.append(toVariableExpression(typeReference, va, parserArguments, serializerArguments, true, suppressPointerAccess)); + sb.append(toVariableExpression(field, typeReference, va, parserArguments, serializerArguments, true, suppressPointerAccess)); } return tracer + getCastExpressionForTypeReference(typeReference) + "(" + va.getName() + "ArraySizeInBytes(" + sb.toString() + "))"; } - private String toCoundVariableExpression(TypeReference typeReference, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, boolean suppressPointerAccess, Tracer tracer) { + private String toCountVariableExpression(Field field, TypeReference typeReference, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, boolean suppressPointerAccess, Tracer tracer) { tracer = tracer.dive("count"); VariableLiteral countLiteral = variableLiteral.getArgs() .orElseThrow(() -> new RuntimeException("Count needs at least one arg")) @@ -796,11 +812,11 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp .asVariableLiteral() .orElseThrow(() -> new RuntimeException("Count needs a variable literal")); return tracer + (typeReference instanceof SimpleTypeReference ? getCastExpressionForTypeReference(typeReference) : "") + "(len(" + - toVariableExpression(typeReference, countLiteral, parserArguments, serializerArguments, serialize, suppressPointerAccess) + + toVariableExpression(field, typeReference, countLiteral, parserArguments, serializerArguments, serialize, suppressPointerAccess) + "))"; } - private String toStaticCallVariableExpression(TypeReference typeReference, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, boolean suppressPointerAccess, Tracer tracer) { + private String toStaticCallVariableExpression(Field field, TypeReference typeReference, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, boolean suppressPointerAccess, Tracer tracer) { tracer = tracer.dive("STATIC_CALL"); StringBuilder sb = new StringBuilder(); List<Term> arguments = variableLiteral.getArgs().orElseThrow(() -> new RuntimeException("A STATIC_CALL expression needs arguments")); @@ -842,10 +858,10 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp } if (isParserArg) { if (va.getName().equals("_value")) { - sb.append(va.getName().substring(1)).append(va.getChild().map(child -> "." + toVariableExpression(typeReference, child, parserArguments, serializerArguments, false, suppressPointerAccess)).orElse("")); + sb.append(va.getName().substring(1)).append(va.getChild().map(child -> "." + toVariableExpression(field, typeReference, child, parserArguments, serializerArguments, false, suppressPointerAccess)).orElse("")); } else { sb.append(va.getName()).append((va.getChild().isPresent()) ? - "." + toVariableExpression(typeReference, variableLiteral.getChild().get(), parserArguments, serializerArguments, false, suppressPointerAccess) : ""); + "." + toVariableExpression(field, typeReference, variableLiteral.getChild().get(), parserArguments, serializerArguments, false, suppressPointerAccess) : ""); } } // We have to manually evaluate the type information at code-generation time. @@ -868,7 +884,7 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp break; } } else { - sb.append(toVariableExpression(typeReference, va, parserArguments, serializerArguments, serialize, suppressPointerAccess)); + sb.append(toVariableExpression(field, typeReference, va, parserArguments, serializerArguments, serialize, suppressPointerAccess)); } } else if (arg instanceof StringLiteral) { sb.append(((StringLiteral) arg).getValue()); @@ -878,7 +894,7 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp return tracer + sb.toString(); } - private String toCastVariableExpression(TypeReference typeReference, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, boolean suppressPointerAccess, Tracer tracer) { + private String toCastVariableExpression(Field field, TypeReference typeReference, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, boolean suppressPointerAccess, Tracer tracer) { tracer = tracer.dive("CAST"); List<Term> arguments = variableLiteral.getArgs().orElseThrow(() -> new RuntimeException("A Cast expression needs arguments")); if (arguments.size() != 2) { @@ -898,39 +914,39 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp sb.append("Cast"); } sb.append(typeLiteral.getName()); - sb.append("(").append(toVariableExpression(typeReference, firstArgument, parserArguments, serializerArguments, serialize, suppressPointerAccess)).append(")"); - return tracer + sb.toString() + variableLiteral.getChild().map(child -> "." + StringUtils.capitalize(toVariableExpression(typeReference, child, parserArguments, serializerArguments, false, suppressPointerAccess))).orElse(""); + sb.append("(").append(toVariableExpression(field, typeReference, firstArgument, parserArguments, serializerArguments, serialize, suppressPointerAccess)).append(")"); + return tracer + sb.toString() + variableLiteral.getChild().map(child -> "." + StringUtils.capitalize(toVariableExpression(field, typeReference, child, parserArguments, serializerArguments, false, suppressPointerAccess))).orElse(""); } - private String toOptionalVariableExpression(TypeReference typeReference, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean suppressPointerAccess, Tracer tracer) { + private String toOptionalVariableExpression(Field field, TypeReference typeReference, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean suppressPointerAccess, Tracer tracer) { tracer = tracer.dive("optional fields"); return tracer + "(" + (suppressPointerAccess ? "" : "*") + variableLiteral.getName() + ")" + - variableLiteral.getChild().map(child -> "." + toVariableExpression(typeReference, child, parserArguments, serializerArguments, false, suppressPointerAccess)).orElse(""); + variableLiteral.getChild().map(child -> "." + toVariableExpression(field, typeReference, child, parserArguments, serializerArguments, false, suppressPointerAccess)).orElse(""); } - private String toConstantVariableExpression(TypeReference typeReference, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean suppressPointerAccess, Tracer tracer) { + private String toConstantVariableExpression(Field field, TypeReference typeReference, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean suppressPointerAccess, Tracer tracer) { tracer = tracer.dive("enum constant"); VariableLiteral child = variableLiteral.getChild().get(); return tracer + variableLiteral.getName() + "." + StringUtils.capitalize(child.getName()) + "()" + - child.getChild().map(childChild -> "." + toVariableExpression(typeReference, childChild, parserArguments, serializerArguments, false, suppressPointerAccess)).orElse(""); + child.getChild().map(childChild -> "." + toVariableExpression(field, typeReference, childChild, parserArguments, serializerArguments, false, suppressPointerAccess)).orElse(""); } - private String toEnumVariableExpression(TypeReference typeReference, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean suppressPointerAccess, Tracer tracer) { + private String toEnumVariableExpression(Field field, TypeReference typeReference, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean suppressPointerAccess, Tracer tracer) { tracer = tracer.dive("enum"); VariableLiteral child = variableLiteral.getChild().orElseThrow(() -> new RuntimeException("Enum should have a child")); return tracer + variableLiteral.getName() + "_" + child.getName() + - child.getChild().map(childChild -> "." + toVariableExpression(typeReference, childChild, parserArguments, serializerArguments, false, suppressPointerAccess)).orElse(""); + child.getChild().map(childChild -> "." + toVariableExpression(field, typeReference, childChild, parserArguments, serializerArguments, false, suppressPointerAccess)).orElse(""); } - private String toLengthVariableExpression(VariableLiteral variableLiteral, boolean serialize, Tracer tracer) { + private String toLengthVariableExpression(Field field, VariableLiteral variableLiteral, boolean serialize, Tracer tracer) { tracer = tracer.dive("length"); return tracer + (serialize ? ("len(m." + StringUtils.capitalize(variableLiteral.getName()) + ")") : ("(" + variableLiteral.getName() + ")")); } - private String toValueVariableExpression(TypeReference typeReference, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, boolean suppressPointerAccess, Tracer tracer) { + private String toValueVariableExpression(Field field, TypeReference typeReference, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, boolean suppressPointerAccess, Tracer tracer) { final Tracer tracer2 = tracer.dive("_value"); return variableLiteral.getChild() - .map(child -> tracer2.dive("withChild") + toVariableExpression(typeReference, child, parserArguments, serializerArguments, serialize, suppressPointerAccess)) + .map(child -> tracer2.dive("withChild") + toVariableExpression(field, typeReference, child, parserArguments, serializerArguments, serialize, suppressPointerAccess)) .orElse(tracer2 + "m"); } @@ -953,10 +969,10 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp final SimpleTypeReference type = (SimpleTypeReference) arrayField.getType(); switch (arrayField.getLoopType()) { case COUNT: - sb.append("(").append(toTypedSerializationExpression(type, arrayField.getLoopExpression(), parserArguments)).append(" * ").append(type.getSizeInBits()).append(") + "); + sb.append("(").append(toTypedSerializationExpression(field, type, arrayField.getLoopExpression(), parserArguments)).append(" * ").append(type.getSizeInBits()).append(") + "); break; case LENGTH: - sb.append("(").append(toTypedSerializationExpression(type, arrayField.getLoopExpression(), parserArguments)).append(" * 8) + "); + sb.append("(").append(toTypedSerializationExpression(field, type, arrayField.getLoopExpression(), parserArguments)).append(" * 8) + "); break; case TERMINATED: // No terminated. @@ -1143,9 +1159,15 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp return name; } } - for (Term param : curField.getParams().orElse(Collections.emptyList())) { - if (param.contains(name)) { - return name; + if(curField.isTypedField()) { + final TypedField typedField = curField.asTypedField().get(); + if(typedField.getType().isComplexTypeReference()) { + final ComplexTypeReference complexTypeReference = typedField.getType().asComplexTypeReference().get(); + for (Term param : complexTypeReference.getParams().orElse(Collections.emptyList())) { + if (param.contains(name)) { + return name; + } + } } } } @@ -1160,10 +1182,16 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp return true; } } - List<Term> fieldParams = field.getParams().orElse(Collections.emptyList()); - for (Term param : fieldParams) { - if (param.contains(variableName)) { - return true; + if(field.isTypedField()) { + final TypedField typedField = field.asTypedField().get(); + if (typedField.getType().isComplexTypeReference()) { + final ComplexTypeReference complexTypeReference = typedField.getType().asComplexTypeReference().get(); + List<Term> fieldParams = complexTypeReference.getParams().orElse(Collections.emptyList()); + for (Term param : fieldParams) { + if (param.contains(variableName)) { + return true; + } + } } } return false; @@ -1226,9 +1254,16 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp return true; } } - for (Term paramTerm : curField.getParams().orElse(Collections.emptyList())) { - if (paramTerm.contains(variable)) { - return true; + if(curField.isTypedField()) { + final TypedField typedField = curField.asTypedField().get(); + if (typedField.getType().isComplexTypeReference()) { + final ComplexTypeReference complexTypeReference = typedField.getType().asComplexTypeReference().get(); + List<Term> fieldParams = complexTypeReference.getParams().orElse(Collections.emptyList()); + for (Term param : fieldParams) { + if (param.contains(variable)) { + return true; + } + } } } return false; diff --git a/code-generation/language-go/src/main/resources/templates/go/data-io-template.go.ftlh b/code-generation/language-go/src/main/resources/templates/go/data-io-template.go.ftlh index a5a801a..cdbacdd 100644 --- a/code-generation/language-go/src/main/resources/templates/go/data-io-template.go.ftlh +++ b/code-generation/language-go/src/main/resources/templates/go/data-io-template.go.ftlh @@ -85,8 +85,8 @@ func ${type.name}Parse(readBuffer utils.ReadBuffer<#if parserArguments?has_conte // Array Field (${arrayField.name}) var ${arrayField.name} []api.PlcValue - for i := 0; i < int(${helper.toParseExpression(null, arrayField.loopExpression, parserArguments)}); i++ { - _item, _itemErr := <#if helper.isSimpleTypeReference(arrayField.type)>${helper.getReadBufferReadMethodCall(arrayField.name, arrayField.type.asSimpleTypeReference().orElseThrow())}<#else>Complex type array in data-io parsing currently not implemented</#if> + for i := 0; i < int(${helper.toParseExpression(arrayField, arrayField.loopExpression, parserArguments)}); i++ { + _item, _itemErr := <#if helper.isSimpleTypeReference(arrayField.type)>${helper.getReadBufferReadMethodCall(arrayField.name, arrayField.type.asSimpleTypeReference().orElseThrow(), arrayField)}<#else>Complex type array in data-io parsing currently not implemented</#if> if _itemErr != nil { return nil, errors.Wrap(_itemErr, "Error parsing 'value' field")<@emitImport import="github.com/pkg/errors" /> } @@ -112,7 +112,7 @@ func ${type.name}Parse(readBuffer utils.ReadBuffer<#if parserArguments?has_conte <#assign reservedField = field.asReservedField().orElseThrow()> // Reserved Field (Just skip the bytes) - if _, _err := ${helper.getReadBufferReadMethodCall("reserved", reservedField.type.asSimpleTypeReference().orElseThrow())}; _err != nil { + if _, _err := ${helper.getReadBufferReadMethodCall("reserved", reservedField.type.asSimpleTypeReference().orElseThrow(), reservedField)}; _err != nil { return nil, errors.Wrap(_err, "Error parsing reserved field")<@emitImport import="github.com/pkg/errors" /> } <#break> @@ -120,7 +120,7 @@ func ${type.name}Parse(readBuffer utils.ReadBuffer<#if parserArguments?has_conte <#assign simpleField = field.asSimpleField().orElseThrow()> // Simple Field (${simpleField.name}) - <#if case.name == "Struct" || ((case.name == "DATE_AND_TIME") && ((simpleField.name == "year") || (simpleField.name == "month") || (simpleField.name == "day") || (simpleField.name == "hour") || (simpleField.name == "minutes") || (simpleField.name == "seconds") || (simpleField.name == "secondsSinceEpoch"))) || ((case.name == "DATE") && ((simpleField.name == "year") || (simpleField.name == "month") || (simpleField.name == "day"))) || ((case.name == "TIME_OF_DAY") && ((simpleField.name = [...] + <#if case.name == "Struct" || ((case.name == "DATE_AND_TIME") && ((simpleField.name == "year") || (simpleField.name == "month") || (simpleField.name == "day") || (simpleField.name == "hour") || (simpleField.name == "minutes") || (simpleField.name == "seconds") || (simpleField.name == "secondsSinceEpoch"))) || ((case.name == "DATE") && ((simpleField.name == "year") || (simpleField.name == "month") || (simpleField.name == "day"))) || ((case.name == "TIME_OF_DAY") && ((simpleField.name = [...] if _${simpleField.name}Err != nil { return nil, errors.Wrap(_${simpleField.name}Err, "Error parsing '${simpleField.name}' field")<@emitImport import="github.com/pkg/errors" /> } @@ -188,7 +188,7 @@ func ${type.name}Serialize(writeBuffer utils.WriteBuffer, value api.PlcValue<#if <#assign arrayField = field.asArrayField().orElseThrow()> // Array Field (${arrayField.name}) - for i := uint32(0); i < uint32(${helper.toSerializationExpression(null, field.loopExpression, parserArguments)}); i++ { + for i := uint32(0); i < uint32(${helper.toSerializationExpression(arrayField, arrayField.loopExpression, parserArguments)}); i++ { <#if case.name = "Struct"> ${arrayField.name} := value.GetValue("${arrayField.name}") </#if> @@ -202,7 +202,7 @@ func ${type.name}Serialize(writeBuffer utils.WriteBuffer, value api.PlcValue<#if <#assign manualField = field.asManualField().orElseThrow()> // Manual Field (${manualField.name}) - _${manualField.name}Err := ${helper.toSerializationExpression(field, manualField.serializeExpression, parserArguments)} + _${manualField.name}Err := ${helper.toSerializationExpression(manualField, manualField.serializeExpression, parserArguments)} if _${manualField.name}Err != nil { return errors.Wrap(_${manualField.name}Err, "Error serializing '${manualField.name}' field")<@emitImport import="github.com/pkg/errors" /> } @@ -219,7 +219,7 @@ func ${type.name}Serialize(writeBuffer utils.WriteBuffer, value api.PlcValue<#if <#assign simpleField = field.asSimpleField().orElseThrow()> // Simple Field (${simpleField.name}) - if _err := <#if helper.isSimpleTypeReference(simpleField.type)>${helper.getWriteBufferWriteMethodCall(simpleField.name, simpleField.type.asSimpleTypeReference().orElseThrow(), "value.Get" + helper.getLanguageTypeNameForTypeReference(simpleField.type)?cap_first + "()", simpleField)}<#else>${simpleField.type.asComplexTypeReference().orElseThrow().name}Serialize(io, <#if simpleField.params.isPresent()>, <#list simpleField.params.orElseThrow() as parserArgument>(${helper.getLanguageTypeNa [...] + if _err := <#if helper.isSimpleTypeReference(simpleField.type)>${helper.getWriteBufferWriteMethodCall(simpleField.name, simpleField.type.asSimpleTypeReference().orElseThrow(), "value.Get" + helper.getLanguageTypeNameForTypeReference(simpleField.type)?cap_first + "()", simpleField)}<#else>${simpleField.type.asComplexTypeReference().orElseThrow().name}Serialize(io, <#if simpleField.type.asComplexTypeReference().orElseThrow().params.isPresent()>, <#list simpleField.type.asComplexTypeRefe [...] return errors.Wrap(_err, "Error serializing '${simpleField.name}' field")<@emitImport import="github.com/pkg/errors" /> } <#break> diff --git a/code-generation/language-go/src/main/resources/templates/go/enum-template.go.ftlh b/code-generation/language-go/src/main/resources/templates/go/enum-template.go.ftlh index 555f69f..07bef8c 100644 --- a/code-generation/language-go/src/main/resources/templates/go/enum-template.go.ftlh +++ b/code-generation/language-go/src/main/resources/templates/go/enum-template.go.ftlh @@ -166,15 +166,15 @@ func (m ${type.name}) LengthInBytes() uint16 { <#assign simpleTypeReference = type.type.asSimpleTypeReference().orElseThrow()> <#if simpleTypeReference.getSizeInBits() != -1> func ${type.name}Parse(readBuffer utils.ReadBuffer) (${type.name}, error) { - val, err := ${helper.getReadBufferReadMethodCall(type.name, helper.getEnumBaseTypeReference(type.typeReference))} + val, err := ${helper.getReadBufferReadMethodCall(type.name, type.type, null)} if err != nil { - return <#if type.type.isStringTypeReference()>""<#elseif baseType == "bool">false<#else>0</#if>, nil +<#-- return <#if type.type.isStringTypeReference()>""<#elseif baseType == "bool">false<#else>0</#if>, nil--> } return ${type.name}ByValue(val), nil } func (e ${type.name}) Serialize(writeBuffer utils.WriteBuffer) error { - return ${helper.getWriteBufferWriteMethodCall(type.name, helper.getEnumBaseTypeReference(type.typeReference), helper.getLanguageTypeNameForTypeReference(helper.getEnumBaseTypeReference(type.typeReference)) + "(e)", null, "utils.WithAdditionalStringRepresentation(e.name())")} + return ${helper.getWriteBufferWriteMethodCall(type.name, type.type, helper.getLanguageTypeNameForTypeReference(type.type) + "(e)", null, "utils.WithAdditionalStringRepresentation(e.name())")} } </#if> </#if> diff --git a/code-generation/language-go/src/main/resources/templates/go/model-template.go.ftlh b/code-generation/language-go/src/main/resources/templates/go/model-template.go.ftlh index 4d9cc96..abd6986 100644 --- a/code-generation/language-go/src/main/resources/templates/go/model-template.go.ftlh +++ b/code-generation/language-go/src/main/resources/templates/go/model-template.go.ftlh @@ -224,9 +224,9 @@ func (m *${type.name}) LengthInBitsConditional(lastItem bool) uint16 { // Array field if len(m.${arrayField.name?cap_first}) > 0 { - <#if helper.getLanguageTypeNameForTypeReference(arrayField.type) = "string"> - <#assign stringTypeReference = arrayField.type.asStringTypeReference().orElseThrow()> - lengthInBits += uint16(${helper.toSerializationExpression(arrayField, stringTypeReference.lengthExpression, parserArguments)}) * uint16(len(m.${arrayField.name?cap_first})) + <#if arrayField.type.isVstringTypeReference()> + <#assign vstringTypeReference = arrayField.type.asVstringTypeReference().orElseThrow()> + lengthInBits += uint16(${helper.toSerializationExpression(arrayField, vstringTypeReference.lengthExpression, parserArguments)}) * uint16(len(m.${arrayField.name?cap_first})) <#elseif helper.isSimpleTypeReference(arrayField.type)> <#assign simpleTypeReference = arrayField.type.asSimpleTypeReference().orElseThrow()> lengthInBits += ${simpleTypeReference.sizeInBits} * uint16(len(m.${arrayField.name?cap_first})) @@ -254,9 +254,9 @@ func (m *${type.name}) LengthInBitsConditional(lastItem bool) uint16 { <#assign constField = field.asConstField().orElseThrow()> // Const Field (${constField.name}) - <#if helper.getLanguageTypeNameForTypeReference(constField.type) = "string"> - <#assign stringTypeReference = constField.type.asStringTypeReference().orElseThrow()> - lengthInBits += uint16(${helper.toSerializationExpression(constField, stringTypeReference.lengthExpression, parserArguments)}) + <#if constField.type.isVstringTypeReference()> + <#assign vstringTypeReference = constField.type.asVstringTypeReference().orElseThrow()> + lengthInBits += uint16(${helper.toSerializationExpression(constField, vstringTypeReference.lengthExpression, parserArguments)}) <#else> <#assign simpleTypeReference = constField.type.asSimpleTypeReference().orElseThrow()> lengthInBits += ${simpleTypeReference.sizeInBits} @@ -267,9 +267,9 @@ func (m *${type.name}) LengthInBitsConditional(lastItem bool) uint16 { // Discriminator Field (${discriminatorField.name}) <#if helper.isSimpleTypeReference(discriminatorField.type)> <#assign simpleTypeReference = discriminatorField.type.asSimpleTypeReference().orElseThrow()> - <#if helper.getLanguageTypeNameForTypeReference(discriminatorField.type) = "String"> - <#assign stringTypeReference = discriminatorField.type.asStringTypeReference().orElseThrow()> - lengthInBits += uint16(${helper.toSerializationExpression(discriminatorField, stringTypeReference.getLengthExpression(), parserArguments)}) + <#if discriminatorField.type.isVstringTypeReference()> + <#assign vstringTypeReference = discriminatorField.type.asVstringTypeReference().orElseThrow()> + lengthInBits += uint16(${helper.toSerializationExpression(discriminatorField, vstringTypeReference.lengthExpression, parserArguments)}) <#else> lengthInBits += ${simpleTypeReference.sizeInBits}; </#if> @@ -342,9 +342,9 @@ func (m *${type.name}) LengthInBitsConditional(lastItem bool) uint16 { // Simple field (${simpleField.name}) <#if helper.isSimpleTypeReference(simpleField.type)> - <#if helper.getLanguageTypeNameForTypeReference(simpleField.type) = "string"> - <#assign stringTypeReference = simpleField.type.asStringTypeReference().orElseThrow()> - lengthInBits += uint16(${helper.toSerializationExpression(simpleField, stringTypeReference.lengthExpression, parserArguments)}) + <#if simpleField.type.isVstringTypeReference()> + <#assign vstringTypeReference = simpleField.type.asVstringTypeReference().orElseThrow()> + lengthInBits += uint16(${helper.toSerializationExpression(simpleField, vstringTypeReference.lengthExpression, parserArguments)}) <#else> <#assign simpleTypeReference = simpleField.type.asSimpleTypeReference().orElseThrow()> lengthInBits += ${simpleTypeReference.sizeInBits}; @@ -391,9 +391,9 @@ func (m *${type.name}) ParentLengthInBits() uint16 { // Array field if len(m.${arrayField.name?cap_first}) > 0 { - <#if helper.getLanguageTypeNameForTypeReference(arrayField.type) = "string"> - <#assign stringTypeReference=arrayField.type.asSimpleTypeReference().orElseThrow()> - lengthInBits += uint16(${helper.toSerializationExpression(arrayField, stringTypeReference.asStringTypeReference().orElseThrow().getLengthExpression(), parserArguments)}) * uint16(len(m.${arrayField.name?cap_first})) + <#if arrayField.type.isVstringTypeReference()> + <#assign vstringTypeReference=arrayField.type.asVstringTypeReference().orElseThrow()> + lengthInBits += uint16(${helper.toSerializationExpression(arrayField, vstringTypeReference.lengthExpression, parserArguments)}) * uint16(len(m.${arrayField.name?cap_first})) <#elseif helper.isSimpleTypeReference(arrayField.type)> <#assign simpleTypeReference = arrayField.type.asSimpleTypeReference().orElseThrow()> lengthInBits += ${simpleTypeReference.sizeInBits} * uint16(len(m.${arrayField.name?cap_first})) @@ -422,8 +422,9 @@ func (m *${type.name}) ParentLengthInBits() uint16 { <#assign simpleTypeReference = constField.type> // Const Field (${constField.name}) - <#if helper.getLanguageTypeNameForTypeReference(constField.type) = "string"> - lengthInBits += uint16(${helper.toSerializationExpression(constField, simpleTypeReference.asStringTypeReference().orElseThrow().getLengthExpression(), parserArguments)}) + <#if constField.type.isVstringTypeReference()> + <#assign vstringTypeReference = constField.type.asVstringTypeReference().orElseThrow()> + lengthInBits += uint16(${helper.toSerializationExpression(constField, vstringTypeReference.lengthExpression, parserArguments)}) <#elseif helper.isEnumTypeReference(constField.type)> lengthInBits += ${helper.getEnumBaseTypeReference(constField.type).sizeInBits}; <#else> @@ -435,8 +436,9 @@ func (m *${type.name}) ParentLengthInBits() uint16 { <#assign simpleTypeReference = discriminatorField.type> // Discriminator Field (${discriminatorField.name}) <#if helper.isSimpleTypeReference(simpleTypeReference)> - <#if helper.getLanguageTypeNameForTypeReference(discriminatorField.type) = "String"> - lengthInBits += uint16(${helper.toSerializationExpression(discriminatorField, discriminatorField.type.asStringTypeReference().orElseThrow().getLengthExpression(), parserArguments)}) + <#if discriminatorField.type.isVstringTypeReference()> + <#assign vstringTypeReference = discriminatorField.type.asVstringTypeReference().orElseThrow()> + lengthInBits += uint16(${helper.toSerializationExpression(discriminatorField, discriminatorField.lengthExpression, parserArguments)}) <#else> lengthInBits += ${simpleTypeReference.asSimpleTypeReference().orElseThrow().sizeInBits}; </#if> @@ -508,9 +510,9 @@ func (m *${type.name}) ParentLengthInBits() uint16 { // Simple field (${simpleField.name}) <#if helper.isSimpleTypeReference(simpleField.type)> - <#if helper.getLanguageTypeNameForTypeReference(simpleField.type) = "string"> - <#assign stringTypeReference = simpleField.type.asStringTypeReference().orElseThrow()> - lengthInBits += uint16(${helper.toSerializationExpression(simpleField, stringTypeReference.lengthExpression, parserArguments)}) + <#if simpleField.type.isVstringTypeReference()> + <#assign vstringTypeReference = simpleField.type.asVstringTypeReference().orElseThrow()> + lengthInBits += uint16(${helper.toSerializationExpression(simpleField, vstringTypeReference.lengthExpression, parserArguments)}) <#else> <#assign simpleTypeReference = simpleField.type.asSimpleTypeReference().orElseThrow()> lengthInBits += ${simpleTypeReference.sizeInBits}; @@ -566,12 +568,12 @@ func ${type.name}Parse(readBuffer utils.ReadBuffer<#if hasParserArguments>, ${pa <#assign numberOfBytesExpression> <#compress> <#if field.isCountArrayField()> - numberOfBytes := int(${helper.toIntegerParseExpression(16, arrayField.loopExpression, parserArguments)}) + numberOfBytes := int(${helper.toIntegerParseExpression(field, 16, arrayField.loopExpression, parserArguments)}) <#elseif field.isLengthArrayField()> - numberOfBytes := int(${helper.toIntegerParseExpression(16, arrayField.loopExpression, parserArguments)}) + numberOfBytes := int(${helper.toIntegerParseExpression(field, 16, arrayField.loopExpression, parserArguments)}) <#elseif field.isTerminatedArrayField()> <#-- TODO: we need to find out to implement this--> - numberOfBytes := int(${helper.toIntegerParseExpression(16, arrayField.loopExpression, parserArguments)}) + numberOfBytes := int(${helper.toIntegerParseExpression(field, 16, arrayField.loopExpression, parserArguments)}) <#else> <#-- TODO: we should throw a exception here--> numberOfBytes := int(-1) @@ -596,12 +598,12 @@ func ${type.name}Parse(readBuffer utils.ReadBuffer<#if hasParserArguments>, ${pa <#-- If this is a count array, we can directly initialize an array with the given size --> <#if field.isCountArrayField()> // Count array - ${arrayField.name} := make([]<#if helper.isComplexTypeReference(arrayField.type)>*</#if>${helper.getLanguageTypeNameForField(field)}, ${helper.toIntegerParseExpression(16, arrayField.loopExpression, parserArguments)}) - for curItem := uint16(0); curItem < uint16(${helper.toIntegerParseExpression(16, arrayField.loopExpression, parserArguments)}); curItem++ { + ${arrayField.name} := make([]<#if helper.isComplexTypeReference(arrayField.type)>*</#if>${helper.getLanguageTypeNameForField(field)}, ${helper.toIntegerParseExpression(arrayField, 16, arrayField.loopExpression, parserArguments)}) + for curItem := uint16(0); curItem < uint16(${helper.toIntegerParseExpression(arrayField, 16, arrayField.loopExpression, parserArguments)}); curItem++ { <#if (!helper.isSimpleTypeReference(arrayField.type)) && helper.requiresVariable(arrayField, "lastItem")> lastItem := curItem == uint16(${helper.toParseExpression(arrayField, arrayField.loopExpression, parserArguments)} - 1) </#if> - _item, _err := <#if helper.isSimpleTypeReference(arrayField.type)>${helper.getReadBufferReadMethodCall("", arrayField.type.asSimpleTypeReference().orElseThrow())}<#else>${arrayField.type.asComplexTypeReference().orElseThrow().name}Parse(readBuffer<#if field.params.isPresent()>, <#list field.params.orElseThrow() as parserArgument><#if <#--TODO: here DF1ResponseMessage throws a payloadLength not present: meaning that some feature is not rightfully implemented as the result should be a er [...] + _item, _err := <#if helper.isSimpleTypeReference(arrayField.type)>${helper.getReadBufferReadMethodCall("", arrayField.type.asSimpleTypeReference().orElseThrow(), arrayField)}<#else>${arrayField.type.asComplexTypeReference().orElseThrow().name}Parse(readBuffer<#if arrayField.type.asComplexTypeReference().orElseThrow().params.isPresent()>, <#list arrayField.type.asComplexTypeReference().orElseThrow().params.orElseThrow() as parserArgument><#if <#--TODO: here DF1ResponseMessage throws a p [...] if _err != nil { return nil, errors.Wrap(_err, "Error parsing '${arrayField.name}' field")<@emitImport import="github.com/pkg/errors" /> } @@ -612,10 +614,10 @@ func ${type.name}Parse(readBuffer utils.ReadBuffer<#if hasParserArguments>, ${pa <#-- For a length array, we read data till the read position of the buffer reaches a given position --> // Length array ${arrayField.name} := make([]<#if helper.isComplexTypeReference(arrayField.type)>*</#if>${helper.getLanguageTypeNameForField(field)}, 0) - _${arrayField.name}Length := ${helper.toIntegerParseExpression(16, arrayField.loopExpression, parserArguments)} + _${arrayField.name}Length := ${helper.toIntegerParseExpression(arrayField, 16, arrayField.loopExpression, parserArguments)} _${arrayField.name}EndPos := readBuffer.GetPos() + uint16(_${arrayField.name}Length) for ;readBuffer.GetPos() < _${arrayField.name}EndPos; { - _item, _err := <#if helper.isSimpleTypeReference(arrayField.type)>${helper.getReadBufferReadMethodCall("", arrayField.type.asSimpleTypeReference().orElseThrow())}<#else>${arrayField.type.asComplexTypeReference().orElseThrow().name}Parse(readBuffer<#if field.params.isPresent()>, <#list field.params.orElseThrow() as parserArgument><#if <#--TODO: here DF1ResponseMessage throws a payloadLength not present: meaning that some feature is not rightfully implemented as the result should be a er [...] + _item, _err := <#if helper.isSimpleTypeReference(arrayField.type)>${helper.getReadBufferReadMethodCall("", arrayField.type.asSimpleTypeReference().orElseThrow(), arrayField)}<#else>${arrayField.type.asComplexTypeReference().orElseThrow().name}Parse(readBuffer<#if arrayField.type.asComplexTypeReference().orElseThrow().params.isPresent()>, <#list arrayField.type.asComplexTypeReference().orElseThrow().params.orElseThrow() as parserArgument><#if <#--TODO: here DF1ResponseMessage throws a p [...] if _err != nil { return nil, errors.Wrap(_err, "Error parsing '${arrayField.name}' field")<@emitImport import="github.com/pkg/errors" /> } @@ -630,7 +632,7 @@ func ${type.name}Parse(readBuffer utils.ReadBuffer<#if hasParserArguments>, ${pa // Terminated array ${arrayField.name} := make([]<#if helper.isComplexTypeReference(arrayField.type)>*</#if>${helper.getLanguageTypeNameForField(field)}, 0) for ;!bool(${helper.toParseExpression(arrayField, arrayField.loopExpression, parserArguments)}); { - _item, _err := <#if helper.isSimpleTypeReference(arrayField.type)>${helper.getReadBufferReadMethodCall("", arrayField.type.asSimpleTypeReference().orElseThrow())}<#else>${arrayField.type.asComplexTypeReference().orElseThrow().name}Parse(readBuffer<#if field.params.isPresent()>, <#list field.params.orElseThrow() as parserArgument><#if <#--TODO: here DF1ResponseMessage throws a payloadLength not present: meaning that some feature is not rightfully implemented as the result should be a er [...] + _item, _err := <#if helper.isSimpleTypeReference(arrayField.type)>${helper.getReadBufferReadMethodCall("", arrayField.type.asSimpleTypeReference().orElseThrow(), arrayField)}<#else>${arrayField.type.asComplexTypeReference().orElseThrow().name}Parse(readBuffer<#if arrayField.type.asComplexTypeReference().orElseThrow().params.isPresent()>, <#list arrayField.type.asComplexTypeReference().orElseThrow().params.orElseThrow() as parserArgument><#if <#--TODO: here DF1ResponseMessage throws a p [...] if _err != nil { return nil, errors.Wrap(_err, "Error parsing '${arrayField.name}' field")<@emitImport import="github.com/pkg/errors" /> } @@ -653,7 +655,7 @@ func ${type.name}Parse(readBuffer utils.ReadBuffer<#if hasParserArguments>, ${pa // Checksum Field (checksum) { - checksumRef, _checksumRefErr := ${helper.getReadBufferReadMethodCall("checksum", simpleTypeReference)} + checksumRef, _checksumRefErr := ${helper.getReadBufferReadMethodCall("checksum", simpleTypeReference, checksumField)} if _checksumRefErr != nil { return nil, errors.Wrap(_checksumRefErr, "Error parsing 'checksum' field")<@emitImport import="github.com/pkg/errors" /> } @@ -674,7 +676,7 @@ func ${type.name}Parse(readBuffer utils.ReadBuffer<#if hasParserArguments>, ${pa <#--<#assign constField=constField.asEnumField().orElseThrow()>--> <#-- TODO: finish me--> <#if false && constField.fieldName.isPresent()> - ${constField.name}${constField.fieldName.orElseThrow()?cap_first}, _${constField.name}${constField.fieldName.orElseThrow()?cap_first}Err := ${helper.getReadBufferReadMethodCall(constField.name, helper.getEnumFieldSimpleTypeReference(constField.type, constField.fieldName.orElseThrow()))} + ${constField.name}${constField.fieldName.orElseThrow()?cap_first}, _${constField.name}${constField.fieldName.orElseThrow()?cap_first}Err := ${helper.getReadBufferReadMethodCall(constField.name, helper.getEnumFieldSimpleTypeReference(constField.type, constField.fieldName.orElseThrow()), constField)} if _${constField.name}${constField.fieldName.orElseThrow()?cap_first}Err != nil { return nil, errors.Wrap(_${constField.name}${constField.fieldName.orElseThrow()?cap_first}Err, "Error serializing '${constField.name}' field")<@emitImport import="github.com/pkg/errors" /> } @@ -689,7 +691,7 @@ func ${type.name}Parse(readBuffer utils.ReadBuffer<#if hasParserArguments>, ${pa } </#if> <#else> - ${constField.name}, _${constField.name}Err := ${helper.getReadBufferReadMethodCall(constField.name, constField.type.asSimpleTypeReference().orElseThrow())} + ${constField.name}, _${constField.name}Err := ${helper.getReadBufferReadMethodCall(constField.name, constField.type.asSimpleTypeReference().orElseThrow(), constField)} </#if> if _${constField.name}Err != nil { return nil, errors.Wrap(_${constField.name}Err, "Error parsing '${constField.name}' field")<@emitImport import="github.com/pkg/errors" /> @@ -707,7 +709,7 @@ func ${type.name}Parse(readBuffer utils.ReadBuffer<#if hasParserArguments>, ${pa var ${helper.getVariableName(field)} ${helper.getLanguageTypeNameForField(discriminatorField)} = ${helper.getVariableName(field)}_temp <#else> <#assign simpleTypeReference = discriminatorField.type.asSimpleTypeReference().orElseThrow()> - ${helper.getVariableName(field)}, _${discriminatorField.name}Err := ${helper.getReadBufferReadMethodCall(discriminatorField.name, simpleTypeReference)} + ${helper.getVariableName(field)}, _${discriminatorField.name}Err := ${helper.getReadBufferReadMethodCall(discriminatorField.name, simpleTypeReference, discriminatorField)} </#if> if _${discriminatorField.name}Err != nil { return nil, errors.Wrap(_${discriminatorField.name}Err, "Error parsing '${discriminatorField.name}' field")<@emitImport import="github.com/pkg/errors" /> @@ -719,23 +721,15 @@ func ${type.name}Parse(readBuffer utils.ReadBuffer<#if hasParserArguments>, ${pa if pullErr := readBuffer.PullContext("${enumField.name}"); pullErr != nil { return nil, pullErr } - <#if enumField.fieldName.isPresent()> // Enum field (${enumField.name}) - ${enumField.name}${enumField.fieldName.orElseThrow()?cap_first}, _${enumField.name}${enumField.fieldName.orElseThrow()?cap_first}Err := ${helper.getReadBufferReadMethodCall(enumField.type.name, helper.getEnumFieldSimpleTypeReference(enumField.type, enumField.fieldName.orElseThrow()))} - if _${enumField.name}${enumField.fieldName.orElseThrow()?cap_first}Err != nil { - return nil, errors.Wrap(_${enumField.name}${enumField.fieldName.orElseThrow()?cap_first}Err, "Error serializing '${enumField.name}' field")<@emitImport import="github.com/pkg/errors" /> + ${enumField.name}${enumField.fieldName?cap_first}, _${enumField.name}${enumField.fieldName?cap_first}Err := ${helper.getReadBufferReadMethodCall(enumField.type.name, helper.getEnumFieldSimpleTypeReference(enumField.type, enumField.fieldName), enumField)} + if _${enumField.name}${enumField.fieldName?cap_first}Err != nil { + return nil, errors.Wrap(_${enumField.name}${enumField.fieldName?cap_first}Err, "Error serializing '${enumField.name}' field")<@emitImport import="github.com/pkg/errors" /> } - ${enumField.name}, _${enumField.name}Err := ${helper.getLanguageTypeNameForField(field)}FirstEnumForField${enumField.fieldName.orElseThrow()?cap_first}(${enumField.name}${enumField.fieldName.orElseThrow()?cap_first}) + ${enumField.name}, _${enumField.name}Err := ${helper.getLanguageTypeNameForField(field)}FirstEnumForField${enumField.fieldName?cap_first}(${enumField.name}${enumField.fieldName?cap_first}) if _${enumField.name}Err != nil { return nil, errors.Wrap(_${enumField.name}Err, "Error serializing '${enumField.name}' field")<@emitImport import="github.com/pkg/errors" /> } - <#else> - // Enum field (${enumField.name}) - ${enumField.name}, _${enumField.name}Err := ${helper.getLanguageTypeNameForField(field)}Parse(readBuffer) - if _${enumField.name}Err != nil { - return nil, errors.Wrap(_${enumField.name}Err, "Error parsing '${enumField.name}' field")<@emitImport import="github.com/pkg/errors" /> - } - </#if> if closeErr := readBuffer.CloseContext("${enumField.name}"); closeErr != nil { return nil, closeErr } @@ -745,7 +739,7 @@ func ${type.name}Parse(readBuffer utils.ReadBuffer<#if hasParserArguments>, ${pa <#assign simpleTypeReference = implicitField.type.asSimpleTypeReference().orElseThrow()> // Implicit Field (${implicitField.name}) (Used for parsing, but it's value is not stored as it's implicitly given by the objects content) - ${implicitField.name}, _${implicitField.name}Err := ${helper.getReadBufferReadMethodCall(implicitField.name, simpleTypeReference)} + ${implicitField.name}, _${implicitField.name}Err := ${helper.getReadBufferReadMethodCall(implicitField.name, simpleTypeReference, implicitField)} _ = ${implicitField.name} if _${implicitField.name}Err != nil { return nil, errors.Wrap(_${implicitField.name}Err, "Error parsing '${implicitField.name}' field")<@emitImport import="github.com/pkg/errors" /> @@ -774,7 +768,7 @@ func ${type.name}Parse(readBuffer utils.ReadBuffer<#if hasParserArguments>, ${pa <#-- For a length array, we read data till the read position of the buffer reaches a given position --> <#if field.isLengthArrayField()> // Length array - _${manualArrayField.name}Length := ${helper.toIntegerParseExpression(16, manualArrayField.loopExpression, parserArguments)} + _${manualArrayField.name}Length := ${helper.toIntegerParseExpression(manualArrayField, 16, manualArrayField.loopExpression, parserArguments)} _${manualArrayField.name}List := make([]${helper.getLanguageTypeNameForField(manualArrayField)}, 0) ${manualArrayField.name}EndPos := readBuffer.GetPos() + _${manualArrayField.name}Length for ;readBuffer.GetPos() < ${manualArrayField.name}EndPos; { @@ -839,9 +833,9 @@ func ${type.name}Parse(readBuffer utils.ReadBuffer<#if hasParserArguments>, ${pa </#if> var ${optionalField.name} *${helper.getLanguageTypeNameForField(field)} = nil <#if optionalField.conditionExpression.present> - if ${helper.toBooleanParseExpression(optionalField.conditionExpression.get(), parserArguments)} </#if>{ + if ${helper.toBooleanParseExpression(optionalField, optionalField.conditionExpression.get(), parserArguments)} </#if>{ <#if helper.isSimpleTypeReference(optionalField.type)> - _val, _err := ${helper.getReadBufferReadMethodCall(optionalField.name, optionalField.type.asSimpleTypeReference().orElseThrow())} + _val, _err := ${helper.getReadBufferReadMethodCall(optionalField.name, optionalField.type.asSimpleTypeReference().orElseThrow(), optionalField)} if _err != nil { return nil, errors.Wrap(_err, "Error parsing '${optionalField.name}' field")<@emitImport import="github.com/pkg/errors" /> } @@ -862,12 +856,12 @@ func ${type.name}Parse(readBuffer utils.ReadBuffer<#if hasParserArguments>, ${pa <#assign typeName=typeDefinition.parentType.name> <#assign typeDefinition=typeDefinition.parentType> </#if> - <#assign hasFieldParams=field.params.isPresent()> + <#assign hasFieldParams=complexTypeReference.params.isPresent()> <#assign fieldParams> <#if hasFieldParams> , - <#list field.params.orElseThrow() as parserArgument> - ${helper.toTypedParseExpression(helper.getArgumentType(optionalField.type, parserArgument?index), parserArgument, parserArguments)} + <#list complexTypeReference.params.orElseThrow() as parserArgument> + ${helper.toTypedParseExpression(optionalField, helper.getArgumentType(optionalField.type, parserArgument?index), parserArgument, parserArguments)} <#sep>, </#sep> </#list> </#if> @@ -877,7 +871,7 @@ func ${type.name}Parse(readBuffer utils.ReadBuffer<#if hasParserArguments>, ${pa <#if hasRefParams> , <#list complexTypeReference.params.orElseThrow() as typeParam> - ${helper.toTypedParseExpression(null, typeParam, null)} + ${helper.toTypedParseExpression(optionalField, null, typeParam, null)} <#sep>, </#sep> </#list> </#if> @@ -900,7 +894,7 @@ func ${type.name}Parse(readBuffer utils.ReadBuffer<#if hasParserArguments>, ${pa curPos = readBuffer.GetPos() - startPos </#if> <#if helper.isSimpleTypeReference(assertField.type)> - ${assertField.name}, _err := ${helper.getReadBufferReadMethodCall(assertField.name, assertField.type.asSimpleTypeReference().orElseThrow())} + ${assertField.name}, _err := ${helper.getReadBufferReadMethodCall(assertField.name, assertField.type.asSimpleTypeReference().orElseThrow(), assertField)} if _err != nil { return nil, errors.Wrap(_err, "Error parsing '${assertField.name}' field")<@emitImport import="github.com/pkg/errors" /> } @@ -919,10 +913,10 @@ func ${type.name}Parse(readBuffer utils.ReadBuffer<#if hasParserArguments>, ${pa <#assign typeName=typeDefinition.parentType.name> <#assign typeDefinition=typeDefinition.parentType> </#if> - <#assign hasFieldParams=field.params.isPresent()> - <#assign fieldParams><#if hasFieldParams>, <#list field.params.orElseThrow() as parserArgument>${helper.toTypedParseExpression(helper.getArgumentType(assertField.type, parserArgument?index), parserArgument, parserArguments)}<#sep>, </#sep></#list></#if></#assign> + <#assign hasFieldParams=complexTypeReference.params.isPresent()> + <#assign fieldParams><#if hasFieldParams>, <#list complexTypeReference.params.orElseThrow() as parserArgument>${helper.toTypedParseExpression(assertField, helper.getArgumentType(assertField.type, parserArgument?index), parserArgument, parserArguments)}<#sep>, </#sep></#list></#if></#assign> <#assign hasRefParams=complexTypeReference.params.isPresent() && typeDefinition.parserArguments.isPresent()> - <#assign refParams> <#if hasRefParams>, <#list complexTypeReference.params.orElseThrow() as typeParam>${helper.toTypedParseExpression(null, typeParam, null)}<#sep>, </#sep></#list> </#if> </#assign> + <#assign refParams> <#if hasRefParams>, <#list complexTypeReference.params.orElseThrow() as typeParam>${helper.toTypedParseExpression(assertField, null, typeParam, null)}<#sep>, </#sep></#list> </#if> </#assign> </@compress> _val, _err := ${helper.getLanguageTypeNameForField(field)}Parse(readBuffer${fieldParams}${refParams}) if _err != nil { @@ -943,7 +937,7 @@ func ${type.name}Parse(readBuffer utils.ReadBuffer<#if hasParserArguments>, ${pa _timesPadding := (${helper.toParseExpression(paddingField, paddingField.paddingCondition, parserArguments)}) for ;(readBuffer.HasMore(${helper.getNumBits(simpleTypeReference)})) && (_timesPadding > 0);_timesPadding-- { // Just read the padding data and ignore it - _, _err := ${helper.getReadBufferReadMethodCall("", simpleTypeReference)} + _, _err := ${helper.getReadBufferReadMethodCall("", simpleTypeReference, paddingField)} if _err != nil { return nil, errors.Wrap(_err, "Error parsing 'padding' field")<@emitImport import="github.com/pkg/errors" /> } @@ -959,7 +953,7 @@ func ${type.name}Parse(readBuffer utils.ReadBuffer<#if hasParserArguments>, ${pa // Reserved Field (Compartmentalized so the "reserved" variable can't leak) { - reserved, _err := ${helper.getReadBufferReadMethodCall("reserved", simpleTypeReference)} + reserved, _err := ${helper.getReadBufferReadMethodCall("reserved", simpleTypeReference, reservedField)} if _err != nil { return nil, errors.Wrap(_err, "Error parsing 'reserved' field")<@emitImport import="github.com/pkg/errors" /> } @@ -994,12 +988,12 @@ func ${type.name}Parse(readBuffer utils.ReadBuffer<#if hasParserArguments>, ${pa <#assign typeName=typeDefinition.parentType.name> <#assign typeDefinition=typeDefinition.parentType> </#if> - <#assign hasFieldParams=field.params.isPresent()> + <#assign hasFieldParams=complexTypeReference.params.isPresent()> <#assign fieldParams> <#if hasFieldParams> , - <#list field.params.orElseThrow() as parserArgument> - ${helper.toTypedParseExpression(helper.getArgumentType(simpleField.type, parserArgument?index), parserArgument, parserArguments)} + <#list complexTypeReference.params.orElseThrow() as parserArgument> + ${helper.toTypedParseExpression(simpleField, helper.getArgumentType(simpleField.type, parserArgument?index), parserArgument, parserArguments)} <#sep>, </#sep> </#list> </#if> @@ -1009,7 +1003,7 @@ func ${type.name}Parse(readBuffer utils.ReadBuffer<#if hasParserArguments>, ${pa <#if hasRefParams> , <#list complexTypeReference.params.orElseThrow() as typeParam> - ${helper.toTypedParseExpression(null, typeParam, null)} + ${helper.toTypedParseExpression(simpleField, null, typeParam, null)} <#sep>, </#sep> </#list> </#if> @@ -1191,7 +1185,7 @@ func (m *${type.name}) Serialize(writeBuffer utils.WriteBuffer<#if helper.getSer <#if helper.needsVariable(arrayField, "lastItem", true)> var lastItem bool = curItem == (itemCount - 1) </#if> - _elementErr := _element.Serialize(writeBuffer<#if helper.getSerializerTerms(arrayField.params.orElse(null))?has_content>, <#list helper.getSerializerTerms(arrayField.params.orElse(null)) as parserArgument>${parserArgument.name}<#sep>, </#sep></#list></#if>) + _elementErr := _element.Serialize(writeBuffer<#if helper.getSerializerTerms(arrayField.asTypedField().orElseThrow().type.asComplexTypeReference().orElseThrow().params.orElse(null))?has_content>, <#list helper.getSerializerTerms(arrayField.asTypedField().orElseThrow().type.asComplexTypeReference().orElseThrow().params.orElse(null)) as parserArgument>${parserArgument.name}<#sep>, </#sep></#list></#if>) </#if> if _elementErr != nil { return errors.Wrap(_elementErr, "Error serializing '${arrayField.name}' field")<@emitImport import="github.com/pkg/errors" /> @@ -1230,7 +1224,7 @@ func (m *${type.name}) Serialize(writeBuffer utils.WriteBuffer<#if helper.getSer <#if constField.fieldName?has_content> <#assign enumValueFieldAccessor=type.name+"_"+constField.name?upper_case> // Const field (${constField.name}) - _${constField.name}Err := ${helper.getWriteBufferWriteMethodCall(constField.type.name, helper.getEnumFieldSimpleTypeReference(constField.type, constField.fieldName), enumValueFieldAccessor, constField, "utils.WithAdditionalStringRepresentation(${type.name}_${constField.name?upper_case}.name())")} + _${constField.name}Err := ${helper.getWriteBufferWriteMethodCall(constField, constField.type.name, helper.getEnumFieldSimpleTypeReference(constField.type, constField.fieldName), enumValueFieldAccessor, constField, "utils.WithAdditionalStringRepresentation(${type.name}_${constField.name?upper_case}.name())")} if _${constField.name}Err != nil { return errors.Wrap(_${constField.name}Err, "Error serializing '${constField.name}' field")<@emitImport import="github.com/pkg/errors" /> } @@ -1272,21 +1266,12 @@ func (m *${type.name}) Serialize(writeBuffer utils.WriteBuffer<#if helper.getSer if pushErr := writeBuffer.PushContext("${enumField.name}"); pushErr != nil { return pushErr } - <#if enumField.fieldName.isPresent()> - <#assign enumValueFieldAccessor="m."+enumField.name?cap_first+"."+enumField.fieldName.orElseThrow()?cap_first+"()"> + <#assign enumValueFieldAccessor="m."+enumField.name?cap_first+"."+enumField.fieldName?cap_first+"()"> // Enum field (${enumField.name}) - _${enumField.name}Err := ${helper.getWriteBufferWriteMethodCall(enumField.type.asComplexTypeReference().orElseThrow().name, helper.getEnumFieldSimpleTypeReference(enumField.type, enumField.fieldName.orElseThrow()), enumValueFieldAccessor, enumField, "utils.WithAdditionalStringRepresentation(m.${enumField.name?cap_first}.name())")} + _${enumField.name}Err := ${helper.getWriteBufferWriteMethodCall(enumField.type.asComplexTypeReference().orElseThrow().name, helper.getEnumFieldSimpleTypeReference(enumField.type, enumField.fieldName), enumValueFieldAccessor, enumField, "utils.WithAdditionalStringRepresentation(m.${enumField.name?cap_first}.name())")} if _${enumField.name}Err != nil { return errors.Wrap(_${enumField.name}Err, "Error serializing '${enumField.name}' field")<@emitImport import="github.com/pkg/errors" /> } - <#else> - // Enum field (${enumField.name}) - ${enumField.name} := Cast${helper.getLanguageTypeNameForField(field)}(m.${enumField.name?cap_first}) - _${enumField.name}Err := ${enumField.name}.Serialize(writeBuffer) - if _${enumField.name}Err != nil { - return errors.Wrap(_${enumField.name}Err, "Error serializing '${enumField.name}' field")<@emitImport import="github.com/pkg/errors" /> - } - </#if> if popErr := writeBuffer.PopContext("${enumField.name}"); popErr != nil { return popErr } diff --git a/code-generation/language-go/src/test/resources/plc4go/pom.xml b/code-generation/language-go/src/test/resources/plc4go/pom.xml index af60ac7..3106619 100644 --- a/code-generation/language-go/src/test/resources/plc4go/pom.xml +++ b/code-generation/language-go/src/test/resources/plc4go/pom.xml @@ -229,39 +229,6 @@ <dependencies> <dependency> <groupId>org.apache.plc4x</groupId> - <artifactId>plc4j-api</artifactId> - <version>@project.version@</version> - </dependency> - <dependency> - <groupId>org.apache.plc4x</groupId> - <artifactId>plc4j-spi</artifactId> - <version>@project.version@</version> - </dependency> - <dependency> - <groupId>org.apache.plc4x</groupId> - <artifactId>plc4j-transport-tcp</artifactId> - <version>@project.version@</version> - </dependency> - <dependency> - <groupId>io.netty</groupId> - <artifactId>netty-buffer</artifactId> - </dependency> - <dependency> - <groupId>org.apache.commons</groupId> - <artifactId>commons-lang3</artifactId> - </dependency> - <dependency> - <groupId>com.fasterxml.jackson.core</groupId> - <artifactId>jackson-annotations</artifactId> - </dependency> - <dependency> - <groupId>org.apache.plc4x</groupId> - <artifactId>plc4j-utils-test-utils</artifactId> - <version>@project.version@</version> - <scope>test</scope> - </dependency> - <dependency> - <groupId>org.apache.plc4x</groupId> <artifactId>plc4x-code-generation-language-go</artifactId> <version>@project.version@</version> <!-- Scope is 'provided' as this way it's not shipped with the driver -->
