feat(code-gen/go): enum field writer

code-generation/language-go/src/main/java/org/apache/plc4x/language/go/GoLanguageTemplateHelper.java

@@ -465,7 +465,7 @@ public String getDataReaderCall(TypeReference typeReference, String resolverMeth
             String paramsStringString = paramsString.toString();
             if (StringUtils.isNotBlank(paramsStringString) || typeDefinition.isDiscriminatedChildTypeDefinition()) { // In this case we need to spell the function out
                 String genericTypeParam = "";
-                if (typeDefinition.isDiscriminatedParentTypeDefinition()||typeDefinition.isDiscriminatedChildTypeDefinition()) {
+                if (typeDefinition.isDiscriminatedParentTypeDefinition() || typeDefinition.isDiscriminatedChildTypeDefinition()) {
                     genericTypeParam = "[" + typeName + "]";
                 }
                 return "ReadComplex[" + typeName + "](" + parserCallString + "ParseWithBufferProducer" + genericTypeParam + "(" + StringUtils.substring(paramsStringString, 2) + "), readBuffer)";
@@ -544,7 +544,7 @@ public String getEnumDataWriterCall(EnumTypeReference typeReference, String fiel
         } else {
             outputTypeReference = getEnumFieldSimpleTypeReference(typeReference.asNonSimpleTypeReference().orElseThrow(), attributeName);
         }
-        return "WriteEnum(" + languageTypeName + "::get" + StringUtils.capitalize(attributeName) + ", " + languageTypeName + "::name, " + getDataWriterCall(outputTypeReference, fieldName) + ")";
+        return "WriteEnum[" + languageTypeName + "," + getLanguageTypeNameForTypeReference(outputTypeReference) + "](ctx, " + languageTypeName + ".Get" + StringUtils.capitalize(attributeName) + ", " + languageTypeName + ".PLC4XEnumName, " + getDataWriterCall(outputTypeReference, fieldName) + ")";
     }
 
     public String getDataWriterCall(SimpleTypeReference simpleTypeReference) {

code-generation/language-go/src/main/resources/templates/go/complex-type-template.go.ftlh

@@ -1249,27 +1249,13 @@ func (m *_${type.name}) SerializeWithWriteBuffer(ctx context.Context, writeBuffe
 				<#break>
 				<#case "discriminator">
 					<#assign discriminatorField = field.asDiscriminatorField().orElseThrow()>
+					<#assign typedField = field.asTypedField().orElseThrow()>
+					<#assign namedField = field.asNamedField().orElseThrow()>
 
-	// Discriminator Field (${discriminatorField.name}) (Used as input to a switch field)
-	${discriminatorField.name} := ${helper.getLanguageTypeNameForField(field)}(child.Get${discriminatorField.name?cap_first}())
-					<#if helper.isEnumField(field)>
-                        <#assign namedField = field.asNamedField().orElseThrow()>
-	if pushErr := writeBuffer.PushContext("${namedField.name}"); pushErr != nil {
-		return errors.Wrap(pushErr, "Error pushing for ${namedField.name}")<@emitImport import="github.com/pkg/errors" />
-	}
-	_${discriminatorField.name}Err := writeBuffer.WriteSerializable(ctx, ${discriminatorField.name})
-	if popErr := writeBuffer.PopContext("${namedField.name}"); popErr != nil {
-		return errors.Wrap(popErr, "Error popping for ${namedField.name}")<@emitImport import="github.com/pkg/errors" />
-	}
-					<#else>
-                        <#assign simpleTypeReference = discriminatorField.type.asSimpleTypeReference().orElseThrow()>
-	_${discriminatorField.name}Err := ${helper.getWriteBufferWriteMethodCall(discriminatorField.name, simpleTypeReference, "(" + discriminatorField.name + ")", discriminatorField)}
-					</#if>
-
-	if _${discriminatorField.name}Err != nil {
-		return errors.Wrap(_${discriminatorField.name}Err, "Error serializing '${discriminatorField.name}' field")<@emitImport import="github.com/pkg/errors" />
+	if err := <#if typedField.type.isEnumTypeReference()>WriteDiscriminatorEnumField(ctx, "${namedField.name}", "${helper.getLanguageTypeNameForField(field)}", m.Get${discriminatorField.name?cap_first}(), ${helper.getEnumDataWriterCall(typedField.type, namedField.name, "value")}${helper.getFieldOptions(typedField, parserArguments)});<#else>WriteDiscriminatorField(ctx, "${namedField.name}", m.Get${discriminatorField.name?cap_first}(), ${helper.getDataWriterCall(typedField.type, namedField.name)}${helper.getFieldOptions(typedField, parserArguments)});</#if>err != nil{
+		return errors.Wrap(err, "Error serializing '${namedField.name}' field")<@emitImport import="github.com/pkg/errors" />
 	}
-					<#break>
+				<#break>
 				<#case "enum">
 					<#assign enumField = field.asEnumField().orElseThrow()>
 

code-generation/language-go/src/main/resources/templates/go/enum-template.go.ftlh

@@ -219,6 +219,18 @@ func (e ${type.name}) SerializeWithWriteBuffer(ctx context.Context, writeBuffer
 	</#if>
 </#if>
 
+func (e ${type.name}) GetValue() <#if type.type.isPresent()>${helper.getLanguageTypeNameForTypeReference(type.type.orElseThrow())}<#else>string</#if> {
+	return <#if type.type.isPresent()>${helper.getLanguageTypeNameForTypeReference(type.type.orElseThrow())}<#else>string</#if>(e)
+}
+
+<#if type.constantNames?has_content>
+    <#list type.constantNames as constantName>
+func (e ${type.name}) ${type.name}Get${constantName?cap_first}() ${helper.getLanguageTypeNameForTypeReference(type.getConstantType(constantName))}  {
+	return e.${constantName?cap_first}()
+}
+	</#list>
+</#if>
+
 // PLC4XEnumName returns the name that is used in code to identify this enum
 func (e ${type.name}) PLC4XEnumName() string {
 	switch e {