You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@plc4x.apache.org by cd...@apache.org on 2024/02/01 15:51:23 UTC
(plc4x) branch fix/DATE_AND_TIME_2 updated: refactor: Updated the template for generating java data-io classes to match the previous refactoring of the complex-types and enums.
This is an automated email from the ASF dual-hosted git repository.
cdutz pushed a commit to branch fix/DATE_AND_TIME_2
in repository https://gitbox.apache.org/repos/asf/plc4x.git
The following commit(s) were added to refs/heads/fix/DATE_AND_TIME_2 by this push:
new bf7acb06b9 refactor: Updated the template for generating java data-io classes to match the previous refactoring of the complex-types and enums.
bf7acb06b9 is described below
commit bf7acb06b9e0b249c2fe0e48ca0a04bd8587b5c4
Author: Christofer Dutz <cd...@apache.org>
AuthorDate: Thu Feb 1 16:50:54 2024 +0100
refactor: Updated the template for generating java data-io classes to match the previous refactoring of the complex-types and enums.
---
README.md | 2 +-
.../language/java/JavaLanguageTemplateHelper.java | 70 +
.../templates/java/data-io-template.java.ftlh | 924 +-
.../plc4x/java/test/readwrite/DataIOType.java | 77 +-
plc4c/generated-sources/plc4x/src/plc4x_value.c | 3 -
.../s7/include/s7_payload_user_data_item.h | 4 +-
.../s7/src/alarm_message_ack_push_type.c | 12 +-
.../s7/src/alarm_message_push_type.c | 12 +-
.../s7/src/alarm_message_query_type.c | 14 +-
plc4c/generated-sources/s7/src/date_and_time.c | 98 +-
.../s7/src/s7_payload_user_data_item.c | 218 +-
plc4c/generated-sources/s7/src/transport_size.c | 11 +-
.../knxnetip/readwrite/model/KnxProperty.go | 86 +-
.../s7/readwrite/model/AlarmMessageAckPushType.go | 42 +-
.../s7/readwrite/model/AlarmMessagePushType.go | 42 +-
.../s7/readwrite/model/AlarmMessageQueryType.go | 22 +-
plc4go/protocols/s7/readwrite/model/DateAndTime.go | 126 +-
.../readwrite/model/S7PayloadDiagnosticMessage.go | 198 +-
.../model/S7PayloadUserDataItemClkFResponse.go | 104 +-
.../model/S7PayloadUserDataItemClkResponse.go | 104 +-
.../model/S7PayloadUserDataItemClkSetRequest.go | 42 +-
...serDataItemCpuFunctionMsgSubscriptionRequest.go | 102 +-
.../protocols/s7/readwrite/model/TransportSize.go | 4 +-
.../apache/plc4x/java/ads/readwrite/DataItem.java | 577 +-
.../plc4x/java/genericcan/readwrite/DataItem.java | 457 +-
.../plc4x/java/canopen/readwrite/DataItem.java | 369 +-
.../java/knxnetip/readwrite/KnxDatapoint.java | 19103 ++++++-------------
.../plc4x/java/knxnetip/readwrite/KnxProperty.java | 2024 +-
.../plc4x/java/modbus/readwrite/DataItem.java | 1061 +-
.../plc4x/java/plc4x/readwrite/Plc4xValue.java | 467 +-
.../plc4x/java/profinet/readwrite/DataItem.java | 1332 +-
.../plc4x/java/profinet/readwrite/DataItem.java | 1332 +-
.../java/s7/readwrite/AlarmMessageAckPushType.java | 22 +-
.../java/s7/readwrite/AlarmMessagePushType.java | 22 +-
.../java/s7/readwrite/AlarmMessageQueryType.java | 10 +-
.../java/s7/readwrite/AssociatedValueType.java | 6 +-
.../apache/plc4x/java/s7/readwrite/DataItem.java | 812 +-
.../plc4x/java/s7/readwrite/DateAndTime.java | 141 +-
.../s7/readwrite/S7PayloadDiagnosticMessage.java | 174 +-
.../S7PayloadUserDataItemClkFResponse.java | 76 +-
.../S7PayloadUserDataItemClkResponse.java | 76 +-
.../S7PayloadUserDataItemClkSetRequest.java | 30 +-
...rDataItemCpuFunctionMsgSubscriptionRequest.java | 82 +-
.../plc4x/java/s7/readwrite/TransportSize.java | 4 +-
.../apache/plc4x/java/s7/events/S7CyclicEvent.java | 6 +-
.../java/s7/readwrite/utils/StaticHelper.java | 84 +-
.../java/s7/readwrite/ManualS71500DriverTest.java | 6 +-
.../plc4x/java/simulated/readwrite/DataItem.java | 1423 +-
.../org/apache/plc4x/java/spi/values/PlcDATE.java | 5 +
.../org/apache/plc4x/java/spi/values/PlcLDATE.java | 5 +
.../src/test/resources/application-test.properties | 1 +
.../knxnetip/readwrite/model/KnxProperty.cs | 78 +-
.../resources/protocols/knxnetip/knxnetip.mspec | 12 +-
.../main/resources/protocols/plc4x/v0/plc4x.mspec | 2 +-
.../protocols/plc4x/ParserSerializerTestsuite.xml | 2 +-
.../s7/src/main/resources/protocols/s7/s7.mspec | 69 +-
56 files changed, 11613 insertions(+), 20574 deletions(-)
diff --git a/README.md b/README.md
index c65356e194..1242e2bd60 100644
--- a/README.md
+++ b/README.md
@@ -88,7 +88,7 @@ the language of choice.
### Java
-NOTE: Currently the Java version which supports building of all parts of Apache PLC4X is at least Java 11 (Currently with Java 21 the Apache Kafka integration module is excluded from the build as the plugins it requires are incompatible with this version)
+NOTE: Currently the Java version which supports building of all parts of Apache PLC4X is at least Java 19 (We have tested all versions up to Java 21), however it's only the Java Tool UI, that requires this right now. All other modules need at least Java 11.
See the PLC4J user guide on the website to start using PLC4X in your Java application:
[https://plc4x.apache.org/users/getting-started/plc4j.html](https://plc4x.apache.org/users/getting-started/plc4j.html)
diff --git a/code-generation/language-java/src/main/java/org/apache/plc4x/language/java/JavaLanguageTemplateHelper.java b/code-generation/language-java/src/main/java/org/apache/plc4x/language/java/JavaLanguageTemplateHelper.java
index 5256ab9c83..73f575c0a2 100644
--- a/code-generation/language-java/src/main/java/org/apache/plc4x/language/java/JavaLanguageTemplateHelper.java
+++ b/code-generation/language-java/src/main/java/org/apache/plc4x/language/java/JavaLanguageTemplateHelper.java
@@ -168,6 +168,9 @@ public class JavaLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHe
}
public String getPlcValueTypeForTypeReference(TypeReference typeReference) {
+ if(typeReference.isArrayTypeReference() && typeReference.asArrayTypeReference().orElseThrow().getElementTypeReference().isByteBased()) {
+ return "PlcRawByteArray";
+ }
if (!(typeReference instanceof SimpleTypeReference)) {
return "PlcStruct";
}
@@ -588,6 +591,73 @@ public class JavaLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHe
throw new FreemarkerException("Unmapped basetype" + simpleTypeReference.getBaseType());
}
+ public boolean isRawByteArray(DiscriminatedComplexTypeDefinition currentCase) {
+ Optional<Field> valueFieldOptional = currentCase.getFields().stream().filter(field -> field.isNamedField() && field.asNamedField().orElseThrow().getName().equals("value")).findFirst();
+ if(valueFieldOptional.isPresent()) {
+ Field valueField = valueFieldOptional.get();
+ if(valueField.isTypedField()) {
+ TypedField typedField = valueField.asTypedField().orElseThrow();
+ return typedField.getType().isArrayTypeReference() && typedField.getType().asArrayTypeReference().orElseThrow().getElementTypeReference().isByteBased();
+ }
+ }
+ return false;
+ }
+
+ public String getDataIoPropertyValue(PropertyField propertyField) {
+ TypeReference propertyFieldType = propertyField.getType();
+ if(propertyFieldType.isSimpleTypeReference()) {
+ SimpleTypeReference simpleTypeReference = propertyFieldType.asSimpleTypeReference().orElseThrow();
+ switch (propertyField.getName()) {
+ case "value":
+ return "_value.get" + getLanguageTypeNameForTypeReference(simpleTypeReference) + "()";
+ case "year":
+ return "_value.getDate().getYear()";
+ case "month":
+ return "_value.getDate().getMonthValue()";
+ case "day":
+ case "dayOfMonth":
+ return "_value.getDate().getDayOfMonth()";
+ case "dayOfWeek":
+ return "_value.getDate().getDayOfWeek().getValue()";
+ case "hour":
+ return "_value.getTime().getHour()";
+ case "minutes":
+ return "_value.getTime().getMinute()";
+ case "seconds":
+ return "_value.getTime().getSecond()";
+ case "secondsSinceEpoch":
+ return "_value.getDateTime().toEpochSecond(OffsetDateTime.now().getOffset())";
+ case "milliseconds":
+ return "_value.getDuration().toMillis()";
+ case "millisecondsSinceMidnight":
+ if(simpleTypeReference.getSizeInBits() <= 63) {
+ return "_value.getTime().getLong(ChronoField.MILLI_OF_DAY)";
+ } else {
+ return "BigInteger.valueOf(_value.getTime().getLong(ChronoField.MILLI_OF_DAY))";
+ }
+ case "nanoseconds":
+ if(simpleTypeReference.getSizeInBits() <= 63) {
+ return "_value.getDuration().toNanos()";
+ } else {
+ return "BigInteger.valueOf(_value.getDuration().toNanos())";
+ }
+ case "nanosecondsSinceMidnight":
+ if(simpleTypeReference.getSizeInBits() <= 63) {
+ return "_value.getTime().getLong(ChronoField.NANO_OF_DAY)";
+ } else {
+ return "BigInteger.valueOf(_value.getTime().getLong(ChronoField.NANO_OF_DAY))";
+ }
+ case "nanosecondsSinceEpoch":
+ return "BigInteger.valueOf(_value.getDateTime().toEpochSecond(ZoneOffset.of(ZoneId.systemDefault().getId()))).multiply(BigInteger.valueOf(1000000000)).add(BigInteger.valueOf(_value.getDateTime().getNano()))";
+ }
+ if("value".equals(propertyField.getName())) {
+ } else {
+ return "hurz-" + propertyField.getName();
+ }
+ }
+ throw new UnsupportedOperationException("Non Simple types not yet supported.");
+ }
+
public String getReservedValue(ReservedField reservedField) {
final String languageTypeName = getLanguageTypeNameForTypeReference(reservedField.getType(), true);
if ("BigInteger".equals(languageTypeName)) {
diff --git a/code-generation/language-java/src/main/resources/templates/java/data-io-template.java.ftlh b/code-generation/language-java/src/main/resources/templates/java/data-io-template.java.ftlh
index fa472a86d6..d1b0b8b96f 100644
--- a/code-generation/language-java/src/main/resources/templates/java/data-io-template.java.ftlh
+++ b/code-generation/language-java/src/main/resources/templates/java/data-io-template.java.ftlh
@@ -47,18 +47,19 @@ ${helper.packageName(protocolName, languageName, outputFlavor)?replace(".", "/")
package ${helper.packageName(protocolName, languageName, outputFlavor)};
import static org.apache.plc4x.java.spi.generation.StaticHelper.*;
+import static org.apache.plc4x.java.spi.codegen.io.DataReaderFactory.*;
+import static org.apache.plc4x.java.spi.codegen.io.DataWriterFactory.*;
+import static org.apache.plc4x.java.spi.codegen.fields.FieldReaderFactory.*;
+import static org.apache.plc4x.java.spi.codegen.fields.FieldWriterFactory.*;
-import org.apache.plc4x.java.api.model.PlcTag;
-import org.apache.plc4x.java.api.value.*;
-import org.apache.plc4x.java.spi.codegen.WithOption;
-import org.apache.plc4x.java.spi.generation.EvaluationHelper;
-import org.apache.plc4x.java.spi.generation.ParseException;
-import org.apache.plc4x.java.spi.generation.SerializationException;
-import org.apache.plc4x.java.spi.generation.ReadBuffer;
-import org.apache.plc4x.java.spi.generation.WriteBuffer;
-import org.apache.plc4x.java.spi.generation.ByteOrder;
-import ${helper.packageName(protocolName, languageName, outputFlavor)}.*;
+import org.apache.plc4x.java.spi.codegen.*;
+import org.apache.plc4x.java.spi.codegen.io.*;
+import org.apache.plc4x.java.spi.codegen.fields.*;
+import org.apache.plc4x.java.api.exceptions.*;
+import org.apache.plc4x.java.spi.generation.*;
import org.apache.plc4x.java.spi.values.*;
+import org.apache.plc4x.java.api.value.*;
+
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -66,8 +67,10 @@ import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.math.BigInteger;
import java.time.*;
+import java.time.temporal.ChronoField;
import java.util.*;
import java.util.function.Supplier;
+import java.util.stream.Collectors;
// Code generated by code-generation. DO NOT EDIT.
@@ -76,487 +79,652 @@ import java.util.function.Supplier;
public class ${type.name} {
private static final Logger LOGGER = LoggerFactory.getLogger(${type.name}.class);
- public static PlcValue staticParse(ReadBuffer readBuffer<#if type.parserArguments.isPresent()>, <#list type.parserArguments.orElseThrow() as parserArgument>${helper.getLanguageTypeNameForTypeReference(parserArgument.type, false)} ${parserArgument.name}<#sep>, </#sep></#list></#if>) throws ParseException {
+ <#assign hasParserArguments=parserArguments?has_content/>
+ <#assign parserArgumentList><#if hasParserArguments><#list parserArguments as parserArgument>${helper.getLanguageTypeNameForTypeReference(parserArgument.type, false)} ${parserArgument.name}<#sep>, </#sep></#list></#if></#assign>
+ public static PlcValue staticParse(ReadBuffer readBuffer<#if hasParserArguments>, ${parserArgumentList}</#if>) throws ParseException {
<#assign defaultCaseOutput=false>
<#assign dataIoTypeDefinition=type.asDataIoTypeDefinition().orElseThrow()>
<#list dataIoTypeDefinition.switchField.orElseThrow().cases as case>
+ <#--
+ Output the if-expression for this case
+ -->
<@compress single_line=true>
<#if case.discriminatorValueTerms?has_content>
if(
<#list case.discriminatorValueTerms as discriminatorValueTerm>
- <#assign discriminatorExpression=dataIoTypeDefinition.switchField.orElseThrow().discriminatorExpressions[discriminatorValueTerm?index].asLiteral().orElseThrow().asVariableLiteral().orElseThrow()>
- <#assign discriminatorType=helper.getDiscriminatorTypes()[discriminatorExpression.name]>
- EvaluationHelper.equals(
- ${helper.toParseExpression(dataIoTypeDefinition.switchField.orElseThrow(), discriminatorType, discriminatorExpression, parserArguments)},
- <#if discriminatorType.isEnumTypeReference()>
- ${helper.getLanguageTypeNameForTypeReference(discriminatorType)}.${helper.toParseExpression(dataIoTypeDefinition.switchField.orElseThrow(), discriminatorType, discriminatorValueTerm, parserArguments)}
+ <#if helper.isWildcard(discriminatorValueTerm)>
+ true
<#else>
- ${helper.toParseExpression(dataIoTypeDefinition.switchField.orElseThrow(), discriminatorType, discriminatorValueTerm, parserArguments)}
+ <#assign switchField=dataIoTypeDefinition.switchField.orElseThrow()>
+ <#assign discriminatorExpression=switchField.discriminatorExpressions[discriminatorValueTerm?index].asLiteral().orElseThrow().asVariableLiteral().orElseThrow()>
+ <#assign discriminatorType=helper.getDiscriminatorTypes()[discriminatorExpression.discriminatorName]>
+ EvaluationHelper.equals(
+ ${helper.toParseExpression(switchField, discriminatorType, discriminatorExpression, parserArguments)},
+ <#if discriminatorType.isEnumTypeReference()>
+ ${helper.getLanguageTypeNameForTypeReference(discriminatorType)}.${helper.toParseExpression(switchField, discriminatorType, discriminatorValueTerm, parserArguments)}
+ <#else>
+ (${helper.getLanguageTypeNameForTypeReference(discriminatorType, true)}) ${helper.toParseExpression(switchField, discriminatorType, discriminatorValueTerm, parserArguments)}
+ </#if>
+ )
</#if>
- )
<#sep> && </#sep>
</#list>
)
<#else>
<#assign defaultCaseOutput=true>
- </#if>
- </...@compress> { // ${case.name}
+ </#if>{ // ${case.name}
+ </...@compress>
+ <#--
+ Output the body of this case
+ -->
+ <#assign reservedFieldIndex=0>
<#assign valueDefined=false>
<#list case.fields as field>
+ <#if field.isNamedField()>
+ <#assign namedField = field.asNamedField().orElseThrow()>
+ <#if namedField.name == "value">
+ <#assign valueDefined=true>
+ </#if>
+ </#if>
<#switch field.typeName>
<#case "array">
<#assign arrayField = field.asArrayField().orElseThrow()>
- <#assign elementTypeReference=arrayField.type.elementTypeReference>
- // Array field (${arrayField.name})
- <#-- Only update curPos if the length expression uses it -->
- <#if arrayField.loopExpression.contains("curPos")>
- curPos = readBuffer.getPos() - startPos;
- </#if>
- <#-- If this is a count array, we can directly initialize an array with the given size -->
- <#if field.isCountArrayField()>
- // Count array
- if(${helper.toParseExpression(arrayField, helper.intTypeReference, arrayField.loopExpression,parserArguments)} > Integer.MAX_VALUE) {
- throw new ParseException("Array count of " + (${helper.toParseExpression(arrayField, helper.intTypeReference, arrayField.loopExpression,parserArguments)}) + " exceeds the maximum allowed count of " + Integer.MAX_VALUE);
- }
- List<PlcValue> ${arrayField.name};
- {
- int itemCount = (int) ${helper.toParseExpression(arrayField, helper.intTypeReference, arrayField.loopExpression,parserArguments)};
- ${arrayField.name} = new LinkedList<>();
- for(int curItem = 0; curItem < itemCount; curItem++) {
- ${arrayField.name}.add(new ${helper.getPlcValueTypeForTypeReference(elementTypeReference)}((${helper.getLanguageTypeNameForTypeReference(elementTypeReference, false)}) <#if elementTypeReference.isSimpleTypeReference()>${helper.getReadBufferReadMethodCall(elementTypeReference.asSimpleTypeReference().orElseThrow(), "", arrayField)})<#else>${elementTypeReference.asComplexTypeReference().orElseThrow().name}IO.staticParse(readBuffer<#if elementTypeReference.params.isPresen [...]
- }
- }
- <#-- In all other cases do we have to work with a list, that is later converted to an array -->
+ <#assign typedField = field.asTypedField().orElseThrow()>
+ <#assign namedField = field.asNamedField().orElseThrow()>
+ <#assign arrayElementTypeReference = arrayField.type.asArrayTypeReference().orElseThrow().getElementTypeReference()>
+
+ <#if arrayElementTypeReference.isByteBased()>
+ <#if !field.isCountArrayField() && !field.isLengthArrayField()>
+ throw new ParseException("array fields of type byte only support 'count' and 'length' loop-types.");
+ </#if>
+ byte[] ${namedField.name} = readBuffer.readByteArray("${namedField.name}", Math.toIntExact(${helper.toParseExpression(arrayField, helper.intTypeReference, arrayField.loopExpression, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)});
<#else>
- <#-- For a length array, we read data till the read position of the buffer reaches a given position -->
- <#if arrayField.isLengthArrayField()>
- // Length array
- long _${arrayField.name}Length = ${helper.toParseExpression(arrayField, helper.intTypeReference, arrayField.loopExpression,parserArguments)};
- long ${arrayField.name}EndPos = readBuffer.getPos() + _${arrayField.name}Length;
- List<PlcValue> value = new LinkedList<>();
- while(readBuffer.getPos() < ${arrayField.name}EndPos) {
- value.add(
- <#if elementTypeReference.isSimpleTypeReference()>
- new ${helper.getPlcValueTypeForTypeReference(elementTypeReference)}(${helper.getReadBufferReadMethodCall(elementTypeReference.asSimpleTypeReference().orElseThrow(), "", arrayField)})
- <#else>${elementTypeReference.asNonSimpleTypeReference().orElseThrow().name}IO.staticParse(readBuffer
- <#if elementTypeReference.params.isPresent()>,
- <#list elementTypeReference.params.orElseThrow() as parserArgument>
- (${helper.getLanguageTypeNameForTypeReference(helper.getArgumentType(elementTypeReference, parserArgument?index), true)}) (${helper.toParseExpression(arrayField, elementTypeReference, parserArgument,parserArguments)})
- <#sep>, </#sep>
- </#list>
- </#if>
- )
- </#if>
- );
- }
- <#-- A terminated array keeps on reading data as long as the termination expression evaluates to false -->
- <#elseif arrayField.isTerminatedArrayField()>
- // Terminated array
- ${helper.getNonPrimitiveLanguageTypeNameForField(arrayField)} ${arrayField.name} = new LinkedList<>();
- while(!((boolean) (${helper.toParseExpression(arrayField, helper.boolTypeReference, arrayField.loopExpression,parserArguments)}))) {
- ${arrayField.name}.add(<#if elementTypeReference.isSimpleTypeReference()>${helper.getReadBufferReadMethodCall(elementTypeReference.asSimpleTypeReference().orElseThrow(), "", arrayField)}<#else>${elementTypeReference.asComplexTypeReference().orElseThrow().name}IO.staticParse(readBuffer<#if arrayField.params.isPresent()>, <#list arrayField.params.orElseThrow() as parserArgument>(${helper.getLanguageTypeNameForTypeReference(helper.getArgumentType(elementTypeReference, parser [...]
-
- <#-- After parsing, update the current position, but only if it's needed -->
- <#if arrayField.loopExpression.contains("curPos")>
- curPos = readBuffer.getPos() - startPos;
+ <#-- If this is a count array, we can directly initialize an array with the given size -->
+ <#if field.isCountArrayField()>
+ ${helper.getNonPrimitiveLanguageTypeNameForField(arrayField)} _${arrayField.name} = readCountArrayField("${arrayField.name}", ${helper.getDataReaderCall(arrayField.type)}, ${helper.toParseExpression(arrayField, helper.intTypeReference, arrayField.loopExpression, parserArguments)}${helper.getFieldOptions(typedField, parserArguments)});
+ List<PlcValue> value = new ArrayList<>(_value.size());
+ for (${helper.getLanguageTypeNameForTypeReference(arrayElementTypeReference, true)} _item : _value) {
+ value.add(new ${helper.getPlcValueTypeForTypeReference(arrayElementTypeReference)}(_item));
+ }
+ <#-- In all other cases do we have to work with a list, that is later converted to an array -->
+ <#else>
+ <#-- For a length array, we read data till the read position of the buffer reaches a given position -->
+ <#if field.isLengthArrayField()>
+ ${helper.getNonPrimitiveLanguageTypeNameForField(arrayField)} ${arrayField.name} = readLengthArrayField("${arrayField.name}", ${helper.getDataReaderCall(arrayField.type)}, ${helper.toParseExpression(arrayField, helper.intTypeReference, arrayField.loopExpression, parserArguments)}${helper.getFieldOptions(typedField, parserArguments)});
+ <#-- A terminated array keeps on reading data as long as the termination expression evaluates to false -->
+ <#elseif field.isTerminatedArrayField()>
+ ${helper.getNonPrimitiveLanguageTypeNameForField(arrayField)} ${arrayField.name} = readTerminatedArrayField("${arrayField.name}", ${helper.getDataReaderCall(arrayField.type)}, () -> ((boolean) (${helper.toParseExpression(arrayField, helper.intTypeReference, arrayField.loopExpression, parserArguments)}))${helper.getFieldOptions(typedField, parserArguments)});
</#if>
- }
</#if>
</#if>
- <#if arrayField.name == "value">
- <#assign valueDefined=true>
- </#if>
- <#break>
+ <#break>
+ <#case "assert">
+ <#assign assertField = field.asAssertField().orElseThrow()>
+ <#assign typedField = field.asTypedField().orElseThrow()>
+ <#assign namedField = field.asNamedField().orElseThrow()>
+
+ ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}, (${helper.getLanguageTypeNameForField(field)}) (${helper.toParseExpression(assertField, assertField.type, assertField.conditionExpression, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)});
+ <#break>
+ <#case "checksum">
+ <#assign checksumField = field.asChecksumField().orElseThrow()>
+ <#assign typedField = field.asTypedField().orElseThrow()>
+ <#assign namedField = field.asNamedField().orElseThrow()>
+
+ ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}, (${helper.getLanguageTypeNameForField(field)}) (${helper.toParseExpression(checksumField, checksumField.type, checksumField.checksumExpression, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)});
+ <#break>
<#case "const">
- <#assign constField=field.asConstField().orElseThrow()>
-
- // Const Field (${constField.name})
- ${helper.getNonPrimitiveLanguageTypeNameForField(constField)} ${constField.name} = ${helper.getReadBufferReadMethodCall(constField.type.asSimpleTypeReference().orElseThrow(), "", constField)};
- if(${constField.name} != ${dataIoTypeDefinition.name}.${constField.name?upper_case}) {
- throw new ParseException("Expected constant value " + ${dataIoTypeDefinition.name}.${constField.name?upper_case} + " but got " + ${constField.name});
- }
- <#if constField.name == "value">
- <#assign valueDefined=true>
- </#if>
- <#break>
+ <#assign constField = field.asConstField().orElseThrow()>
+ <#assign typedField = field.asTypedField().orElseThrow()>
+ <#assign namedField = field.asNamedField().orElseThrow()>
+
+ ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}, ${type.name}.${namedField.name?upper_case}${helper.getFieldOptions(typedField, parserArguments)});
+ <#break>
+ <#case "discriminator">
+ <#assign discriminatorField = field.asDiscriminatorField().orElseThrow()>
+ <#assign typedField = field.asTypedField().orElseThrow()>
+ <#assign namedField = field.asNamedField().orElseThrow()>
+
+ ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}${helper.getFieldOptions(typedField, parserArguments)});
+ <#break>
<#case "enum">
- <#assign enumField=field.asEnumField().orElseThrow()>
+ <#assign enumField = field.asEnumField().orElseThrow()>
+ <#assign typedField = field.asTypedField().orElseThrow()>
+ <#assign namedField = field.asNamedField().orElseThrow()>
+
+ ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = read${field.typeName?cap_first}Field("${namedField.name}", "${enumField.type.asNonSimpleTypeReference().orElseThrow().typeDefinition.name}", readEnum(${enumField.type.asNonSimpleTypeReference().orElseThrow().typeDefinition.name}::firstEnumForField${enumField.fieldName?cap_first}, ${helper.getDataReaderCall(helper.getEnumFieldTypeReference(enumField.type, enumField.fieldName))})${helper.getFieldOptio [...]
+ <#break>
+ <#case "implicit">
+ <#assign implicitField = field.asImplicitField().orElseThrow()>
+ <#assign typedField = field.asTypedField().orElseThrow()>
+ <#assign namedField = field.asNamedField().orElseThrow()>
+
+ ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}${helper.getFieldOptions(typedField, parserArguments)});
+ <#break>
+ <#case "manualArray">
+ <#assign manualArrayField = field.asManualArrayField().orElseThrow()>
+ <#assign typedField = field.asTypedField().orElseThrow()>
+ <#assign namedField = field.asNamedField().orElseThrow()>
+ <#assign arrayElementTypeReference = manualArrayField.type.asArrayTypeReference().orElseThrow().getElementTypeReference()>
- // Enum field (${enumField.name})
- ${helper.getNonPrimitiveLanguageTypeNameForField(enumField)} ${enumField.name} = ${helper.getNonPrimitiveLanguageTypeNameForField(enumField)}.enumForValue(${helper.getReadBufferReadMethodCall(helper.getEnumBaseTypeReference(enumField.type.asSimpleTypeReference().orElseThrow()), "", enumField)});
- <#if enumField.name == "value">
- <#assign valueDefined=true>
+ <#if arrayElementTypeReference.isByteBased()>
+ byte[] ${namedField.name} = readManualByteArrayField("${namedField.name}", readBuffer, (byte[] _values) -> (boolean) (${helper.toParseExpression(manualArrayField, helper.boolTypeReference, manualArrayField.loopExpression, parserArguments)}), () -> (byte) (${helper.toParseExpression(manualArrayField, manualArrayField.type, manualArrayField.parseExpression, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)});
+ <#else>
+ ${helper.getNonPrimitiveLanguageTypeNameForField(manualArrayField)} ${namedField.name} = readManualArrayField("${namedField.name}", readBuffer, (${helper.getNonPrimitiveLanguageTypeNameForField(manualArrayField)} _values) -> (boolean) (${helper.toParseExpression(manualArrayField, helper.boolTypeReference, manualArrayField.loopExpression, parserArguments)}), () -> (${helper.getLanguageTypeNameForTypeReference(manualArrayField.type.elementTypeReference)}) (${hel [...]
</#if>
- <#break>
+ <#break>
<#case "manual">
- <#assign manualField=field.asManualField().orElseThrow()>
+ <#assign manualField = field.asManualField().orElseThrow()>
+ <#assign typedField = field.asTypedField().orElseThrow()>
+ <#assign namedField = field.asNamedField().orElseThrow()>
- // Manual Field (${manualField.name})
- ${helper.getLanguageTypeNameForField(field)} ${manualField.name} = (${helper.getLanguageTypeNameForField(manualField)}) (${helper.toParseExpression(manualField, manualField.type, manualField.parseExpression,parserArguments)});
- <#if manualField.name == "value">
- <#assign valueDefined=true>
- </#if>
- <#break>
+ ${helper.getLanguageTypeNameForField(field)} ${manualField.name} = readManualField("${namedField.name}", readBuffer, () -> (${helper.getLanguageTypeNameForField(manualField)}) (${helper.toParseExpression(manualField, manualField.type, manualField.parseExpression, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)});
+ <#break>
+ <#case "optional">
+ <#assign optionalField = field.asOptionalField().orElseThrow()>
+ <#assign typedField = field.asTypedField().orElseThrow()>
+ <#assign namedField = field.asNamedField().orElseThrow()>
+
+ ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}<#if optionalField.conditionExpression.present>, ${helper.toParseExpression(optionalField, helper.boolTypeReference, optionalField.conditionExpression.get(), parserArguments)}</#if>${helper.getFieldOptions(typedField, parserArguments)});
+ <#break>
+ <#case "padding">
+ <#assign paddingField = field.asPaddingField().orElseThrow()>
+ <#assign typedField = field.asTypedField().orElseThrow()>
+ <#assign simpleTypeReference = paddingField.type.asSimpleTypeReference().orElseThrow()>
+
+ read${field.typeName?cap_first}Field(${helper.getDataReaderCall(typedField.type)}, (int) (${helper.toParseExpression(paddingField, paddingField.type, paddingField.paddingCondition, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)});
+ <#break>
<#case "reserved">
- <#assign reservedField=field.asReservedField().orElseThrow()>
-
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- ${helper.getLanguageTypeNameForField(field)} reserved = ${helper.getReadBufferReadMethodCall(reservedField.type.asSimpleTypeReference().orElseThrow(), "", reservedField)};
- if(reserved != ${helper.getReservedValue(reservedField)}) {
- LOGGER.info("Expected constant value " + ${reservedField.referenceValue} + " but got " + reserved + " for reserved field.");
- }
- }
- <#break>
+ <#assign reservedField = field.asReservedField().orElseThrow()>
+ <#assign typedField = field.asTypedField().orElseThrow()>
+
+ ${helper.getLanguageTypeNameForTypeReference(reservedField.type, false)} reservedField${reservedFieldIndex}<#assign reservedFieldIndex=reservedFieldIndex+1> = read${field.typeName?cap_first}Field("reserved", ${helper.getDataReaderCall(typedField.type)}, ${helper.getReservedValue(reservedField)}${helper.getFieldOptions(typedField, parserArguments)});
+ <#break>
<#case "simple">
- <#assign simpleField=field.asSimpleField().orElseThrow()>
+ <#assign simpleField = field.asSimpleField().orElseThrow()>
+ <#assign typedField = field.asTypedField().orElseThrow()>
+ <#assign namedField = field.asNamedField().orElseThrow()>
- <#if helper.isEnumField(simpleField)>
- // Enum field (${simpleField.name})
- ${helper.getNonPrimitiveLanguageTypeNameForField(simpleField)} ${simpleField.name} = ${helper.getNonPrimitiveLanguageTypeNameForField(simpleField)}.enumForValue(${helper.getReadBufferReadMethodCall(helper.getEnumBaseTypeReference(simpleField.type), "", simpleField)});
- <#else>
- // Simple Field (${simpleField.name})
- ${helper.getNonPrimitiveLanguageTypeNameForField(simpleField)} ${simpleField.name} = <#if simpleField.type.isSimpleTypeReference()>${helper.getReadBufferReadMethodCall(simpleField.type.asSimpleTypeReference().orElseThrow(), "", simpleField)}<#else>${simpleField.type.asComplexTypeReference().orElseThrow().name}IO.staticParse(readBuffer<#if simpleField.params.isPresent()>, <#list field.params.orElseThrow() as parserArgument>(${helper.getLanguageTypeNameForTypeReference(helper.g [...]
- </#if>
- <#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"))) ||
- ((case.name == "DATE_AND_TIME") && (simpleField.name == "secondsSinceEpoch")) ||
- ((case.name == "DATE") && ((simpleField.name == "year") || (simpleField.name == "month") || (simpleField.name == "day"))) ||
- ((case.name == "TIME_OF_DAY") && ((simpleField.name == "hour") || (simpleField.name == "minutes") || (simpleField.name == "seconds"))) ||
- simpleField.name == "value">
- <#assign valueDefined=true>
- </#if>
- <#break>
- </#switch>
- </#list>
- <#if case.name == "Struct">
+ ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = <#if typedField.type.isEnumTypeReference()>readEnumField("${namedField.name}", "${helper.getLanguageTypeNameForField(field)}", ${helper.getDataReaderCall(typedField.type)}${helper.getFieldOptions(typedField, parserArguments)});<#else>read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}${helper.getFieldOptions(typedField, parserArguments)});</#if>
+ <#break>
+ <#case "unknown">
+ <#assign unknownField = field.asUnknownField().orElseThrow()>
+ <#assign typedField = field.asTypedField().orElseThrow()>
- <#-- In this case we need to wrap each field in a PlcValue that matches it's natural type -->
- Map<String, PlcValue> _map = new HashMap<>();
- <#list case.fields as field>
- <#if field.isArrayField()>
- <#assign field=field.asArrayField().orElseThrow()>
- _map.put("${field.name}", new PlcList(${field.name}));
- <#elseif field.isPropertyField()>
- <#assign field=field.asPropertyField().orElseThrow()>
- <#switch helper.getLanguageTypeNameForTypeReference(field.type)>
- <#case "Boolean">
- _map.put("${field.name}", new PlcBOOL(${field.name}));
- <#break>
- <#case "Byte">
- _map.put("${field.name}", new PlcSINT(${field.name}));
- <#break>
- <#case "Short">
- _map.put("${field.name}", new PlcINT(${field.name}));
- <#break>
- <#case "Integer">
- _map.put("${field.name}", new PlcDINT(${field.name}));
- <#break>
- <#case "Long">
- _map.put("${field.name}", new PlcLINT(${field.name}));
- <#break>
- <#case "BigInteger">
- _map.put("${field.name}", new PlcBigInteger(${field.name}));
- <#break>
- <#case "Float">
- _map.put("${field.name}", new PlcREAL(${field.name}));
- <#break>
- <#case "Double">
- _map.put("${field.name}", new PlcLREAL(${field.name}));
- <#break>
- <#case "BigDecimal">
- _map.put("${field.name}", new PlcBigDecimal(${field.name}));
- <#break>
- <#case "String">
- _map.put("${field.name}", new PlcSTRING(${field.name}));
- <#break>
- <#case "LocalTime">
- _map.put("${field.name}", new PlcTIME_OF_DAY(${field.name}));
- <#break>
- <#case "LocalDate">
- _map.put("${field.name}", new PlcDATE(${field.name}));
- <#break>
- <#case "LocalDateTime">
- _map.put("${field.name}", new PlcDATE_AND_TIME(${field.name}));
- <#break>
- </#switch>
- </#if>
- </#list>
- <#assign valueDefined=true>
- </#if>
+ read${field.typeName?cap_first}Field("unknown", ${helper.getDataReaderCall(typedField.type)}${helper.getFieldOptions(typedField, parserArguments)});
+ <#break>
+ <#case "virtual">
+ <#assign virtualField = field.asVirtualField().orElseThrow()>
+ <#assign typedField = field.asTypedField().orElseThrow()>
+ <#assign namedField = field.asNamedField().orElseThrow()>
+ ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getLanguageTypeNameForField(field)}.class, ${helper.toParseExpression(virtualField, virtualField.type, virtualField.valueExpression, parserArguments)}${helper.getFieldOptions(typedField, parserArguments)});
+ <#break>
+ <#case "validation">
+ <#assign validationField = field.asValidationField().orElseThrow()>
+ // Validation
+ if (!(${helper.toParseExpression(validationField, helper.boolTypeReference, validationField.getValidationExpression(), null)})) {
+ <#assign errorType="ParseValidationException">
+ <#if !validationField.shouldFail()><#assign errorType="ParseAssertException"></#if>
+ throw new ${errorType}(${validationField.getDescription().orElse("\"Validation failed\"")});
+ }
+ <#break>
+ <#case "peek">
+ <#assign peekField = field.asPeekField().orElseThrow()>
+ <#assign typedField = field.asTypedField().orElseThrow()>
+ <#assign namedField = field.asNamedField().orElseThrow()>
+ ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}<#if peekField.offsetExpression.present>, ${helper.toParseExpression(peekField, helper.boolTypeReference, peekField.offsetExpression.get(), parserArguments)}</#if>${helper.getFieldOptions(typedField, parserArguments)});
+ <#break>
+ </#switch>
+ </#list>
<#switch case.name>
<#case "TIME">
<#if helper.hasFieldsWithNames(case.fields, "milliseconds")>
- return PlcTIME.ofMilliseconds(milliseconds);
+ return PlcTIME.ofMilliseconds(milliseconds);
</#if>
<#break>
<#case "LTIME">
<#if helper.hasFieldsWithNames(case.fields, "nanoseconds")>
- return PlcLTIME.ofNanoseconds(nanoseconds);
+ return PlcLTIME.ofNanoseconds(nanoseconds);
</#if>
<#break>
<#case "DATE">
<#if helper.hasFieldsWithNames(case.fields, "secondsSinceEpoch")>
- return PlcDATE.ofSecondsSinceEpoch(secondsSinceEpoch);
+ return PlcDATE.ofSecondsSinceEpoch(secondsSinceEpoch);
<#elseif helper.hasFieldsWithNames(case.fields, "daysSinceEpoch")>
- return PlcDATE.ofDaysSinceEpoch(daysSinceEpoch);
+ return PlcDATE.ofDaysSinceEpoch(daysSinceEpoch);
<#elseif helper.hasFieldsWithNames(case.fields, "daysSinceSiemensEpoch")>
- return PlcDATE.ofDaysSinceSiemensEpoch(daysSinceSiemensEpoch);
+ return PlcDATE.ofDaysSinceSiemensEpoch(daysSinceSiemensEpoch);
</#if>
<#break>
<#case "LDATE">
<#if helper.hasFieldsWithNames(case.fields, "nanosecondsSinceEpoch")>
- return PlcLDATE.ofNanosecondsSinceEpoch(nanosecondsSinceEpoch);
+ return PlcLDATE.ofNanosecondsSinceEpoch(nanosecondsSinceEpoch);
</#if>
<#break>
<#case "TIME_OF_DAY">
<#if helper.hasFieldsWithNames(case.fields, "millisecondsSinceMidnight")>
- return PlcTIME_OF_DAY.ofMillisecondsSinceMidnight(millisecondsSinceMidnight);
+ return PlcTIME_OF_DAY.ofMillisecondsSinceMidnight(millisecondsSinceMidnight);
</#if>
<#break>
<#case "LTIME_OF_DAY">
<#if helper.hasFieldsWithNames(case.fields, "nanosecondsSinceMidnight")>
- return PlcLTIME_OF_DAY.ofNanosecondsSinceMidnight(nanosecondsSinceMidnight);
+ return PlcLTIME_OF_DAY.ofNanosecondsSinceMidnight(nanosecondsSinceMidnight);
</#if>
<#break>
<#case "DATE_AND_TIME">
- <#if helper.hasFieldsWithNames(case.fields, "year", "month", "day", "hour", "minutes", "seconds", "nanoseconds")>
- return PlcDATE_AND_TIME.ofSegments(year.intValue(), (month == 0) ? 1 : month.intValue(), (day == 0) ? 1 : day.intValue(), hour.intValue(), minutes.intValue(), seconds.intValue(), nanoseconds.intValue());
+ <#if helper.hasFieldsWithNames(case.fields, "year", "month", "day", "hour", "minutes", "seconds", "milliseconds")>
+ return PlcDATE_AND_TIME.ofSegments(year, (month == 0) ? 1 : month, (day == 0) ? 1 : day, hour, minutes, seconds, milliseconds);
<#elseif helper.hasFieldsWithNames(case.fields, "secondsSinceEpoch")>
- return PlcDATE_AND_TIME.ofSecondsSinceEpoch(secondsSinceEpoch);
+ return PlcDATE_AND_TIME.ofSecondsSinceEpoch(secondsSinceEpoch);
</#if>
<#break>
<#case "LDATE_AND_TIME">
<#if helper.hasFieldsWithNames(case.fields, "nanosecondsSinceEpoch")>
- return PlcLDATE_AND_TIME.ofNanosecondsSinceEpoch(nanosecondsSinceEpoch);
+ return PlcLDATE_AND_TIME.ofNanosecondsSinceEpoch(nanosecondsSinceEpoch);
</#if>
<#break>
<#case "Struct">
- return new PlcStruct(_map);
+
+ Map<String, PlcValue> _map = new HashMap<>();
+ <#list case.fields as field>
+ <#if field.isNamedField()>
+ <#assign namedField=field.asNamedField().orElseThrow()>
+ <#assign typedField=field.asTypedField().orElseThrow()>
+ _map.put("${namedField.name}", new ${helper.getPlcValueTypeForTypeReference(typedField.type)}(${namedField.name}));
+ </#if>
+ </#list>
+ return new PlcStruct(_map);
<#break>
<#case "List">
- return new PlcList(value);
+ <#if helper.isRawByteArray(case)>
+ return new PlcRawByteArray(value);
+ <#else>
+ return new PlcList(value);
+ </#if>
<#break>
<#default>
- return new Plc${case.name}(value);
+ return new Plc${case.name}(value);
</#switch>
- }<#sep> else </#sep></#list>
+ }<#sep> else </#sep>
+ </#list>
<#if !defaultCaseOutput>
- return null;
+ return null;
</#if>
}
-<#if outputFlavor != "passive">
- public static void staticSerialize(WriteBuffer writeBuffer, PlcValue _value<#if type.parserArguments.isPresent()>, <#list type.parserArguments.orElseThrow() as parserArgument>${helper.getLanguageTypeNameForTypeReference(parserArgument.type, false)} ${parserArgument.name}<#sep>, </#sep></#list></#if>) throws SerializationException {
- staticSerialize(writeBuffer, _value<#if type.parserArguments.isPresent()>, <#list type.parserArguments.orElseThrow() as parserArgument>${parserArgument.name}<#sep>, </#sep></#list></#if>, ByteOrder.BIG_ENDIAN);
+ public static int getLengthInBytes(PlcValue _value<#if type.parserArguments.isPresent()>, <#list type.parserArguments.orElseThrow() as parserArgument>${helper.getLanguageTypeNameForTypeReference(parserArgument.type, false)} ${parserArgument.name}<#sep>, </#sep></#list></#if>) {
+ return (int) Math.ceil((float) getLengthInBits(_value<#if type.parserArguments.isPresent()>, <#list type.parserArguments.orElseThrow() as parserArgument>${parserArgument.name}<#sep>, </#sep></#list></#if>) / 8.0);
}
- public static void staticSerialize(WriteBuffer writeBuffer, PlcValue _value<#if type.parserArguments.isPresent()>, <#list type.parserArguments.orElseThrow() as parserArgument>${helper.getLanguageTypeNameForTypeReference(parserArgument.type, false)} ${parserArgument.name}<#sep>, </#sep></#list></#if>, ByteOrder byteOrder) throws SerializationException {
- <#assign defaultCaseOutput=false>
+ public static int getLengthInBits(PlcValue _value<#if type.parserArguments.isPresent()>, <#list type.parserArguments.orElseThrow() as parserArgument>${helper.getLanguageTypeNameForTypeReference(parserArgument.type, false)} ${parserArgument.name}<#sep>, </#sep></#list></#if>) {
+ int lengthInBits = 0;
<#assign dataIoTypeDefinition=type.asDataIoTypeDefinition().orElseThrow()>
<#list dataIoTypeDefinition.switchField.orElseThrow().cases as case>
- <@compress single_line=true>
- <#if case.discriminatorValueTerms?has_content>
- if(
- <#list case.discriminatorValueTerms as discriminatorValueTerm>
- <#assign discriminatorExpression=dataIoTypeDefinition.switchField.orElseThrow().discriminatorExpressions[discriminatorValueTerm?index].asLiteral().orElseThrow().asVariableLiteral().orElseThrow()>
- <#assign discriminatorType=helper.getDiscriminatorTypes()[discriminatorExpression.name]>
- EvaluationHelper.equals(
- ${helper.toParseExpression(dataIoTypeDefinition.switchField.orElseThrow(), discriminatorType, discriminatorExpression, parserArguments)},
- <#if discriminatorType.isEnumTypeReference()>
- ${helper.getLanguageTypeNameForTypeReference(discriminatorType)}.${helper.toParseExpression(dataIoTypeDefinition.switchField.orElseThrow(), discriminatorType, discriminatorValueTerm, parserArguments)}
- <#else>
- ${helper.toParseExpression(dataIoTypeDefinition.switchField.orElseThrow(), discriminatorType, discriminatorValueTerm, parserArguments)}
- </#if>
+ <#--
+ Output the if-expression for this case
+ -->
+ <@compress single_line=true>
+ <#if case.discriminatorValueTerms?has_content>
+ if(
+ <#list case.discriminatorValueTerms as discriminatorValueTerm>
+ <#if helper.isWildcard(discriminatorValueTerm)>
+ true
+ <#else>
+ <#assign switchField=dataIoTypeDefinition.switchField.orElseThrow()>
+ <#assign discriminatorExpression=switchField.discriminatorExpressions[discriminatorValueTerm?index].asLiteral().orElseThrow().asVariableLiteral().orElseThrow()>
+ <#assign discriminatorType=helper.getDiscriminatorTypes()[discriminatorExpression.discriminatorName]>
+ EvaluationHelper.equals(
+ ${helper.toParseExpression(switchField, discriminatorType, discriminatorExpression, parserArguments)},
+ <#if discriminatorType.isEnumTypeReference()>
+ ${helper.getLanguageTypeNameForTypeReference(discriminatorType)}.${helper.toParseExpression(switchField, discriminatorType, discriminatorValueTerm, parserArguments)}
+ <#else>
+ (${helper.getLanguageTypeNameForTypeReference(discriminatorType, true)}) ${helper.toParseExpression(switchField, discriminatorType, discriminatorValueTerm, parserArguments)}
+ </#if>
+ )
+ </#if>
+ <#sep> && </#sep>
+ </#list>
)
- <#sep> && </#sep>
- </#list>
- )
- <#else>
- <#assign defaultCaseOutput=true>
- </#if>
- </...@compress> { // ${case.name}
+ </#if>{ // ${case.name}
+ </...@compress>
+ <#--
+ Calculate the size of the current type.
+ -->
<#list case.fields as field>
<#switch field.typeName>
<#case "array">
- <#assign arrayField=field.asArrayField().orElseThrow()>
- <#assign elementTypeReference=arrayField.type.elementTypeReference>
- PlcList values = (PlcList) _value;
-
- <#if case.name == "Struct">
- for (PlcValue val : ((List<PlcValue>) values.getStruct().get("${arrayField.name}").getList())) {
- <#if elementTypeReference.isByteBased()>
- ${helper.getLanguageTypeNameForField(arrayField)} value = (${helper.getLanguageTypeNameForField(arrayField)}) val.getRaw();
- writeBuffer.writeByteArray("", value);
- <#else>
- ${helper.getLanguageTypeNameForField(arrayField)} value = (${helper.getLanguageTypeNameForField(arrayField)}) val.get${helper.getLanguageTypeNameForField(arrayField)?cap_first}();
- ${helper.getWriteBufferWriteMethodCall(elementTypeReference.asSimpleTypeReference().orElseThrow(), "value", arrayField)};
- </#if>
- }
+ <#assign arrayField = field.asArrayField().orElseThrow()>
+ <#assign arrayElementTypeReference = arrayField.type.asArrayTypeReference().orElseThrow().getElementTypeReference()>
+
+ // Array field
+ if(_value != null) {
+ <#if arrayElementTypeReference.isSimpleTypeReference()>
+ <#assign simpleTypeReference = arrayElementTypeReference.asSimpleTypeReference().orElseThrow()>
+ lengthInBits += ${simpleTypeReference.sizeInBits} * _value.<#if arrayElementTypeReference.isByteBased()>getRaw().length<#else>getList().size()</#if>;
+ <#elseif arrayField.isCountArrayField()>
+ int i=0;
+ <#assign nonSimpleTypeReference = arrayElementTypeReference.asNonSimpleTypeReference().orElseThrow()>
+ for(${nonSimpleTypeReference.name} element : ${arrayField.name}) {
+ ThreadLocalHelper.lastItemThreadLocal.set(++i >= ${arrayField.name}.size());
+ lengthInBits += element.getLengthInBits();
+ }
<#else>
- for (PlcValue val : ((List<PlcValue>) values.getList())) {
- <#if elementTypeReference.isByteBased()>
- byte[] value = (byte[]) val.getRaw();
- writeBuffer.writeByteArray("", value);
- <#else>
- ${helper.getLanguageTypeNameForTypeReference(elementTypeReference)} value = (${helper.getLanguageTypeNameForTypeReference(elementTypeReference)}) val.get${helper.getLanguageTypeNameForTypeReference(elementTypeReference)?cap_first}();
- ${helper.getWriteBufferWriteMethodCall(elementTypeReference.asSimpleTypeReference().orElseThrow(), "(" + arrayField.name + ")", arrayField)};
- </#if>
- }
+ for(Message element : ${arrayField.name}) {
+ lengthInBits += element.getLengthInBits();
+ }
</#if>
+ }
+ <#break>
+ <#case "checksum">
+ <#assign checksumField = field.asChecksumField().orElseThrow()>
+ <#assign typedField = field.asTypedField().orElseThrow()>
+ <#assign simpleTypeReference = typedField.type.asSimpleTypeReference().orElseThrow()>
- <#if case.name == "BOOL">
- while (writeBuffer.getPos() < writeBuffer.getData().length) {
- writeBuffer.writeBit(false);
- }
- </#if>
+ // Checksum Field (checksum)
+ lengthInBits += ${simpleTypeReference.sizeInBits};
<#break>
<#case "const">
- <#assign constField=field.asConstField().orElseThrow()>
- // Const Field (${constField.name})
- ${helper.getWriteBufferWriteMethodCall(constField.type.asSimpleTypeReference().orElseThrow(), constField.referenceValue, constField)};
+ <#assign constField = field.asConstField().orElseThrow()>
+ <#assign typedField = field.asTypedField().orElseThrow()>
+
+ // Const Field (${constField.name})
+ <#if typedField.type.isSimpleTypeReference()>
+ <#assign simpleTypeReference = typedField.type.asSimpleTypeReference().orElseThrow()>
+ lengthInBits += ${simpleTypeReference.sizeInBits};
+ <#else>
+ lengthInBits += ${helper.getEnumBaseTypeReference(typedField.type).sizeInBits};
+ </#if>
+ <#break>
+ <#case "discriminator">
+ <#assign discriminatorField = field.asDiscriminatorField().orElseThrow()>
+
+ // Discriminator Field (${discriminatorField.name})
+ <#if discriminatorField.type.isSimpleTypeReference()>
+ <#assign simpleTypeReference = discriminatorField.type.asSimpleTypeReference().orElseThrow()>
+ <#if simpleTypeReference.isVstringTypeReference()>
+ <#assign vstringTypeReference = simpleTypeReference.asVstringTypeReference().orElseThrow()>
+ lengthInBits += ${helper.toSerializationExpression(discriminatorField, helper.intTypeReference, vstringTypeReference.getLengthExpression(), parserArguments)};
+ <#else>
+ lengthInBits += ${simpleTypeReference.sizeInBits};
+ </#if>
+ <#elseif helper.isEnumField(field)>
+ lengthInBits += ${helper.getEnumBaseTypeReference(discriminatorField.type).sizeInBits};
+ <#else>
+ lengthInBits += ${discriminatorField.name}.getLengthInBits();
+ </#if>
<#break>
<#case "enum">
- <#assign enumField=field.asEnumField().orElseThrow()>
- // Enum field (${enumField.name})
- ${helper.getLanguageTypeNameForField(field)} ${enumField.name} = (${helper.getLanguageTypeNameForField(field)}) _value.get${enumField.name?cap_first}();
- ${helper.getWriteBufferWriteMethodCall(helper.getEnumBaseTypeReference(field.asTypedField().orElseThrow().type), "(" + enumField.name + ".getValue())", enumField)};
+ <#assign enumField = field.asEnumField().orElseThrow()>
+
+ // Enum Field (${enumField.name})
+ lengthInBits += ${helper.getEnumBaseTypeReference(enumField.type).sizeInBits};
+ <#break>
+ <#case "implicit">
+ <#assign implicitField = field.asImplicitField().orElseThrow()>
+ <#assign simpleTypeReference = implicitField.type.asSimpleTypeReference().orElseThrow()>
+
+ // Implicit Field (${implicitField.name})
+ lengthInBits += ${simpleTypeReference.sizeInBits};
+ <#break>
+ <#case "manualArray">
+ <#assign manualArrayField = field.asManualArrayField().orElseThrow()>
+ <#assign arrayElementTypeReference = manualArrayField.type.asArrayTypeReference().orElseThrow().getElementTypeReference()>
+
+ // Manual Array Field (${manualArrayField.name})
+ lengthInBits += ${helper.toParseExpression(manualArrayField, helper.intTypeReference, manualArrayField.lengthExpression, parserArguments)} * 8;
<#break>
<#case "manual">
- <#assign manualField=field.asManualField().orElseThrow()>
- // Manual Field (${manualField.name})
- ${helper.toSerializationExpression(manualField, manualField.type, manualField.serializeExpression, type.parserArguments.orElse(null))};
+ <#assign manualField = field.asManualField().orElseThrow()>
+
+ // Manual Field (${manualField.name})
+ lengthInBits += ${helper.toParseExpression(manualField, helper.intTypeReference, manualField.lengthExpression, parserArguments)};
+ <#break>
+ <#case "optional">
+ <#assign optionalField = field.asOptionalField().orElseThrow()>
+ <#assign nullBytesHex = optionalField.getNullBytesHex()>
+
+ // Optional Field (${optionalField.name})<#if nullBytesHex.isEmpty()>
+ if(${optionalField.name} != null) {</#if>
+ <#if optionalField.type.isSimpleTypeReference()>
+ <#assign simpleTypeReference = optionalField.type.asSimpleTypeReference().orElseThrow()>
+ <#if simpleTypeReference.isVstringTypeReference()>
+ <#assign vstringTypeReference = simpleTypeReference.asVstringTypeReference().orElseThrow()>
+ lengthInBits += ${helper.toSerializationExpression(optionalField, helper.intTypeReference, vstringTypeReference.getLengthExpression(), parserArguments)};
+ <#else>
+ lengthInBits += ${simpleTypeReference.sizeInBits};
+ </#if>
+ <#elseif helper.isEnumField(field)>
+ lengthInBits += ${helper.getEnumBaseTypeReference(optionalField.type).sizeInBits};
+ <#elseif optionalField.type.isDataIoTypeReference()>
+ lengthInBits += ${optionalField.type.asComplexTypeReference().orElseThrow().name}.getLengthInBits(${optionalField.name}<#if optionalField.type.asComplexTypeReference().orElseThrow().params?has_content>, <#list optionalField.type.asComplexTypeReference().orElseThrow().params.orElseThrow() as param>${helper.toParseExpression(optionalField, helper.anyTypeReference, param, parserArguments)}<#sep>, </#sep></#list></#if>);
+ <#else>
+ lengthInBits += ${optionalField.name}.getLengthInBits();
+ </#if>
+ <#if nullBytesHex.isEmpty()>}</#if>
+ <#break>
+ <#case "padding">
+ <#assign paddingField = field.asPaddingField().orElseThrow()>
+ <#assign simpleTypeReference = paddingField.type.asSimpleTypeReference().orElseThrow()>
+
+ // Padding Field (padding)
+ <#-- We're replacing the "lastItem" with 'false' here as the item itself can't know if it is the last -->
+ int _timesPadding = (int) (${helper.toParseExpression(paddingField, helper.intTypeReference, paddingField.paddingCondition, parserArguments)});
+ while (_timesPadding-- > 0) {
+ lengthInBits += ${simpleTypeReference.sizeInBits};
+ }
<#break>
<#case "reserved">
- <#assign reservedField=field.asReservedField().orElseThrow()>
- // Reserved Field
- ${helper.getWriteBufferWriteMethodCall(reservedField.type.asSimpleTypeReference().orElseThrow(), helper.getReservedValue(reservedField), reservedField)};
+ <#assign reservedField = field.asReservedField().orElseThrow()>
+ <#assign simpleTypeReference = reservedField.type.asSimpleTypeReference().orElseThrow()>
+
+ // Reserved Field (reserved)
+ lengthInBits += ${simpleTypeReference.sizeInBits};
<#break>
<#case "simple">
- <#assign simpleField=field.asSimpleField().orElseThrow()>
- // Simple Field (${simpleField.name})
- <#if case.name == "Struct">
- ${helper.getLanguageTypeNameForField(simpleField)} ${simpleField.name} = (${helper.getLanguageTypeNameForField(field)}) _value.getStruct().get("${simpleField.name}").get${helper.getLanguageTypeNameForField(simpleField)?cap_first}();
- <#elseif simpleField.name == "value">
- ${helper.getLanguageTypeNameForField(simpleField)} ${simpleField.name} = (${helper.getLanguageTypeNameForField(field)}) _value.get${helper.getLanguageTypeNameForField(simpleField)?cap_first}();
- <#elseif simpleField.name == "secondsSinceEpoch">
- ${helper.getLanguageTypeNameForField(simpleField)} ${simpleField.name} = (${helper.getLanguageTypeNameForField(field)}) _value.get${helper.getLanguageTypeNameForField(simpleField)?cap_first}();
- <#elseif simpleField.name == "daysSinceEpoch">
- ${helper.getLanguageTypeNameForField(simpleField)} ${simpleField.name} = (${helper.getLanguageTypeNameForField(field)}) _value.get${helper.getLanguageTypeNameForField(simpleField)?cap_first}();
- <#elseif simpleField.name == "daysSinceSiemensEpoch">
- ${helper.getLanguageTypeNameForField(simpleField)} ${simpleField.name} = (${helper.getLanguageTypeNameForField(field)}) ((PlcDATE) _value).getDaysSinceSiemensEpoch();
- <#elseif simpleField.name == "year">
- ${helper.getLanguageTypeNameForField(simpleField)} ${simpleField.name} = (${helper.getLanguageTypeNameForField(field)}) _value.get${helper.getLanguageTypeNameForField(simpleField)?cap_first}();
- <#elseif simpleField.name == "month">
- ${helper.getLanguageTypeNameForField(simpleField)} ${simpleField.name} = (${helper.getLanguageTypeNameForField(field)}) _value.get${helper.getLanguageTypeNameForField(simpleField)?cap_first}();
- <#elseif simpleField.name == "day">
- ${helper.getLanguageTypeNameForField(simpleField)} ${simpleField.name} = (${helper.getLanguageTypeNameForField(field)}) _value.get${helper.getLanguageTypeNameForField(simpleField)?cap_first}();
- <#elseif simpleField.name == "dayOfWeek">
- ${helper.getLanguageTypeNameForField(simpleField)} ${simpleField.name} = (${helper.getLanguageTypeNameForField(field)}) _value.get${helper.getLanguageTypeNameForField(simpleField)?cap_first}();
- <#elseif simpleField.name == "hour">
- ${helper.getLanguageTypeNameForField(simpleField)} ${simpleField.name} = (${helper.getLanguageTypeNameForField(field)}) _value.get${helper.getLanguageTypeNameForField(simpleField)?cap_first}();
- <#elseif simpleField.name == "minutes">
- ${helper.getLanguageTypeNameForField(simpleField)} ${simpleField.name} = (${helper.getLanguageTypeNameForField(field)}) _value.get${helper.getLanguageTypeNameForField(simpleField)?cap_first}();
- <#elseif simpleField.name == "seconds">
- ${helper.getLanguageTypeNameForField(simpleField)} ${simpleField.name} = (${helper.getLanguageTypeNameForField(field)}) _value.get${helper.getLanguageTypeNameForField(simpleField)?cap_first}();
- <#elseif simpleField.name == "milliseconds">
- ${helper.getLanguageTypeNameForField(simpleField)} ${simpleField.name} = (${helper.getLanguageTypeNameForField(field)}) _value.get${helper.getLanguageTypeNameForField(simpleField)?cap_first}();
- <#elseif simpleField.name == "millisecondsSinceMidnight">
- ${helper.getLanguageTypeNameForField(simpleField)} ${simpleField.name} = (${helper.getLanguageTypeNameForField(field)}) _value.get${helper.getLanguageTypeNameForField(simpleField)?cap_first}();
- <#elseif simpleField.name == "nanoseconds">
- ${helper.getLanguageTypeNameForField(simpleField)} ${simpleField.name} = (${helper.getLanguageTypeNameForField(field)}) _value.get${helper.getLanguageTypeNameForField(simpleField)?cap_first}();
- <#elseif simpleField.name == "nanosecondsSinceMidnight">
- ${helper.getLanguageTypeNameForField(simpleField)} ${simpleField.name} = (${helper.getLanguageTypeNameForField(field)}) _value.get${helper.getLanguageTypeNameForField(simpleField)?cap_first}();
- <#elseif simpleField.name == "nanosecondsSinceEpoch">
- ${helper.getLanguageTypeNameForField(simpleField)} ${simpleField.name} = (${helper.getLanguageTypeNameForField(field)}) _value.get${helper.getLanguageTypeNameForField(simpleField)?cap_first}();
- </#if>
+ <#assign simpleField = field.asSimpleField().orElseThrow()>
+
+ // Simple field (${simpleField.name})
<#if simpleField.type.isSimpleTypeReference()>
- ${helper.getWriteBufferWriteMethodCall(simpleField.type.asSimpleTypeReference().orElseThrow(), "(" + simpleField.name + ")", simpleField)};
+ <#assign simpleTypeReference = simpleField.type.asSimpleTypeReference().orElseThrow()>
+ <#if simpleTypeReference.isVstringTypeReference()>
+ <#assign vstringTypeReference = simpleTypeReference.asVstringTypeReference().orElseThrow()>
+ lengthInBits += ${helper.toSerializationExpression(simpleField, helper.intTypeReference, vstringTypeReference.getLengthExpression(), parserArguments)};
+ <#else>
+ lengthInBits += ${simpleTypeReference.sizeInBits};
+ </#if>
+ <#elseif helper.isEnumField(field)>
+ lengthInBits += ${helper.getEnumBaseTypeReference(simpleField.type).sizeInBits};
+ <#elseif simpleField.type.isDataIoTypeReference()>
+ lengthInBits += ${simpleField.type.asComplexTypeReference().orElseThrow().name}.getLengthInBits(${simpleField.name}<#if simpleField.type.asComplexTypeReference().orElseThrow().params?has_content>, <#list simpleField.type.asComplexTypeReference().orElseThrow().params.orElseThrow() as param>${helper.toParseExpression(simpleField, helper.anyTypeReference, param, parserArguments)}<#sep>, </#sep></#list></#if>);
<#else>
- ${simpleField.type.asComplexTypeReference().orElseThrow().name}IO.staticSerialize(writeBuffer, ${simpleField.name});
+ lengthInBits += ${simpleField.name}.getLengthInBits();
</#if>
<#break>
+ <#case "switch">
+ <#assign switchField = field.asSwitchField().orElseThrow()>
+
+ // Length of sub-type elements will be added by sub-type...
+ <#break>
+ <#case "unknown">
+ <#assign unknownField = field.asUnknownField().orElseThrow()>
+ <#assign simpleTypeReference = unknownField.type.asSimpleTypeReference().orElseThrow()>
+
+ // Unknown field
+ lengthInBits += ${simpleTypeReference.sizeInBits};
+ <#break>
+ <#case "virtual">
+ <#assign virtualField = field.asVirtualField().orElseThrow()>
+
+ // A virtual field doesn't have any in- or output.
+ <#break>
</#switch>
</#list>
- }<#sep> else </#sep></#list>
+ }<#sep> else </#sep>
+ </#list>
+
+ return lengthInBits;
}
-</#if>
- public static int getLengthInBytes(PlcValue _value<#if type.parserArguments.isPresent()>, <#list type.parserArguments.orElseThrow() as parserArgument>${helper.getLanguageTypeNameForTypeReference(parserArgument.type, false)} ${parserArgument.name}<#sep>, </#sep></#list></#if>) {
- return (int) Math.ceil((float) getLengthInBits(_value<#if type.parserArguments.isPresent()>, <#list type.parserArguments.orElseThrow() as parserArgument>${parserArgument.name}<#sep>, </#sep></#list></#if>) / 8.0);
+ public static void staticSerialize(WriteBuffer writeBuffer, PlcValue _value<#if type.parserArguments.isPresent()>, <#list type.parserArguments.orElseThrow() as parserArgument>${helper.getLanguageTypeNameForTypeReference(parserArgument.type, false)} ${parserArgument.name}<#sep>, </#sep></#list></#if>) throws SerializationException {
+ staticSerialize(writeBuffer, _value<#if type.parserArguments.isPresent()>, <#list type.parserArguments.orElseThrow() as parserArgument>${parserArgument.name}<#sep>, </#sep></#list></#if>, ByteOrder.BIG_ENDIAN);
}
- public static int getLengthInBits(PlcValue _value<#if type.parserArguments.isPresent()>, <#list type.parserArguments.orElseThrow() as parserArgument>${helper.getLanguageTypeNameForTypeReference(parserArgument.type, false)} ${parserArgument.name}<#sep>, </#sep></#list></#if>) {
- int sizeInBits = 0;
- <#assign defaultCaseOutput=false>
- <#assign dataIoTypeDefinition=type.asDataIoTypeDefinition().orElseThrow()>
+ public static void staticSerialize(WriteBuffer writeBuffer, PlcValue _value<#if type.parserArguments.isPresent()>, <#list type.parserArguments.orElseThrow() as parserArgument>${helper.getLanguageTypeNameForTypeReference(parserArgument.type, false)} ${parserArgument.name}<#sep>, </#sep></#list></#if>, ByteOrder byteOrder) throws SerializationException {
<#list dataIoTypeDefinition.switchField.orElseThrow().cases as case>
- <@compress single_line=true>
- <#if case.discriminatorValueTerms?has_content>
- if(
- <#list case.discriminatorValueTerms as discriminatorValueTerm>
- <#assign discriminatorExpression=dataIoTypeDefinition.switchField.orElseThrow().discriminatorExpressions[discriminatorValueTerm?index].asLiteral().orElseThrow().asVariableLiteral().orElseThrow()>
- <#assign discriminatorType=helper.getDiscriminatorTypes()[discriminatorExpression.name]>
- EvaluationHelper.equals(
- ${helper.toParseExpression(dataIoTypeDefinition.switchField.orElseThrow(), discriminatorType, discriminatorExpression, parserArguments)},
- <#if discriminatorType.isEnumTypeReference()>
- ${helper.getLanguageTypeNameForTypeReference(discriminatorType)}.${helper.toParseExpression(dataIoTypeDefinition.switchField.orElseThrow(), discriminatorType, discriminatorValueTerm, parserArguments)}
- <#else>
- ${helper.toParseExpression(dataIoTypeDefinition.switchField.orElseThrow(), discriminatorType, discriminatorValueTerm, parserArguments)}
- </#if>
- )
- <#sep> && </#sep>
- </#list>
- )
- <#else>
- <#assign defaultCaseOutput=true>
- </#if>
- </...@compress> { // ${case.name}
+ <#--
+ Output the if-expression for this case
+ -->
+ <@compress single_line=true>
+ <#if case.discriminatorValueTerms?has_content>
+ if(
+ <#list case.discriminatorValueTerms as discriminatorValueTerm>
+ <#if helper.isWildcard(discriminatorValueTerm)>
+ true
+ <#else>
+ <#assign switchField=dataIoTypeDefinition.switchField.orElseThrow()>
+ <#assign discriminatorExpression=switchField.discriminatorExpressions[discriminatorValueTerm?index].asLiteral().orElseThrow().asVariableLiteral().orElseThrow()>
+ <#assign discriminatorType=helper.getDiscriminatorTypes()[discriminatorExpression.discriminatorName]>
+ EvaluationHelper.equals(
+ ${helper.toParseExpression(switchField, discriminatorType, discriminatorExpression, parserArguments)},
+ <#if discriminatorType.isEnumTypeReference()>
+ ${helper.getLanguageTypeNameForTypeReference(discriminatorType)}.${helper.toParseExpression(switchField, discriminatorType, discriminatorValueTerm, parserArguments)}
+ <#else>
+ (${helper.getLanguageTypeNameForTypeReference(discriminatorType, true)}) ${helper.toParseExpression(switchField, discriminatorType, discriminatorValueTerm, parserArguments)}
+ </#if>
+ )
+ </#if>
+ <#sep> && </#sep>
+ </#list>
+ )
+ </#if>{ // ${case.name}
+ </...@compress>
+ <#--
+ Output the body of this case
+ -->
+ <#if case.name == "Struct">
+ // Output something here ...
+ <#else>
<#list case.fields as field>
- <#switch field.typeName>
- <#case "array">
- <#assign arrayField=field.asArrayField().orElseThrow()>
- <#assign elementTypeReference=arrayField.type.elementTypeReference>
- PlcList values = (PlcList) _value;
- <#if case.name == "Struct">
- // TODO: Finish this!
- <#elseif elementTypeReference.isComplexTypeReference()>
- // TODO: Finish this!
- <#else>
- sizeInBits += values.getList().size() * ${elementTypeReference.asSimpleTypeReference().orElseThrow().sizeInBits};
- </#if>
- <#break>
- <#case "const">
- <#assign constField=field.asConstField().orElseThrow()>
- // Const Field (${constField.name})
- <#-- const fields are only simple type -->
- sizeInBits += ${constField.type.asSimpleTypeReference().orElseThrow().sizeInBits};
- <#break>
- <#case "enum">
- <#assign enumField=field.asEnumField().orElseThrow()>
- // Enum field (${enumField.name})
- sizeInBits += ${helper.getEnumFieldSimpleTypeReference(enumField.type, enumField.fieldName).sizeInBits};
- <#break>
- <#case "manual">
- <#assign manualField=field.asManualField().orElseThrow()>
- // Manual Field (${manualField.name})
- sizeInBits += ${helper.toSerializationExpression(manualField, helper.intTypeReference, manualField.lengthExpression, type.parserArguments.orElse(null))};
- <#break>
- <#case "reserved">
- <#assign reservedField=field.asReservedField().orElseThrow()>
- // Reserved Field
- sizeInBits += ${reservedField.type.asSimpleTypeReference().orElseThrow().sizeInBits};
- <#break>
- <#case "simple">
- <#assign simpleField=field.asSimpleField().orElseThrow()>
- // Simple Field (${simpleField.name})
- sizeInBits += ${simpleField.type.asSimpleTypeReference().orElseThrow().sizeInBits};
- <#break>
- </#switch>
+ <#switch field.typeName>
+ <#case "array">
+ <#assign arrayField = field.asArrayField().orElseThrow()>
+ <#assign typedField = field.asTypedField().orElseThrow()>
+ <#assign namedField = field.asNamedField().orElseThrow()>
+
+ // Array Field (${arrayField.name})
+ <#if arrayField.type.elementTypeReference.isByteBased()>
+ writeByteArrayField("${namedField.name}", _value.getRaw(), writeByteArray(writeBuffer, 8)${helper.getFieldOptions(typedField, parserArguments)});
+ <#elseif arrayField.type.elementTypeReference.isSimpleTypeReference()>
+ writeSimpleTypeArrayField("${namedField.name}", _value.getList().stream().map(PlcValue::get${helper.getLanguageTypeNameForTypeReference(arrayField.type.elementTypeReference.asSimpleTypeReference().orElseThrow())}).collect(Collectors.toList()), ${helper.getDataWriterCall(arrayField.type.elementTypeReference, namedField.name)}${helper.getFieldOptions(typedField, parserArguments)});
+ <#else>
+ writeComplexTypeArrayField("${namedField.name}", _value, writeBuffer${helper.getFieldOptions(typedField, parserArguments)});
+ </#if>
+ <#break>
+ <#case "checksum">
+ <#assign checksumField = field.asChecksumField().orElseThrow()>
+ <#assign typedField = field.asTypedField().orElseThrow()>
+ <#assign namedField = field.asNamedField().orElseThrow()>
+
+ // Checksum Field (checksum) (Calculated)
+ writeChecksumField("${namedField.name}", (${helper.getLanguageTypeNameForField(field)}) (${helper.toParseExpression(checksumField, checksumField.type, checksumField.checksumExpression, parserArguments)}), ${helper.getDataWriterCall(typedField.type, namedField.name)}${helper.getFieldOptions(typedField, parserArguments)});
+ <#break>
+ <#case "const">
+ <#assign constField = field.asConstField().orElseThrow()>
+ <#assign typedField = field.asTypedField().orElseThrow()>
+ <#assign namedField = field.asNamedField().orElseThrow()>
+
+ // Const Field (${constField.name})
+ <#if typedField.type.isEnumTypeReference()>writeConstField("${constField.name}", ${namedField.name?upper_case}.getValue(), ${helper.getDataWriterCall(helper.getEnumBaseTypeReference(typedField.type), namedField.name)}${helper.getFieldOptions(typedField, parserArguments)});<#else>writeConstField("${constField.name}", ${namedField.name?upper_case}, ${helper.getDataWriterCall(typedField.type, namedField.name)}${helper.getFieldOptions(typedField, parserArguments)});</#if>
+ <#break>
+ <#case "enum">
+ <#assign enumField = field.asEnumField().orElseThrow()>
+ <#assign typedField = field.asTypedField().orElseThrow()>
+ <#assign namedField = field.asNamedField().orElseThrow()>
+
+ // Enum field (${namedField.name})
+ writeEnumField("${namedField.name}", "${helper.getLanguageTypeNameForField(field)}", ${namedField.name}, ${helper.getEnumDataWriterCall(typedField.type, namedField.name, enumField.fieldName)}${helper.getFieldOptions(typedField, parserArguments)});
+ <#break>
+ <#case "implicit">
+ <#assign implicitField = field.asImplicitField().orElseThrow()>
+ <#assign typedField = field.asTypedField().orElseThrow()>
+ <#assign namedField = field.asNamedField().orElseThrow()>
+
+ // Implicit Field (${implicitField.name}) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
+ <#-- Implicit field values might be used in expressions, in order to avoid problems, we generate a temporary variable with the given name. -->
+ ${helper.getLanguageTypeNameForField(field)} ${implicitField.name} = (${helper.getLanguageTypeNameForField(field)}) (${helper.toSerializationExpression(implicitField, implicitField.type, implicitField.serializeExpression, parserArguments)});
+ writeImplicitField("${namedField.name}", ${implicitField.name}, ${helper.getDataWriterCall(typedField.type, namedField.name)}${helper.getFieldOptions(typedField, parserArguments)});
+ <#break>
+ <#case "manualArray">
+ <#assign manualArrayField = field.asManualArrayField().orElseThrow()>
+ <#assign typedField = field.asTypedField().orElseThrow()>
+ <#assign namedField = field.asNamedField().orElseThrow()>
+
+ // Manual Array Field (${manualArrayField.name})
+ writeManualArrayField("${namedField.name}", ${namedField.name}, (${helper.getLanguageTypeNameForTypeReference(manualArrayField.type.elementTypeReference)} _value) -> ${helper.toParseExpression(manualArrayField, manualArrayField.type.elementTypeReference, manualArrayField.serializeExpression, parserArguments)}, writeBuffer${helper.getFieldOptions(typedField, parserArguments)});
+ <#break>
+ <#case "manual">
+ <#assign manualField = field.asManualField().orElseThrow()>
+ <#assign typedField = field.asTypedField().orElseThrow()>
+ <#assign namedField = field.asNamedField().orElseThrow()>
+
+ // Manual Field (${manualField.name})
+ writeManualField("${namedField.name}", () -> ${helper.toParseExpression(manualField, manualField.type, manualField.serializeExpression, parserArguments)}, writeBuffer${helper.getFieldOptions(typedField, parserArguments)});
+ <#break>
+ <#case "optional">
+ <#assign optionalField = field.asOptionalField().orElseThrow()>
+ <#assign typedField = field.asTypedField().orElseThrow()>
+ <#assign namedField = field.asNamedField().orElseThrow()>
+
+ // Optional Field (${optionalField.name}) (Can be skipped, if the value is null)
+ <#if optionalField.type.isEnumTypeReference()>
+ writeOptionalEnumField("${optionalField.name}", "${helper.getLanguageTypeNameForField(field)}", ${optionalField.name}, ${helper.getEnumDataWriterCall(optionalField.type, optionalField.name, "value")}<#if optionalField.conditionExpression.present>, ${helper.toSerializationExpression(optionalField, helper.boolTypeReference, optionalField.conditionExpression.get(), parserArguments)}</#if>${helper.getFieldOptions(typedField, parserArguments)});
+ <#elseif optionalField.type.isDataIoTypeReference()>
+ writeOptionalField("${optionalField.name}", ${optionalField.name}, new DataWriterDataIoDefault(writeBuffer, (wb, val) -> ${optionalField.type.asComplexTypeReference().orElseThrow().name}.staticSerialize(wb, val<#if optionalField.type.asComplexTypeReference().orElseThrow().params?has_content>, <#list optionalField.type.asComplexTypeReference().orElseThrow().params.orElseThrow() as param>${helper.toParseExpression(optionalField, helper.anyTypeReference, param, p [...]
+ <#else>
+ writeOptionalField("${optionalField.name}", ${optionalField.name}, ${helper.getDataWriterCall(typedField.type, optionalField.name)}<#if helper.isGeneratePropertiesForParserArguments() && optionalField.conditionExpression.present>, ${helper.toSerializationExpression(optionalField, helper.boolTypeReference, optionalField.conditionExpression.get(), parserArguments)}</#if>${helper.getFieldOptions(typedField, parserArguments)});
+ </#if>
+ <#break>
+ <#case "padding">
+ <#assign paddingField = field.asPaddingField().orElseThrow()>
+ <#assign typedField = field.asTypedField().orElseThrow()>
+
+ // Padding Field (padding)
+ writePaddingField("padding", (int) (${helper.toParseExpression(paddingField, helper.intTypeReference, paddingField.paddingCondition, parserArguments)}), (${helper.getLanguageTypeNameForField(field)}) ${helper.toSerializationExpression(paddingField, paddingField.type, paddingField.paddingValue, parserArguments)}, ${helper.getDataWriterCall(typedField.type, "padding")}${helper.getFieldOptions(typedField, parserArguments)});
+ <#break>
+ <#case "reserved">
+ <#assign reservedField = field.asReservedField().orElseThrow()>
+ <#assign typedField = field.asTypedField().orElseThrow()>
+
+ // Reserved Field (reserved)
+ writeReservedField("reserved", <#if helper.isGeneratePropertiesForReservedFields()>reservedField${reservedFieldIndex}!=null?reservedField${reservedFieldIndex}:</#if>${helper.getReservedValue(reservedField)}, ${helper.getDataWriterCall(typedField.type, "reserved")}${helper.getFieldOptions(typedField, parserArguments)});<#assign reservedFieldIndex=reservedFieldIndex+1>
+ <#break>
+ <#case "simple">
+ <#assign simpleField = field.asSimpleField().orElseThrow()>
+ <#assign typedField = field.asTypedField().orElseThrow()>
+ <#assign namedField = field.asNamedField().orElseThrow()>
+
+ // Simple Field (${namedField.name})
+ <#if typedField.type.isEnumTypeReference()>
+ writeSimpleEnumField("${simpleField.name}", "${helper.getLanguageTypeNameForField(field)}", (${helper.getLanguageTypeNameForTypeReference(simpleField.type, true)}) ${helper.getDataIoPropertyValue(simpleField)}, ${helper.getEnumDataWriterCall(simpleField.type, simpleField.name, "value")}${helper.getFieldOptions(typedField, parserArguments)});
+ <#elseif simpleField.type.isDataIoTypeReference()>
+ writeSimpleField("${simpleField.name}", (${helper.getLanguageTypeNameForTypeReference(simpleField.type, true)}) ${helper.getDataIoPropertyValue(simpleField)}, new DataWriterDataIoDefault(writeBuffer, (wb, val) -> ${simpleField.type.asComplexTypeReference().orElseThrow().name}.staticSerialize(wb, val<#if simpleField.type.asComplexTypeReference().orElseThrow().params?has_content>, <#list simpleField.type.asComplexTypeReference().orElseThrow().params.orElseThrow( [...]
+ <#else>
+ writeSimpleField("${simpleField.name}", (${helper.getLanguageTypeNameForTypeReference(simpleField.type, true)}) ${helper.getDataIoPropertyValue(simpleField)}, ${helper.getDataWriterCall(typedField.type, simpleField.name)}${helper.getFieldOptions(typedField, parserArguments)});</#if>
+ <#break>
+ <#case "virtual">
+ <#assign virtualField = field.asVirtualField().orElseThrow()>
+ <#assign typedField = field.asTypedField().orElseThrow()>
+ <#assign namedField = field.asNamedField().orElseThrow()>
+
+ // Virtual field (doesn't actually serialize anything, just makes the value available)
+ ${helper.getLanguageTypeNameForField(field)} ${namedField.name} = get${namedField.name?cap_first}();
+ writeBuffer.writeVirtual("${namedField.name}", ${namedField.name});
+ <#break>
+ </#switch>
</#list>
- }<#sep> else </#sep></#list>
- return sizeInBits;
+ </#if>
+ }<#sep> else </#sep>
+ </#list>
}
}
diff --git a/code-generation/tests/protocol-test-java/src/main/generated/org/apache/plc4x/java/test/readwrite/DataIOType.java b/code-generation/tests/protocol-test-java/src/main/generated/org/apache/plc4x/java/test/readwrite/DataIOType.java
index 4872ae7fd4..e18edaa5ca 100644
--- a/code-generation/tests/protocol-test-java/src/main/generated/org/apache/plc4x/java/test/readwrite/DataIOType.java
+++ b/code-generation/tests/protocol-test-java/src/main/generated/org/apache/plc4x/java/test/readwrite/DataIOType.java
@@ -18,17 +18,20 @@
*/
package org.apache.plc4x.java.test.readwrite;
+import static org.apache.plc4x.java.spi.codegen.fields.FieldReaderFactory.*;
+import static org.apache.plc4x.java.spi.codegen.fields.FieldWriterFactory.*;
+import static org.apache.plc4x.java.spi.codegen.io.DataReaderFactory.*;
+import static org.apache.plc4x.java.spi.codegen.io.DataWriterFactory.*;
import static org.apache.plc4x.java.spi.generation.StaticHelper.*;
import java.time.*;
import java.util.*;
+import org.apache.plc4x.java.api.exceptions.*;
import org.apache.plc4x.java.api.value.*;
-import org.apache.plc4x.java.spi.generation.ByteOrder;
-import org.apache.plc4x.java.spi.generation.EvaluationHelper;
-import org.apache.plc4x.java.spi.generation.ParseException;
-import org.apache.plc4x.java.spi.generation.ReadBuffer;
-import org.apache.plc4x.java.spi.generation.SerializationException;
-import org.apache.plc4x.java.spi.generation.WriteBuffer;
+import org.apache.plc4x.java.spi.codegen.*;
+import org.apache.plc4x.java.spi.codegen.fields.*;
+import org.apache.plc4x.java.spi.codegen.io.*;
+import org.apache.plc4x.java.spi.generation.*;
import org.apache.plc4x.java.spi.values.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -42,69 +45,55 @@ public class DataIOType {
public static PlcValue staticParse(ReadBuffer readBuffer, EnumType dataType)
throws ParseException {
if (EvaluationHelper.equals(dataType, EnumType.BOOL)) { // BOOL
-
- // Simple Field (value)
- Boolean value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
+ boolean value = readSimpleField("value", readBoolean(readBuffer));
return new PlcBOOL(value);
} else if (EvaluationHelper.equals(dataType, EnumType.UINT)) { // USINT
-
- // Simple Field (value)
- Short value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedShort("", 8);
-
+ short value = readSimpleField("value", readUnsignedShort(readBuffer, 8));
return new PlcUSINT(value);
} else if (EvaluationHelper.equals(dataType, EnumType.INT)) { // UINT
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedInt("", 16);
-
+ int value = readSimpleField("value", readUnsignedInt(readBuffer, 16));
return new PlcUINT(value);
}
return null;
}
- public static void staticSerialize(WriteBuffer writeBuffer, PlcValue _value, EnumType dataType)
- throws SerializationException {
- staticSerialize(writeBuffer, _value, dataType, ByteOrder.BIG_ENDIAN);
+ public static int getLengthInBytes(PlcValue _value, EnumType dataType) {
+ return (int) Math.ceil((float) getLengthInBits(_value, dataType) / 8.0);
}
- public static void staticSerialize(
- WriteBuffer writeBuffer, PlcValue _value, EnumType dataType, ByteOrder byteOrder)
- throws SerializationException {
+ public static int getLengthInBits(PlcValue _value, EnumType dataType) {
+ int lengthInBits = 0;
if (EvaluationHelper.equals(dataType, EnumType.BOOL)) { // BOOL
- // Simple Field (value)
- boolean value = (boolean) _value.getBoolean();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeBit("", (boolean) (value));
+ // Simple field (value)
+ lengthInBits += 1;
} else if (EvaluationHelper.equals(dataType, EnumType.UINT)) { // USINT
- // Simple Field (value)
- short value = (short) _value.getShort();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedShort("", 8, ((Number) (value)).shortValue());
+ // Simple field (value)
+ lengthInBits += 8;
} else if (EvaluationHelper.equals(dataType, EnumType.INT)) { // UINT
- // Simple Field (value)
- int value = (int) _value.getInt();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedInt("", 16, ((Number) (value)).intValue());
+ // Simple field (value)
+ lengthInBits += 16;
}
+
+ return lengthInBits;
}
- public static int getLengthInBytes(PlcValue _value, EnumType dataType) {
- return (int) Math.ceil((float) getLengthInBits(_value, dataType) / 8.0);
+ public static void staticSerialize(WriteBuffer writeBuffer, PlcValue _value, EnumType dataType)
+ throws SerializationException {
+ staticSerialize(writeBuffer, _value, dataType, ByteOrder.BIG_ENDIAN);
}
- public static int getLengthInBits(PlcValue _value, EnumType dataType) {
- int sizeInBits = 0;
+ public static void staticSerialize(
+ WriteBuffer writeBuffer, PlcValue _value, EnumType dataType, ByteOrder byteOrder)
+ throws SerializationException {
if (EvaluationHelper.equals(dataType, EnumType.BOOL)) { // BOOL
// Simple Field (value)
- sizeInBits += 1;
+ writeSimpleField("value", (boolean) _value.getBoolean(), writeBoolean(writeBuffer));
} else if (EvaluationHelper.equals(dataType, EnumType.UINT)) { // USINT
// Simple Field (value)
- sizeInBits += 8;
+ writeSimpleField("value", (short) _value.getShort(), writeUnsignedShort(writeBuffer, 8));
} else if (EvaluationHelper.equals(dataType, EnumType.INT)) { // UINT
// Simple Field (value)
- sizeInBits += 16;
+ writeSimpleField("value", (int) _value.getInteger(), writeUnsignedInt(writeBuffer, 16));
}
- return sizeInBits;
}
}
diff --git a/plc4c/generated-sources/plc4x/src/plc4x_value.c b/plc4c/generated-sources/plc4x/src/plc4x_value.c
index f2ca4e097c..1151e2a25c 100644
--- a/plc4c/generated-sources/plc4x/src/plc4x_value.c
+++ b/plc4c/generated-sources/plc4x/src/plc4x_value.c
@@ -323,7 +323,6 @@ plc4c_return_code plc4c_plc4x_read_write_plc4x_value_parse(plc4x_spi_context ctx
*data_item = plc4c_data_create_ldate_and_time_data(nanosecondsSinceEpoch);
- } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_Struct) { /* Struct */
}
return OK;
@@ -508,7 +507,6 @@ plc4c_return_code plc4c_plc4x_read_write_plc4x_value_serialize(plc4x_spi_context
if(_res != OK) {
return _res;
}
- } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_Struct) { /* Struct */
}
return OK;
}
@@ -622,7 +620,6 @@ uint16_t plc4c_plc4x_read_write_plc4x_value_length_in_bits(plc4x_spi_context ctx
// Simple field (nanosecondsSinceEpoch)
lengthInBits += 64;
- } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_Struct) { /* Struct */
}
return lengthInBits;
}
diff --git a/plc4c/generated-sources/s7/include/s7_payload_user_data_item.h b/plc4c/generated-sources/s7/include/s7_payload_user_data_item.h
index ba07aaf154..ec8f1004ac 100644
--- a/plc4c/generated-sources/s7/include/s7_payload_user_data_item.h
+++ b/plc4c/generated-sources/s7/include/s7_payload_user_data_item.h
@@ -206,12 +206,12 @@ struct plc4c_s7_read_write_s7_payload_user_data_item {
plc4c_list* s7_payload_user_data_item_cpu_function_alarm_query_response_items;
};
struct { /* S7PayloadUserDataItemClkResponse */
- uint8_t s7_payload_user_data_item_clk_response_reserved;
+ uint8_t s7_payload_user_data_item_clk_response_res;
uint8_t s7_payload_user_data_item_clk_response_year1;
plc4c_s7_read_write_date_and_time* s7_payload_user_data_item_clk_response_time_stamp;
};
struct { /* S7PayloadUserDataItemClkFResponse */
- uint8_t s7_payload_user_data_item_clk_f_response_reserved;
+ uint8_t s7_payload_user_data_item_clk_f_response_res;
uint8_t s7_payload_user_data_item_clk_f_response_year1;
plc4c_s7_read_write_date_and_time* s7_payload_user_data_item_clk_f_response_time_stamp;
};
diff --git a/plc4c/generated-sources/s7/src/alarm_message_ack_push_type.c b/plc4c/generated-sources/s7/src/alarm_message_ack_push_type.c
index 360407c741..b01c08dc1f 100644
--- a/plc4c/generated-sources/s7/src/alarm_message_ack_push_type.c
+++ b/plc4c/generated-sources/s7/src/alarm_message_ack_push_type.c
@@ -38,13 +38,13 @@ plc4c_return_code plc4c_s7_read_write_alarm_message_ack_push_type_parse(plc4x_sp
return NO_MEMORY;
}
- // Simple Field (TimeStamp)
- plc4c_s7_read_write_date_and_time* TimeStamp;
- _res = plc4c_s7_read_write_date_and_time_parse(ctx, readBuffer, (void*) &TimeStamp);
+ // Simple Field (timeStamp)
+ plc4c_s7_read_write_date_and_time* timeStamp;
+ _res = plc4c_s7_read_write_date_and_time_parse(ctx, readBuffer, (void*) &timeStamp);
if(_res != OK) {
return _res;
}
- (*_message)->time_stamp = TimeStamp;
+ (*_message)->time_stamp = timeStamp;
// Simple Field (functionId)
uint8_t functionId = 0;
@@ -88,7 +88,7 @@ plc4c_return_code plc4c_s7_read_write_alarm_message_ack_push_type_parse(plc4x_sp
plc4c_return_code plc4c_s7_read_write_alarm_message_ack_push_type_serialize(plc4x_spi_context ctx, plc4c_spi_write_buffer* writeBuffer, plc4c_s7_read_write_alarm_message_ack_push_type* _message) {
plc4c_return_code _res = OK;
- // Simple Field (TimeStamp)
+ // Simple Field (timeStamp)
_res = plc4c_s7_read_write_date_and_time_serialize(ctx, writeBuffer, _message->time_stamp);
if(_res != OK) {
return _res;
@@ -128,7 +128,7 @@ uint16_t plc4c_s7_read_write_alarm_message_ack_push_type_length_in_bytes(plc4x_s
uint16_t plc4c_s7_read_write_alarm_message_ack_push_type_length_in_bits(plc4x_spi_context ctx, plc4c_s7_read_write_alarm_message_ack_push_type* _message) {
uint16_t lengthInBits = 0;
- // Simple field (TimeStamp)
+ // Simple field (timeStamp)
lengthInBits += plc4c_s7_read_write_date_and_time_length_in_bits(ctx, _message->time_stamp);
// Simple field (functionId)
diff --git a/plc4c/generated-sources/s7/src/alarm_message_push_type.c b/plc4c/generated-sources/s7/src/alarm_message_push_type.c
index 4e85d035e3..b2e8589dd6 100644
--- a/plc4c/generated-sources/s7/src/alarm_message_push_type.c
+++ b/plc4c/generated-sources/s7/src/alarm_message_push_type.c
@@ -38,13 +38,13 @@ plc4c_return_code plc4c_s7_read_write_alarm_message_push_type_parse(plc4x_spi_co
return NO_MEMORY;
}
- // Simple Field (TimeStamp)
- plc4c_s7_read_write_date_and_time* TimeStamp;
- _res = plc4c_s7_read_write_date_and_time_parse(ctx, readBuffer, (void*) &TimeStamp);
+ // Simple Field (timeStamp)
+ plc4c_s7_read_write_date_and_time* timeStamp;
+ _res = plc4c_s7_read_write_date_and_time_parse(ctx, readBuffer, (void*) &timeStamp);
if(_res != OK) {
return _res;
}
- (*_message)->time_stamp = TimeStamp;
+ (*_message)->time_stamp = timeStamp;
// Simple Field (functionId)
uint8_t functionId = 0;
@@ -88,7 +88,7 @@ plc4c_return_code plc4c_s7_read_write_alarm_message_push_type_parse(plc4x_spi_co
plc4c_return_code plc4c_s7_read_write_alarm_message_push_type_serialize(plc4x_spi_context ctx, plc4c_spi_write_buffer* writeBuffer, plc4c_s7_read_write_alarm_message_push_type* _message) {
plc4c_return_code _res = OK;
- // Simple Field (TimeStamp)
+ // Simple Field (timeStamp)
_res = plc4c_s7_read_write_date_and_time_serialize(ctx, writeBuffer, _message->time_stamp);
if(_res != OK) {
return _res;
@@ -128,7 +128,7 @@ uint16_t plc4c_s7_read_write_alarm_message_push_type_length_in_bytes(plc4x_spi_c
uint16_t plc4c_s7_read_write_alarm_message_push_type_length_in_bits(plc4x_spi_context ctx, plc4c_s7_read_write_alarm_message_push_type* _message) {
uint16_t lengthInBits = 0;
- // Simple field (TimeStamp)
+ // Simple field (timeStamp)
lengthInBits += plc4c_s7_read_write_date_and_time_length_in_bits(ctx, _message->time_stamp);
// Simple field (functionId)
diff --git a/plc4c/generated-sources/s7/src/alarm_message_query_type.c b/plc4c/generated-sources/s7/src/alarm_message_query_type.c
index 32e9cdb6e4..c716e82b67 100644
--- a/plc4c/generated-sources/s7/src/alarm_message_query_type.c
+++ b/plc4c/generated-sources/s7/src/alarm_message_query_type.c
@@ -76,15 +76,15 @@ plc4c_return_code plc4c_s7_read_write_alarm_message_query_type_parse(plc4x_spi_c
}
(*_message)->transport_size = transportSize;
- // Const Field (DataLength)
- uint16_t DataLength = 0;
- _res = plc4c_spi_read_unsigned_short(readBuffer, 16, (uint16_t*) &DataLength);
+ // Const Field (dataLength)
+ uint16_t dataLength = 0;
+ _res = plc4c_spi_read_unsigned_short(readBuffer, 16, (uint16_t*) &dataLength);
if(_res != OK) {
return _res;
}
- if(DataLength != PLC4C_S7_READ_WRITE_ALARM_MESSAGE_QUERY_TYPE_DATA_LENGTH()) {
+ if(dataLength != PLC4C_S7_READ_WRITE_ALARM_MESSAGE_QUERY_TYPE_DATA_LENGTH()) {
return PARSE_ERROR;
- // throw new ParseException("Expected constant value " + PLC4C_S7_READ_WRITE_ALARM_MESSAGE_QUERY_TYPE_DATA_LENGTH + " but got " + DataLength);
+ // throw new ParseException("Expected constant value " + PLC4C_S7_READ_WRITE_ALARM_MESSAGE_QUERY_TYPE_DATA_LENGTH + " but got " + dataLength);
}
// Array field (messageObjects)
@@ -137,7 +137,7 @@ plc4c_return_code plc4c_s7_read_write_alarm_message_query_type_serialize(plc4x_s
return _res;
}
- // Const Field (DataLength)
+ // Const Field (dataLength)
plc4c_spi_write_unsigned_short(writeBuffer, 16, PLC4C_S7_READ_WRITE_ALARM_MESSAGE_QUERY_TYPE_DATA_LENGTH());
// Array field (messageObjects)
@@ -174,7 +174,7 @@ uint16_t plc4c_s7_read_write_alarm_message_query_type_length_in_bits(plc4x_spi_c
// Simple field (transportSize)
lengthInBits += plc4c_s7_read_write_data_transport_size_length_in_bits(ctx, &_message->transport_size);
- // Const Field (DataLength)
+ // Const Field (dataLength)
lengthInBits += 16;
// Array field
diff --git a/plc4c/generated-sources/s7/src/date_and_time.c b/plc4c/generated-sources/s7/src/date_and_time.c
index 400a79a4f9..52e414081d 100644
--- a/plc4c/generated-sources/s7/src/date_and_time.c
+++ b/plc4c/generated-sources/s7/src/date_and_time.c
@@ -38,32 +38,60 @@ plc4c_return_code plc4c_s7_read_write_date_and_time_parse(plc4x_spi_context ctx,
return NO_MEMORY;
}
- // Manual Field (year)
- uint8_t year = (uint8_t) (plc4c_s7_read_write_bcd_to_int(readBuffer));
+ // Simple Field (year)
+ uint8_t year = 0;
+ _res = plc4c_spi_read_unsigned_byte(readBuffer, 8, (uint8_t*) &year);
+ if(_res != OK) {
+ return _res;
+ }
(*_message)->year = year;
- // Manual Field (month)
- uint8_t month = (uint8_t) (plc4c_s7_read_write_bcd_to_int(readBuffer));
+ // Simple Field (month)
+ uint8_t month = 0;
+ _res = plc4c_spi_read_unsigned_byte(readBuffer, 8, (uint8_t*) &month);
+ if(_res != OK) {
+ return _res;
+ }
(*_message)->month = month;
- // Manual Field (day)
- uint8_t day = (uint8_t) (plc4c_s7_read_write_bcd_to_int(readBuffer));
+ // Simple Field (day)
+ uint8_t day = 0;
+ _res = plc4c_spi_read_unsigned_byte(readBuffer, 8, (uint8_t*) &day);
+ if(_res != OK) {
+ return _res;
+ }
(*_message)->day = day;
- // Manual Field (hour)
- uint8_t hour = (uint8_t) (plc4c_s7_read_write_bcd_to_int(readBuffer));
+ // Simple Field (hour)
+ uint8_t hour = 0;
+ _res = plc4c_spi_read_unsigned_byte(readBuffer, 8, (uint8_t*) &hour);
+ if(_res != OK) {
+ return _res;
+ }
(*_message)->hour = hour;
- // Manual Field (minutes)
- uint8_t minutes = (uint8_t) (plc4c_s7_read_write_bcd_to_int(readBuffer));
+ // Simple Field (minutes)
+ uint8_t minutes = 0;
+ _res = plc4c_spi_read_unsigned_byte(readBuffer, 8, (uint8_t*) &minutes);
+ if(_res != OK) {
+ return _res;
+ }
(*_message)->minutes = minutes;
- // Manual Field (seconds)
- uint8_t seconds = (uint8_t) (plc4c_s7_read_write_bcd_to_int(readBuffer));
+ // Simple Field (seconds)
+ uint8_t seconds = 0;
+ _res = plc4c_spi_read_unsigned_byte(readBuffer, 8, (uint8_t*) &seconds);
+ if(_res != OK) {
+ return _res;
+ }
(*_message)->seconds = seconds;
- // Manual Field (msec)
- uint16_t msec = (uint16_t) (plc4c_s7_read_write_s7msec_to_int(readBuffer));
+ // Simple Field (msec)
+ uint16_t msec = 0;
+ _res = plc4c_spi_read_unsigned_short(readBuffer, 12, (uint16_t*) &msec);
+ if(_res != OK) {
+ return _res;
+ }
(*_message)->msec = msec;
// Simple Field (dow)
@@ -80,44 +108,44 @@ plc4c_return_code plc4c_s7_read_write_date_and_time_parse(plc4x_spi_context ctx,
plc4c_return_code plc4c_s7_read_write_date_and_time_serialize(plc4x_spi_context ctx, plc4c_spi_write_buffer* writeBuffer, plc4c_s7_read_write_date_and_time* _message) {
plc4c_return_code _res = OK;
- // Manual Field (year) {
- _res = plc4c_s7_read_write_byte_to_bcd(writeBuffer, _message->year);
+ // Simple Field (year)
+ _res = plc4c_spi_write_unsigned_byte(writeBuffer, 8, _message->year);
if(_res != OK) {
return _res;
}
- // Manual Field (month) {
- _res = plc4c_s7_read_write_byte_to_bcd(writeBuffer, _message->month);
+ // Simple Field (month)
+ _res = plc4c_spi_write_unsigned_byte(writeBuffer, 8, _message->month);
if(_res != OK) {
return _res;
}
- // Manual Field (day) {
- _res = plc4c_s7_read_write_byte_to_bcd(writeBuffer, _message->day);
+ // Simple Field (day)
+ _res = plc4c_spi_write_unsigned_byte(writeBuffer, 8, _message->day);
if(_res != OK) {
return _res;
}
- // Manual Field (hour) {
- _res = plc4c_s7_read_write_byte_to_bcd(writeBuffer, _message->hour);
+ // Simple Field (hour)
+ _res = plc4c_spi_write_unsigned_byte(writeBuffer, 8, _message->hour);
if(_res != OK) {
return _res;
}
- // Manual Field (minutes) {
- _res = plc4c_s7_read_write_byte_to_bcd(writeBuffer, _message->minutes);
+ // Simple Field (minutes)
+ _res = plc4c_spi_write_unsigned_byte(writeBuffer, 8, _message->minutes);
if(_res != OK) {
return _res;
}
- // Manual Field (seconds) {
- _res = plc4c_s7_read_write_byte_to_bcd(writeBuffer, _message->seconds);
+ // Simple Field (seconds)
+ _res = plc4c_spi_write_unsigned_byte(writeBuffer, 8, _message->seconds);
if(_res != OK) {
return _res;
}
- // Manual Field (msec) {
- _res = plc4c_s7_read_write_int_to_s7msec(writeBuffer, _message->msec);
+ // Simple Field (msec)
+ _res = plc4c_spi_write_unsigned_short(writeBuffer, 12, _message->msec);
if(_res != OK) {
return _res;
}
@@ -138,25 +166,25 @@ uint16_t plc4c_s7_read_write_date_and_time_length_in_bytes(plc4x_spi_context ctx
uint16_t plc4c_s7_read_write_date_and_time_length_in_bits(plc4x_spi_context ctx, plc4c_s7_read_write_date_and_time* _message) {
uint16_t lengthInBits = 0;
- // Manual Field (year)
+ // Simple field (year)
lengthInBits += 8;
- // Manual Field (month)
+ // Simple field (month)
lengthInBits += 8;
- // Manual Field (day)
+ // Simple field (day)
lengthInBits += 8;
- // Manual Field (hour)
+ // Simple field (hour)
lengthInBits += 8;
- // Manual Field (minutes)
+ // Simple field (minutes)
lengthInBits += 8;
- // Manual Field (seconds)
+ // Simple field (seconds)
lengthInBits += 8;
- // Manual Field (msec)
+ // Simple field (msec)
lengthInBits += 12;
// Simple field (dow)
diff --git a/plc4c/generated-sources/s7/src/s7_payload_user_data_item.c b/plc4c/generated-sources/s7/src/s7_payload_user_data_item.c
index 6b4c3f610d..ae775721c2 100644
--- a/plc4c/generated-sources/s7/src/s7_payload_user_data_item.c
+++ b/plc4c/generated-sources/s7/src/s7_payload_user_data_item.c
@@ -379,67 +379,67 @@ if( ( cpuFunctionGroup == 0x02 ) && ( cpuFunctionType == 0x08 ) && ( cpuSubfunct
if( ( cpuFunctionGroup == 0x04 ) && ( cpuFunctionType == 0x00 ) && ( cpuSubfunction == 0x03 ) ) { /* S7PayloadDiagnosticMessage */
(*_message)->_type = plc4c_s7_read_write_s7_payload_user_data_item_type_plc4c_s7_read_write_s7_payload_diagnostic_message;
- // Simple Field (EventId)
- uint16_t EventId = 0;
- _res = plc4c_spi_read_unsigned_short(readBuffer, 16, (uint16_t*) &EventId);
+ // Simple Field (eventId)
+ uint16_t eventId = 0;
+ _res = plc4c_spi_read_unsigned_short(readBuffer, 16, (uint16_t*) &eventId);
if(_res != OK) {
return _res;
}
- (*_message)->s7_payload_diagnostic_message_event_id = EventId;
+ (*_message)->s7_payload_diagnostic_message_event_id = eventId;
- // Simple Field (PriorityClass)
- uint8_t PriorityClass = 0;
- _res = plc4c_spi_read_unsigned_byte(readBuffer, 8, (uint8_t*) &PriorityClass);
+ // Simple Field (priorityClass)
+ uint8_t priorityClass = 0;
+ _res = plc4c_spi_read_unsigned_byte(readBuffer, 8, (uint8_t*) &priorityClass);
if(_res != OK) {
return _res;
}
- (*_message)->s7_payload_diagnostic_message_priority_class = PriorityClass;
+ (*_message)->s7_payload_diagnostic_message_priority_class = priorityClass;
- // Simple Field (ObNumber)
- uint8_t ObNumber = 0;
- _res = plc4c_spi_read_unsigned_byte(readBuffer, 8, (uint8_t*) &ObNumber);
+ // Simple Field (obNumber)
+ uint8_t obNumber = 0;
+ _res = plc4c_spi_read_unsigned_byte(readBuffer, 8, (uint8_t*) &obNumber);
if(_res != OK) {
return _res;
}
- (*_message)->s7_payload_diagnostic_message_ob_number = ObNumber;
+ (*_message)->s7_payload_diagnostic_message_ob_number = obNumber;
- // Simple Field (DatId)
- uint16_t DatId = 0;
- _res = plc4c_spi_read_unsigned_short(readBuffer, 16, (uint16_t*) &DatId);
+ // Simple Field (datId)
+ uint16_t datId = 0;
+ _res = plc4c_spi_read_unsigned_short(readBuffer, 16, (uint16_t*) &datId);
if(_res != OK) {
return _res;
}
- (*_message)->s7_payload_diagnostic_message_dat_id = DatId;
+ (*_message)->s7_payload_diagnostic_message_dat_id = datId;
- // Simple Field (Info1)
- uint16_t Info1 = 0;
- _res = plc4c_spi_read_unsigned_short(readBuffer, 16, (uint16_t*) &Info1);
+ // Simple Field (info1)
+ uint16_t info1 = 0;
+ _res = plc4c_spi_read_unsigned_short(readBuffer, 16, (uint16_t*) &info1);
if(_res != OK) {
return _res;
}
- (*_message)->s7_payload_diagnostic_message_info1 = Info1;
+ (*_message)->s7_payload_diagnostic_message_info1 = info1;
- // Simple Field (Info2)
- uint32_t Info2 = 0;
- _res = plc4c_spi_read_unsigned_int(readBuffer, 32, (uint32_t*) &Info2);
+ // Simple Field (info2)
+ uint32_t info2 = 0;
+ _res = plc4c_spi_read_unsigned_int(readBuffer, 32, (uint32_t*) &info2);
if(_res != OK) {
return _res;
}
- (*_message)->s7_payload_diagnostic_message_info2 = Info2;
+ (*_message)->s7_payload_diagnostic_message_info2 = info2;
- // Simple Field (TimeStamp)
- plc4c_s7_read_write_date_and_time* TimeStamp;
- _res = plc4c_s7_read_write_date_and_time_parse(ctx, readBuffer, (void*) &TimeStamp);
+ // Simple Field (timeStamp)
+ plc4c_s7_read_write_date_and_time* timeStamp;
+ _res = plc4c_s7_read_write_date_and_time_parse(ctx, readBuffer, (void*) &timeStamp);
if(_res != OK) {
return _res;
}
- (*_message)->s7_payload_diagnostic_message_time_stamp = TimeStamp;
+ (*_message)->s7_payload_diagnostic_message_time_stamp = timeStamp;
} else
if( ( cpuFunctionGroup == 0x04 ) && ( cpuFunctionType == 0x00 ) && ( cpuSubfunction == 0x05 ) ) { /* S7PayloadAlarm8 */
(*_message)->_type = plc4c_s7_read_write_s7_payload_user_data_item_type_plc4c_s7_read_write_s7_payload_alarm8;
@@ -567,13 +567,13 @@ if( ( cpuFunctionGroup == 0x04 ) && ( cpuFunctionType == 0x08 ) && ( cpuSubfunct
if( ( cpuFunctionGroup == 0x04 ) && ( cpuFunctionType == 0x04 ) && ( cpuSubfunction == 0x02 ) ) { /* S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequest */
(*_message)->_type = plc4c_s7_read_write_s7_payload_user_data_item_type_plc4c_s7_read_write_s7_payload_user_data_item_cpu_function_msg_subscription_request;
- // Simple Field (Subscription)
- uint8_t Subscription = 0;
- _res = plc4c_spi_read_unsigned_byte(readBuffer, 8, (uint8_t*) &Subscription);
+ // Simple Field (subscription)
+ uint8_t subscription = 0;
+ _res = plc4c_spi_read_unsigned_byte(readBuffer, 8, (uint8_t*) &subscription);
if(_res != OK) {
return _res;
}
- (*_message)->s7_payload_user_data_item_cpu_function_msg_subscription_request_subscription = Subscription;
+ (*_message)->s7_payload_user_data_item_cpu_function_msg_subscription_request_subscription = subscription;
// Reserved Field (Compartmentalized so the "reserved" variable can't leak)
@@ -598,32 +598,32 @@ if( ( cpuFunctionGroup == 0x04 ) && ( cpuFunctionType == 0x04 ) && ( cpuSubfunct
(*_message)->s7_payload_user_data_item_cpu_function_msg_subscription_request_magic_key = magicKey;
- // Optional Field (Alarmtype) (Can be skipped, if a given expression evaluates to false)
- plc4c_s7_read_write_alarm_state_type* Alarmtype = NULL;
- if((Subscription) >= (128)) {
- _res = plc4c_s7_read_write_alarm_state_type_parse(ctx, readBuffer, &Alarmtype);
+ // Optional Field (alarmtype) (Can be skipped, if a given expression evaluates to false)
+ plc4c_s7_read_write_alarm_state_type* alarmtype = NULL;
+ if((subscription) >= (128)) {
+ _res = plc4c_s7_read_write_alarm_state_type_parse(ctx, readBuffer, &alarmtype);
if(_res != OK) {
return _res;
}
- (*_message)->s7_payload_user_data_item_cpu_function_msg_subscription_request_alarmtype = Alarmtype;
+ (*_message)->s7_payload_user_data_item_cpu_function_msg_subscription_request_alarmtype = alarmtype;
} else {
(*_message)->s7_payload_user_data_item_cpu_function_msg_subscription_request_alarmtype = NULL;
}
- // Optional Field (Reserve) (Can be skipped, if a given expression evaluates to false)
- uint8_t* Reserve = NULL;
- if((Subscription) >= (128)) {
- Reserve = malloc(sizeof(uint8_t));
- if(Reserve == NULL) {
+ // Optional Field (reserve) (Can be skipped, if a given expression evaluates to false)
+ uint8_t* reserve = NULL;
+ if((subscription) >= (128)) {
+ reserve = malloc(sizeof(uint8_t));
+ if(reserve == NULL) {
return NO_MEMORY;
}
- *Reserve = 0;
- _res = plc4c_spi_read_unsigned_byte(readBuffer, 8, (uint8_t*) Reserve);
+ *reserve = 0;
+ _res = plc4c_spi_read_unsigned_byte(readBuffer, 8, (uint8_t*) reserve);
if(_res != OK) {
return _res;
}
- (*_message)->s7_payload_user_data_item_cpu_function_msg_subscription_request_reserve = Reserve;
+ (*_message)->s7_payload_user_data_item_cpu_function_msg_subscription_request_reserve = reserve;
} else {
(*_message)->s7_payload_user_data_item_cpu_function_msg_subscription_request_reserve = NULL;
}
@@ -916,31 +916,31 @@ if( ( cpuFunctionGroup == 0x07 ) && ( cpuFunctionType == 0x04 ) && ( cpuSubfunct
if( ( cpuFunctionGroup == 0x07 ) && ( cpuFunctionType == 0x08 ) && ( cpuSubfunction == 0x01 ) ) { /* S7PayloadUserDataItemClkResponse */
(*_message)->_type = plc4c_s7_read_write_s7_payload_user_data_item_type_plc4c_s7_read_write_s7_payload_user_data_item_clk_response;
- // Simple Field (Reserved)
- uint8_t Reserved = 0;
- _res = plc4c_spi_read_unsigned_byte(readBuffer, 8, (uint8_t*) &Reserved);
+ // Simple Field (res)
+ uint8_t res = 0;
+ _res = plc4c_spi_read_unsigned_byte(readBuffer, 8, (uint8_t*) &res);
if(_res != OK) {
return _res;
}
- (*_message)->s7_payload_user_data_item_clk_response_reserved = Reserved;
+ (*_message)->s7_payload_user_data_item_clk_response_res = res;
- // Simple Field (Year1)
- uint8_t Year1 = 0;
- _res = plc4c_spi_read_unsigned_byte(readBuffer, 8, (uint8_t*) &Year1);
+ // Simple Field (year1)
+ uint8_t year1 = 0;
+ _res = plc4c_spi_read_unsigned_byte(readBuffer, 8, (uint8_t*) &year1);
if(_res != OK) {
return _res;
}
- (*_message)->s7_payload_user_data_item_clk_response_year1 = Year1;
+ (*_message)->s7_payload_user_data_item_clk_response_year1 = year1;
- // Simple Field (TimeStamp)
- plc4c_s7_read_write_date_and_time* TimeStamp;
- _res = plc4c_s7_read_write_date_and_time_parse(ctx, readBuffer, (void*) &TimeStamp);
+ // Simple Field (timeStamp)
+ plc4c_s7_read_write_date_and_time* timeStamp;
+ _res = plc4c_s7_read_write_date_and_time_parse(ctx, readBuffer, (void*) &timeStamp);
if(_res != OK) {
return _res;
}
- (*_message)->s7_payload_user_data_item_clk_response_time_stamp = TimeStamp;
+ (*_message)->s7_payload_user_data_item_clk_response_time_stamp = timeStamp;
} else
if( ( cpuFunctionGroup == 0x07 ) && ( cpuFunctionType == 0x04 ) && ( cpuSubfunction == 0x03 ) ) { /* S7PayloadUserDataItemClkFRequest */
(*_message)->_type = plc4c_s7_read_write_s7_payload_user_data_item_type_plc4c_s7_read_write_s7_payload_user_data_item_clk_f_request;
@@ -948,31 +948,31 @@ if( ( cpuFunctionGroup == 0x07 ) && ( cpuFunctionType == 0x04 ) && ( cpuSubfunct
if( ( cpuFunctionGroup == 0x07 ) && ( cpuFunctionType == 0x08 ) && ( cpuSubfunction == 0x03 ) ) { /* S7PayloadUserDataItemClkFResponse */
(*_message)->_type = plc4c_s7_read_write_s7_payload_user_data_item_type_plc4c_s7_read_write_s7_payload_user_data_item_clk_f_response;
- // Simple Field (Reserved)
- uint8_t Reserved = 0;
- _res = plc4c_spi_read_unsigned_byte(readBuffer, 8, (uint8_t*) &Reserved);
+ // Simple Field (res)
+ uint8_t res = 0;
+ _res = plc4c_spi_read_unsigned_byte(readBuffer, 8, (uint8_t*) &res);
if(_res != OK) {
return _res;
}
- (*_message)->s7_payload_user_data_item_clk_f_response_reserved = Reserved;
+ (*_message)->s7_payload_user_data_item_clk_f_response_res = res;
- // Simple Field (Year1)
- uint8_t Year1 = 0;
- _res = plc4c_spi_read_unsigned_byte(readBuffer, 8, (uint8_t*) &Year1);
+ // Simple Field (year1)
+ uint8_t year1 = 0;
+ _res = plc4c_spi_read_unsigned_byte(readBuffer, 8, (uint8_t*) &year1);
if(_res != OK) {
return _res;
}
- (*_message)->s7_payload_user_data_item_clk_f_response_year1 = Year1;
+ (*_message)->s7_payload_user_data_item_clk_f_response_year1 = year1;
- // Simple Field (TimeStamp)
- plc4c_s7_read_write_date_and_time* TimeStamp;
- _res = plc4c_s7_read_write_date_and_time_parse(ctx, readBuffer, (void*) &TimeStamp);
+ // Simple Field (timeStamp)
+ plc4c_s7_read_write_date_and_time* timeStamp;
+ _res = plc4c_s7_read_write_date_and_time_parse(ctx, readBuffer, (void*) &timeStamp);
if(_res != OK) {
return _res;
}
- (*_message)->s7_payload_user_data_item_clk_f_response_time_stamp = TimeStamp;
+ (*_message)->s7_payload_user_data_item_clk_f_response_time_stamp = timeStamp;
} else
if( ( cpuFunctionGroup == 0x07 ) && ( cpuFunctionType == 0x04 ) && ( cpuSubfunction == 0x04 ) ) { /* S7PayloadUserDataItemClkSetRequest */
(*_message)->_type = plc4c_s7_read_write_s7_payload_user_data_item_type_plc4c_s7_read_write_s7_payload_user_data_item_clk_set_request;
@@ -1003,13 +1003,13 @@ if( ( cpuFunctionGroup == 0x07 ) && ( cpuFunctionType == 0x04 ) && ( cpuSubfunct
}
- // Simple Field (TimeStamp)
- plc4c_s7_read_write_date_and_time* TimeStamp;
- _res = plc4c_s7_read_write_date_and_time_parse(ctx, readBuffer, (void*) &TimeStamp);
+ // Simple Field (timeStamp)
+ plc4c_s7_read_write_date_and_time* timeStamp;
+ _res = plc4c_s7_read_write_date_and_time_parse(ctx, readBuffer, (void*) &timeStamp);
if(_res != OK) {
return _res;
}
- (*_message)->s7_payload_user_data_item_clk_set_request_time_stamp = TimeStamp;
+ (*_message)->s7_payload_user_data_item_clk_set_request_time_stamp = timeStamp;
} else
if( ( cpuFunctionGroup == 0x07 ) && ( cpuFunctionType == 0x08 ) && ( cpuSubfunction == 0x04 ) ) { /* S7PayloadUserDataItemClkSetResponse */
(*_message)->_type = plc4c_s7_read_write_s7_payload_user_data_item_type_plc4c_s7_read_write_s7_payload_user_data_item_clk_set_response;
@@ -1189,43 +1189,43 @@ plc4c_return_code plc4c_s7_read_write_s7_payload_user_data_item_serialize(plc4x_
}
case plc4c_s7_read_write_s7_payload_user_data_item_type_plc4c_s7_read_write_s7_payload_diagnostic_message: {
- // Simple Field (EventId)
+ // Simple Field (eventId)
_res = plc4c_spi_write_unsigned_short(writeBuffer, 16, _message->s7_payload_diagnostic_message_event_id);
if(_res != OK) {
return _res;
}
- // Simple Field (PriorityClass)
+ // Simple Field (priorityClass)
_res = plc4c_spi_write_unsigned_byte(writeBuffer, 8, _message->s7_payload_diagnostic_message_priority_class);
if(_res != OK) {
return _res;
}
- // Simple Field (ObNumber)
+ // Simple Field (obNumber)
_res = plc4c_spi_write_unsigned_byte(writeBuffer, 8, _message->s7_payload_diagnostic_message_ob_number);
if(_res != OK) {
return _res;
}
- // Simple Field (DatId)
+ // Simple Field (datId)
_res = plc4c_spi_write_unsigned_short(writeBuffer, 16, _message->s7_payload_diagnostic_message_dat_id);
if(_res != OK) {
return _res;
}
- // Simple Field (Info1)
+ // Simple Field (info1)
_res = plc4c_spi_write_unsigned_short(writeBuffer, 16, _message->s7_payload_diagnostic_message_info1);
if(_res != OK) {
return _res;
}
- // Simple Field (Info2)
+ // Simple Field (info2)
_res = plc4c_spi_write_unsigned_int(writeBuffer, 32, _message->s7_payload_diagnostic_message_info2);
if(_res != OK) {
return _res;
}
- // Simple Field (TimeStamp)
+ // Simple Field (timeStamp)
_res = plc4c_s7_read_write_date_and_time_serialize(ctx, writeBuffer, _message->s7_payload_diagnostic_message_time_stamp);
if(_res != OK) {
return _res;
@@ -1338,7 +1338,7 @@ plc4c_return_code plc4c_s7_read_write_s7_payload_user_data_item_serialize(plc4x_
}
case plc4c_s7_read_write_s7_payload_user_data_item_type_plc4c_s7_read_write_s7_payload_user_data_item_cpu_function_msg_subscription_request: {
- // Simple Field (Subscription)
+ // Simple Field (subscription)
_res = plc4c_spi_write_unsigned_byte(writeBuffer, 8, _message->s7_payload_user_data_item_cpu_function_msg_subscription_request_subscription);
if(_res != OK) {
return _res;
@@ -1356,7 +1356,7 @@ plc4c_return_code plc4c_s7_read_write_s7_payload_user_data_item_serialize(plc4x_
return _res;
}
- // Optional Field (Alarmtype)
+ // Optional Field (alarmtype)
if(_message->s7_payload_user_data_item_cpu_function_msg_subscription_request_alarmtype != NULL) {
_res = plc4c_s7_read_write_alarm_state_type_serialize(ctx, writeBuffer, &_message->s7_payload_user_data_item_cpu_function_msg_subscription_request_alarmtype);
if(_res != OK) {
@@ -1364,7 +1364,7 @@ plc4c_return_code plc4c_s7_read_write_s7_payload_user_data_item_serialize(plc4x_
}
}
- // Optional Field (Reserve)
+ // Optional Field (reserve)
if(_message->s7_payload_user_data_item_cpu_function_msg_subscription_request_reserve != NULL) {
_res = plc4c_spi_write_unsigned_byte(writeBuffer, 8, *_message->s7_payload_user_data_item_cpu_function_msg_subscription_request_reserve);
if(_res != OK) {
@@ -1547,19 +1547,19 @@ plc4c_return_code plc4c_s7_read_write_s7_payload_user_data_item_serialize(plc4x_
}
case plc4c_s7_read_write_s7_payload_user_data_item_type_plc4c_s7_read_write_s7_payload_user_data_item_clk_response: {
- // Simple Field (Reserved)
- _res = plc4c_spi_write_unsigned_byte(writeBuffer, 8, _message->s7_payload_user_data_item_clk_response_reserved);
+ // Simple Field (res)
+ _res = plc4c_spi_write_unsigned_byte(writeBuffer, 8, _message->s7_payload_user_data_item_clk_response_res);
if(_res != OK) {
return _res;
}
- // Simple Field (Year1)
+ // Simple Field (year1)
_res = plc4c_spi_write_unsigned_byte(writeBuffer, 8, _message->s7_payload_user_data_item_clk_response_year1);
if(_res != OK) {
return _res;
}
- // Simple Field (TimeStamp)
+ // Simple Field (timeStamp)
_res = plc4c_s7_read_write_date_and_time_serialize(ctx, writeBuffer, _message->s7_payload_user_data_item_clk_response_time_stamp);
if(_res != OK) {
return _res;
@@ -1573,19 +1573,19 @@ plc4c_return_code plc4c_s7_read_write_s7_payload_user_data_item_serialize(plc4x_
}
case plc4c_s7_read_write_s7_payload_user_data_item_type_plc4c_s7_read_write_s7_payload_user_data_item_clk_f_response: {
- // Simple Field (Reserved)
- _res = plc4c_spi_write_unsigned_byte(writeBuffer, 8, _message->s7_payload_user_data_item_clk_f_response_reserved);
+ // Simple Field (res)
+ _res = plc4c_spi_write_unsigned_byte(writeBuffer, 8, _message->s7_payload_user_data_item_clk_f_response_res);
if(_res != OK) {
return _res;
}
- // Simple Field (Year1)
+ // Simple Field (year1)
_res = plc4c_spi_write_unsigned_byte(writeBuffer, 8, _message->s7_payload_user_data_item_clk_f_response_year1);
if(_res != OK) {
return _res;
}
- // Simple Field (TimeStamp)
+ // Simple Field (timeStamp)
_res = plc4c_s7_read_write_date_and_time_serialize(ctx, writeBuffer, _message->s7_payload_user_data_item_clk_f_response_time_stamp);
if(_res != OK) {
return _res;
@@ -1607,7 +1607,7 @@ plc4c_return_code plc4c_s7_read_write_s7_payload_user_data_item_serialize(plc4x_
return _res;
}
- // Simple Field (TimeStamp)
+ // Simple Field (timeStamp)
_res = plc4c_s7_read_write_date_and_time_serialize(ctx, writeBuffer, _message->s7_payload_user_data_item_clk_set_request_time_stamp);
if(_res != OK) {
return _res;
@@ -1756,31 +1756,31 @@ uint16_t plc4c_s7_read_write_s7_payload_user_data_item_length_in_bits(plc4x_spi_
}
case plc4c_s7_read_write_s7_payload_user_data_item_type_plc4c_s7_read_write_s7_payload_diagnostic_message: {
- // Simple field (EventId)
+ // Simple field (eventId)
lengthInBits += 16;
- // Simple field (PriorityClass)
+ // Simple field (priorityClass)
lengthInBits += 8;
- // Simple field (ObNumber)
+ // Simple field (obNumber)
lengthInBits += 8;
- // Simple field (DatId)
+ // Simple field (datId)
lengthInBits += 16;
- // Simple field (Info1)
+ // Simple field (info1)
lengthInBits += 16;
- // Simple field (Info2)
+ // Simple field (info2)
lengthInBits += 32;
- // Simple field (TimeStamp)
+ // Simple field (timeStamp)
lengthInBits += plc4c_s7_read_write_date_and_time_length_in_bits(ctx, _message->s7_payload_diagnostic_message_time_stamp);
break;
@@ -1858,7 +1858,7 @@ uint16_t plc4c_s7_read_write_s7_payload_user_data_item_length_in_bits(plc4x_spi_
}
case plc4c_s7_read_write_s7_payload_user_data_item_type_plc4c_s7_read_write_s7_payload_user_data_item_cpu_function_msg_subscription_request: {
- // Simple field (Subscription)
+ // Simple field (subscription)
lengthInBits += 8;
@@ -1870,13 +1870,13 @@ uint16_t plc4c_s7_read_write_s7_payload_user_data_item_length_in_bits(plc4x_spi_
lengthInBits += 64;
- // Optional Field (Alarmtype)
+ // Optional Field (alarmtype)
if(_message->s7_payload_user_data_item_cpu_function_msg_subscription_request_alarmtype != NULL) {
lengthInBits += plc4c_s7_read_write_alarm_state_type_length_in_bits(ctx, _message->s7_payload_user_data_item_cpu_function_msg_subscription_request_alarmtype);
}
- // Optional Field (Reserve)
+ // Optional Field (reserve)
if(_message->s7_payload_user_data_item_cpu_function_msg_subscription_request_reserve != NULL) {
lengthInBits += 8;
}
@@ -2013,15 +2013,15 @@ uint16_t plc4c_s7_read_write_s7_payload_user_data_item_length_in_bits(plc4x_spi_
}
case plc4c_s7_read_write_s7_payload_user_data_item_type_plc4c_s7_read_write_s7_payload_user_data_item_clk_response: {
- // Simple field (Reserved)
+ // Simple field (res)
lengthInBits += 8;
- // Simple field (Year1)
+ // Simple field (year1)
lengthInBits += 8;
- // Simple field (TimeStamp)
+ // Simple field (timeStamp)
lengthInBits += plc4c_s7_read_write_date_and_time_length_in_bits(ctx, _message->s7_payload_user_data_item_clk_response_time_stamp);
break;
@@ -2032,15 +2032,15 @@ uint16_t plc4c_s7_read_write_s7_payload_user_data_item_length_in_bits(plc4x_spi_
}
case plc4c_s7_read_write_s7_payload_user_data_item_type_plc4c_s7_read_write_s7_payload_user_data_item_clk_f_response: {
- // Simple field (Reserved)
+ // Simple field (res)
lengthInBits += 8;
- // Simple field (Year1)
+ // Simple field (year1)
lengthInBits += 8;
- // Simple field (TimeStamp)
+ // Simple field (timeStamp)
lengthInBits += plc4c_s7_read_write_date_and_time_length_in_bits(ctx, _message->s7_payload_user_data_item_clk_f_response_time_stamp);
break;
@@ -2055,7 +2055,7 @@ uint16_t plc4c_s7_read_write_s7_payload_user_data_item_length_in_bits(plc4x_spi_
lengthInBits += 8;
- // Simple field (TimeStamp)
+ // Simple field (timeStamp)
lengthInBits += plc4c_s7_read_write_date_and_time_length_in_bits(ctx, _message->s7_payload_user_data_item_clk_set_request_time_stamp);
break;
diff --git a/plc4c/generated-sources/s7/src/transport_size.c b/plc4c/generated-sources/s7/src/transport_size.c
index 6b7d7d001d..65c7d4afc1 100644
--- a/plc4c/generated-sources/s7/src/transport_size.c
+++ b/plc4c/generated-sources/s7/src/transport_size.c
@@ -511,7 +511,7 @@ uint8_t plc4c_s7_read_write_transport_size_get_code(plc4c_s7_read_write_transpor
return 6;
}
case plc4c_s7_read_write_transport_size_DATE_AND_TIME: { /* '0x1A' */
- return 15;
+ return 14;
}
case plc4c_s7_read_write_transport_size_DT: { /* '0x1B' */
return 15;
@@ -557,9 +557,12 @@ plc4c_s7_read_write_transport_size plc4c_s7_read_write_transport_size_get_first_
case 11: {
return plc4c_s7_read_write_transport_size_TIME;
}
- case 15: {
+ case 14: {
return plc4c_s7_read_write_transport_size_DATE_AND_TIME;
}
+ case 15: {
+ return plc4c_s7_read_write_transport_size_DT;
+ }
case 19: {
return plc4c_s7_read_write_transport_size_WCHAR;
}
@@ -650,7 +653,7 @@ uint8_t plc4c_s7_read_write_transport_size_get_size_in_bytes(plc4c_s7_read_write
return 4;
}
case plc4c_s7_read_write_transport_size_DATE_AND_TIME: { /* '0x1A' */
- return 12;
+ return 8;
}
case plc4c_s7_read_write_transport_size_DT: { /* '0x1B' */
return 12;
@@ -667,7 +670,7 @@ plc4c_s7_read_write_transport_size plc4c_s7_read_write_transport_size_get_first_
return plc4c_s7_read_write_transport_size_BOOL;
}
case 12: {
- return plc4c_s7_read_write_transport_size_DATE_AND_TIME;
+ return plc4c_s7_read_write_transport_size_DT;
}
case 16: {
return plc4c_s7_read_write_transport_size_ULINT;
diff --git a/plc4go/protocols/knxnetip/readwrite/model/KnxProperty.go b/plc4go/protocols/knxnetip/readwrite/model/KnxProperty.go
index b5b000c407..945cf7e72d 100644
--- a/plc4go/protocols/knxnetip/readwrite/model/KnxProperty.go
+++ b/plc4go/protocols/knxnetip/readwrite/model/KnxProperty.go
@@ -302,12 +302,12 @@ func KnxPropertyParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer
return nil, errors.Wrap(_err, "Error parsing reserved field")
}
- // Simple Field (dayofmonth)
- dayofmonth, _dayofmonthErr := readBuffer.ReadUint8("dayofmonth", 5)
- if _dayofmonthErr != nil {
- return nil, errors.Wrap(_dayofmonthErr, "Error parsing 'dayofmonth' field")
+ // Simple Field (dayOfMonth)
+ dayOfMonth, _dayOfMonthErr := readBuffer.ReadUint8("dayOfMonth", 5)
+ if _dayOfMonthErr != nil {
+ return nil, errors.Wrap(_dayOfMonthErr, "Error parsing 'dayOfMonth' field")
}
- _map["Struct"] = values.NewPlcUSINT(dayofmonth)
+ _map["Struct"] = values.NewPlcUSINT(dayOfMonth)
// Simple Field (dayofweek)
dayofweek, _dayofweekErr := readBuffer.ReadUint8("dayofweek", 3)
@@ -316,12 +316,12 @@ func KnxPropertyParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer
}
_map["Struct"] = values.NewPlcUSINT(dayofweek)
- // Simple Field (hourofday)
- hourofday, _hourofdayErr := readBuffer.ReadUint8("hourofday", 5)
- if _hourofdayErr != nil {
- return nil, errors.Wrap(_hourofdayErr, "Error parsing 'hourofday' field")
+ // Simple Field (hour)
+ hour, _hourErr := readBuffer.ReadUint8("hour", 5)
+ if _hourErr != nil {
+ return nil, errors.Wrap(_hourErr, "Error parsing 'hour' field")
}
- _map["Struct"] = values.NewPlcUSINT(hourofday)
+ _map["Struct"] = values.NewPlcUSINT(hour)
// Reserved Field (Just skip the bytes)
if _, _err := readBuffer.ReadUint8("reserved", 2); _err != nil {
@@ -787,30 +787,22 @@ func KnxPropertyParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer
}
readBuffer.CloseContext("KnxProperty")
return values.NewPlcBOOL(value), nil
- case propertyType == KnxPropertyDataType_PDT_BITSET8: // List
- // Array Field (value)
- var value []api.PlcValue
- for i := 0; i < int((8)); i++ {
- _item, _itemErr := readBuffer.ReadBit("value")
- if _itemErr != nil {
- return nil, errors.Wrap(_itemErr, "Error parsing 'value' field")
- }
- value = append(value, values.NewPlcBOOL(_item))
+ case propertyType == KnxPropertyDataType_PDT_BITSET8: // WORD
+ // Simple Field (value)
+ value, _valueErr := readBuffer.ReadUint8("value", 8)
+ if _valueErr != nil {
+ return nil, errors.Wrap(_valueErr, "Error parsing 'value' field")
}
readBuffer.CloseContext("KnxProperty")
- return values.NewPlcList(value), nil
- case propertyType == KnxPropertyDataType_PDT_BITSET16: // List
- // Array Field (value)
- var value []api.PlcValue
- for i := 0; i < int((16)); i++ {
- _item, _itemErr := readBuffer.ReadBit("value")
- if _itemErr != nil {
- return nil, errors.Wrap(_itemErr, "Error parsing 'value' field")
- }
- value = append(value, values.NewPlcBOOL(_item))
+ return values.NewPlcWORD(value), nil
+ case propertyType == KnxPropertyDataType_PDT_BITSET16: // DWORD
+ // Simple Field (value)
+ value, _valueErr := readBuffer.ReadUint16("value", 16)
+ if _valueErr != nil {
+ return nil, errors.Wrap(_valueErr, "Error parsing 'value' field")
}
readBuffer.CloseContext("KnxProperty")
- return values.NewPlcList(value), nil
+ return values.NewPlcDWORD(value), nil
case propertyType == KnxPropertyDataType_PDT_ENUM8: // USINT
// Simple Field (value)
value, _valueErr := readBuffer.ReadUint8("value", 8)
@@ -1046,9 +1038,9 @@ func KnxPropertySerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.
return errors.Wrap(_err, "Error serializing reserved field")
}
- // Simple Field (dayofmonth)
- if _err := writeBuffer.WriteUint8("dayofmonth", 5, uint8(value.GetUint8())); _err != nil {
- return errors.Wrap(_err, "Error serializing 'dayofmonth' field")
+ // Simple Field (dayOfMonth)
+ if _err := writeBuffer.WriteUint8("dayOfMonth", 5, uint8(value.GetUint8())); _err != nil {
+ return errors.Wrap(_err, "Error serializing 'dayOfMonth' field")
}
// Simple Field (dayofweek)
@@ -1056,9 +1048,9 @@ func KnxPropertySerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.
return errors.Wrap(_err, "Error serializing 'dayofweek' field")
}
- // Simple Field (hourofday)
- if _err := writeBuffer.WriteUint8("hourofday", 5, uint8(value.GetUint8())); _err != nil {
- return errors.Wrap(_err, "Error serializing 'hourofday' field")
+ // Simple Field (hour)
+ if _err := writeBuffer.WriteUint8("hour", 5, uint8(value.GetUint8())); _err != nil {
+ return errors.Wrap(_err, "Error serializing 'hour' field")
}
// Reserved Field (Just skip the bytes)
@@ -1380,21 +1372,15 @@ func KnxPropertySerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.
if _err := writeBuffer.WriteBit("value", value.GetBool()); _err != nil {
return errors.Wrap(_err, "Error serializing 'value' field")
}
- case propertyType == KnxPropertyDataType_PDT_BITSET8: // List
- // Array Field (value)
- for i := uint32(0); i < uint32((8)); i++ {
- _itemErr := writeBuffer.WriteBit("", value.GetIndex(i).GetBool())
- if _itemErr != nil {
- return errors.Wrap(_itemErr, "Error serializing 'value' field")
- }
+ case propertyType == KnxPropertyDataType_PDT_BITSET8: // WORD
+ // Simple Field (value)
+ if _err := writeBuffer.WriteUint8("value", 8, uint8(value.GetUint8())); _err != nil {
+ return errors.Wrap(_err, "Error serializing 'value' field")
}
- case propertyType == KnxPropertyDataType_PDT_BITSET16: // List
- // Array Field (value)
- for i := uint32(0); i < uint32((16)); i++ {
- _itemErr := writeBuffer.WriteBit("", value.GetIndex(i).GetBool())
- if _itemErr != nil {
- return errors.Wrap(_itemErr, "Error serializing 'value' field")
- }
+ case propertyType == KnxPropertyDataType_PDT_BITSET16: // DWORD
+ // Simple Field (value)
+ if _err := writeBuffer.WriteUint16("value", 16, uint16(value.GetUint16())); _err != nil {
+ return errors.Wrap(_err, "Error serializing 'value' field")
}
case propertyType == KnxPropertyDataType_PDT_ENUM8: // USINT
// Simple Field (value)
diff --git a/plc4go/protocols/s7/readwrite/model/AlarmMessageAckPushType.go b/plc4go/protocols/s7/readwrite/model/AlarmMessageAckPushType.go
index d4e58c96f6..1caa781204 100644
--- a/plc4go/protocols/s7/readwrite/model/AlarmMessageAckPushType.go
+++ b/plc4go/protocols/s7/readwrite/model/AlarmMessageAckPushType.go
@@ -86,8 +86,8 @@ func (m *_AlarmMessageAckPushType) GetMessageObjects() []AlarmMessageAckObjectPu
///////////////////////////////////////////////////////////
// NewAlarmMessageAckPushType factory function for _AlarmMessageAckPushType
-func NewAlarmMessageAckPushType(TimeStamp DateAndTime, functionId uint8, numberOfObjects uint8, messageObjects []AlarmMessageAckObjectPushType) *_AlarmMessageAckPushType {
- return &_AlarmMessageAckPushType{TimeStamp: TimeStamp, FunctionId: functionId, NumberOfObjects: numberOfObjects, MessageObjects: messageObjects}
+func NewAlarmMessageAckPushType(timeStamp DateAndTime, functionId uint8, numberOfObjects uint8, messageObjects []AlarmMessageAckObjectPushType) *_AlarmMessageAckPushType {
+ return &_AlarmMessageAckPushType{TimeStamp: timeStamp, FunctionId: functionId, NumberOfObjects: numberOfObjects, MessageObjects: messageObjects}
}
// Deprecated: use the interface for direct cast
@@ -108,7 +108,7 @@ func (m *_AlarmMessageAckPushType) GetTypeName() string {
func (m *_AlarmMessageAckPushType) GetLengthInBits(ctx context.Context) uint16 {
lengthInBits := uint16(0)
- // Simple field (TimeStamp)
+ // Simple field (timeStamp)
lengthInBits += m.TimeStamp.GetLengthInBits(ctx)
// Simple field (functionId)
@@ -149,17 +149,17 @@ func AlarmMessageAckPushTypeParseWithBuffer(ctx context.Context, readBuffer util
currentPos := positionAware.GetPos()
_ = currentPos
- // Simple Field (TimeStamp)
- if pullErr := readBuffer.PullContext("TimeStamp"); pullErr != nil {
- return nil, errors.Wrap(pullErr, "Error pulling for TimeStamp")
+ // Simple Field (timeStamp)
+ if pullErr := readBuffer.PullContext("timeStamp"); pullErr != nil {
+ return nil, errors.Wrap(pullErr, "Error pulling for timeStamp")
}
- _TimeStamp, _TimeStampErr := DateAndTimeParseWithBuffer(ctx, readBuffer)
- if _TimeStampErr != nil {
- return nil, errors.Wrap(_TimeStampErr, "Error parsing 'TimeStamp' field of AlarmMessageAckPushType")
+ _timeStamp, _timeStampErr := DateAndTimeParseWithBuffer(ctx, readBuffer)
+ if _timeStampErr != nil {
+ return nil, errors.Wrap(_timeStampErr, "Error parsing 'timeStamp' field of AlarmMessageAckPushType")
}
- TimeStamp := _TimeStamp.(DateAndTime)
- if closeErr := readBuffer.CloseContext("TimeStamp"); closeErr != nil {
- return nil, errors.Wrap(closeErr, "Error closing for TimeStamp")
+ timeStamp := _timeStamp.(DateAndTime)
+ if closeErr := readBuffer.CloseContext("timeStamp"); closeErr != nil {
+ return nil, errors.Wrap(closeErr, "Error closing for timeStamp")
}
// Simple Field (functionId)
@@ -209,7 +209,7 @@ func AlarmMessageAckPushTypeParseWithBuffer(ctx context.Context, readBuffer util
// Create the instance
return &_AlarmMessageAckPushType{
- TimeStamp: TimeStamp,
+ TimeStamp: timeStamp,
FunctionId: functionId,
NumberOfObjects: numberOfObjects,
MessageObjects: messageObjects,
@@ -233,16 +233,16 @@ func (m *_AlarmMessageAckPushType) SerializeWithWriteBuffer(ctx context.Context,
return errors.Wrap(pushErr, "Error pushing for AlarmMessageAckPushType")
}
- // Simple Field (TimeStamp)
- if pushErr := writeBuffer.PushContext("TimeStamp"); pushErr != nil {
- return errors.Wrap(pushErr, "Error pushing for TimeStamp")
+ // Simple Field (timeStamp)
+ if pushErr := writeBuffer.PushContext("timeStamp"); pushErr != nil {
+ return errors.Wrap(pushErr, "Error pushing for timeStamp")
}
- _TimeStampErr := writeBuffer.WriteSerializable(ctx, m.GetTimeStamp())
- if popErr := writeBuffer.PopContext("TimeStamp"); popErr != nil {
- return errors.Wrap(popErr, "Error popping for TimeStamp")
+ _timeStampErr := writeBuffer.WriteSerializable(ctx, m.GetTimeStamp())
+ if popErr := writeBuffer.PopContext("timeStamp"); popErr != nil {
+ return errors.Wrap(popErr, "Error popping for timeStamp")
}
- if _TimeStampErr != nil {
- return errors.Wrap(_TimeStampErr, "Error serializing 'TimeStamp' field")
+ if _timeStampErr != nil {
+ return errors.Wrap(_timeStampErr, "Error serializing 'timeStamp' field")
}
// Simple Field (functionId)
diff --git a/plc4go/protocols/s7/readwrite/model/AlarmMessagePushType.go b/plc4go/protocols/s7/readwrite/model/AlarmMessagePushType.go
index 613f743099..1f32eba330 100644
--- a/plc4go/protocols/s7/readwrite/model/AlarmMessagePushType.go
+++ b/plc4go/protocols/s7/readwrite/model/AlarmMessagePushType.go
@@ -86,8 +86,8 @@ func (m *_AlarmMessagePushType) GetMessageObjects() []AlarmMessageObjectPushType
///////////////////////////////////////////////////////////
// NewAlarmMessagePushType factory function for _AlarmMessagePushType
-func NewAlarmMessagePushType(TimeStamp DateAndTime, functionId uint8, numberOfObjects uint8, messageObjects []AlarmMessageObjectPushType) *_AlarmMessagePushType {
- return &_AlarmMessagePushType{TimeStamp: TimeStamp, FunctionId: functionId, NumberOfObjects: numberOfObjects, MessageObjects: messageObjects}
+func NewAlarmMessagePushType(timeStamp DateAndTime, functionId uint8, numberOfObjects uint8, messageObjects []AlarmMessageObjectPushType) *_AlarmMessagePushType {
+ return &_AlarmMessagePushType{TimeStamp: timeStamp, FunctionId: functionId, NumberOfObjects: numberOfObjects, MessageObjects: messageObjects}
}
// Deprecated: use the interface for direct cast
@@ -108,7 +108,7 @@ func (m *_AlarmMessagePushType) GetTypeName() string {
func (m *_AlarmMessagePushType) GetLengthInBits(ctx context.Context) uint16 {
lengthInBits := uint16(0)
- // Simple field (TimeStamp)
+ // Simple field (timeStamp)
lengthInBits += m.TimeStamp.GetLengthInBits(ctx)
// Simple field (functionId)
@@ -149,17 +149,17 @@ func AlarmMessagePushTypeParseWithBuffer(ctx context.Context, readBuffer utils.R
currentPos := positionAware.GetPos()
_ = currentPos
- // Simple Field (TimeStamp)
- if pullErr := readBuffer.PullContext("TimeStamp"); pullErr != nil {
- return nil, errors.Wrap(pullErr, "Error pulling for TimeStamp")
+ // Simple Field (timeStamp)
+ if pullErr := readBuffer.PullContext("timeStamp"); pullErr != nil {
+ return nil, errors.Wrap(pullErr, "Error pulling for timeStamp")
}
- _TimeStamp, _TimeStampErr := DateAndTimeParseWithBuffer(ctx, readBuffer)
- if _TimeStampErr != nil {
- return nil, errors.Wrap(_TimeStampErr, "Error parsing 'TimeStamp' field of AlarmMessagePushType")
+ _timeStamp, _timeStampErr := DateAndTimeParseWithBuffer(ctx, readBuffer)
+ if _timeStampErr != nil {
+ return nil, errors.Wrap(_timeStampErr, "Error parsing 'timeStamp' field of AlarmMessagePushType")
}
- TimeStamp := _TimeStamp.(DateAndTime)
- if closeErr := readBuffer.CloseContext("TimeStamp"); closeErr != nil {
- return nil, errors.Wrap(closeErr, "Error closing for TimeStamp")
+ timeStamp := _timeStamp.(DateAndTime)
+ if closeErr := readBuffer.CloseContext("timeStamp"); closeErr != nil {
+ return nil, errors.Wrap(closeErr, "Error closing for timeStamp")
}
// Simple Field (functionId)
@@ -209,7 +209,7 @@ func AlarmMessagePushTypeParseWithBuffer(ctx context.Context, readBuffer utils.R
// Create the instance
return &_AlarmMessagePushType{
- TimeStamp: TimeStamp,
+ TimeStamp: timeStamp,
FunctionId: functionId,
NumberOfObjects: numberOfObjects,
MessageObjects: messageObjects,
@@ -233,16 +233,16 @@ func (m *_AlarmMessagePushType) SerializeWithWriteBuffer(ctx context.Context, wr
return errors.Wrap(pushErr, "Error pushing for AlarmMessagePushType")
}
- // Simple Field (TimeStamp)
- if pushErr := writeBuffer.PushContext("TimeStamp"); pushErr != nil {
- return errors.Wrap(pushErr, "Error pushing for TimeStamp")
+ // Simple Field (timeStamp)
+ if pushErr := writeBuffer.PushContext("timeStamp"); pushErr != nil {
+ return errors.Wrap(pushErr, "Error pushing for timeStamp")
}
- _TimeStampErr := writeBuffer.WriteSerializable(ctx, m.GetTimeStamp())
- if popErr := writeBuffer.PopContext("TimeStamp"); popErr != nil {
- return errors.Wrap(popErr, "Error popping for TimeStamp")
+ _timeStampErr := writeBuffer.WriteSerializable(ctx, m.GetTimeStamp())
+ if popErr := writeBuffer.PopContext("timeStamp"); popErr != nil {
+ return errors.Wrap(popErr, "Error popping for timeStamp")
}
- if _TimeStampErr != nil {
- return errors.Wrap(_TimeStampErr, "Error serializing 'TimeStamp' field")
+ if _timeStampErr != nil {
+ return errors.Wrap(_timeStampErr, "Error serializing 'timeStamp' field")
}
// Simple Field (functionId)
diff --git a/plc4go/protocols/s7/readwrite/model/AlarmMessageQueryType.go b/plc4go/protocols/s7/readwrite/model/AlarmMessageQueryType.go
index aea5925960..2c4a2b9bb1 100644
--- a/plc4go/protocols/s7/readwrite/model/AlarmMessageQueryType.go
+++ b/plc4go/protocols/s7/readwrite/model/AlarmMessageQueryType.go
@@ -143,7 +143,7 @@ func (m *_AlarmMessageQueryType) GetLengthInBits(ctx context.Context) uint16 {
// Simple field (transportSize)
lengthInBits += 8
- // Const Field (DataLength)
+ // Const Field (dataLength)
lengthInBits += 16
// Array field
@@ -218,13 +218,13 @@ func AlarmMessageQueryTypeParseWithBuffer(ctx context.Context, readBuffer utils.
return nil, errors.Wrap(closeErr, "Error closing for transportSize")
}
- // Const Field (DataLength)
- DataLength, _DataLengthErr := readBuffer.ReadUint16("DataLength", 16)
- if _DataLengthErr != nil {
- return nil, errors.Wrap(_DataLengthErr, "Error parsing 'DataLength' field of AlarmMessageQueryType")
+ // Const Field (dataLength)
+ dataLength, _dataLengthErr := readBuffer.ReadUint16("dataLength", 16)
+ if _dataLengthErr != nil {
+ return nil, errors.Wrap(_dataLengthErr, "Error parsing 'dataLength' field of AlarmMessageQueryType")
}
- if DataLength != AlarmMessageQueryType_DATALENGTH {
- return nil, errors.New("Expected constant value " + fmt.Sprintf("%d", AlarmMessageQueryType_DATALENGTH) + " but got " + fmt.Sprintf("%d", DataLength))
+ if dataLength != AlarmMessageQueryType_DATALENGTH {
+ return nil, errors.New("Expected constant value " + fmt.Sprintf("%d", AlarmMessageQueryType_DATALENGTH) + " but got " + fmt.Sprintf("%d", dataLength))
}
// Array field (messageObjects)
@@ -323,10 +323,10 @@ func (m *_AlarmMessageQueryType) SerializeWithWriteBuffer(ctx context.Context, w
return errors.Wrap(_transportSizeErr, "Error serializing 'transportSize' field")
}
- // Const Field (DataLength)
- _DataLengthErr := writeBuffer.WriteUint16("DataLength", 16, uint16(0xFFFF))
- if _DataLengthErr != nil {
- return errors.Wrap(_DataLengthErr, "Error serializing 'DataLength' field")
+ // Const Field (dataLength)
+ _dataLengthErr := writeBuffer.WriteUint16("dataLength", 16, uint16(0xFFFF))
+ if _dataLengthErr != nil {
+ return errors.Wrap(_dataLengthErr, "Error serializing 'dataLength' field")
}
// Array Field (messageObjects)
diff --git a/plc4go/protocols/s7/readwrite/model/DateAndTime.go b/plc4go/protocols/s7/readwrite/model/DateAndTime.go
index f8b579ae39..080859c79b 100644
--- a/plc4go/protocols/s7/readwrite/model/DateAndTime.go
+++ b/plc4go/protocols/s7/readwrite/model/DateAndTime.go
@@ -136,26 +136,26 @@ func (m *_DateAndTime) GetTypeName() string {
func (m *_DateAndTime) GetLengthInBits(ctx context.Context) uint16 {
lengthInBits := uint16(0)
- // Manual Field (year)
- lengthInBits += uint16(int32(8))
+ // Simple field (year)
+ lengthInBits += 8
- // Manual Field (month)
- lengthInBits += uint16(int32(8))
+ // Simple field (month)
+ lengthInBits += 8
- // Manual Field (day)
- lengthInBits += uint16(int32(8))
+ // Simple field (day)
+ lengthInBits += 8
- // Manual Field (hour)
- lengthInBits += uint16(int32(8))
+ // Simple field (hour)
+ lengthInBits += 8
- // Manual Field (minutes)
- lengthInBits += uint16(int32(8))
+ // Simple field (minutes)
+ lengthInBits += 8
- // Manual Field (seconds)
- lengthInBits += uint16(int32(8))
+ // Simple field (seconds)
+ lengthInBits += 8
- // Manual Field (msec)
- lengthInBits += uint16(int32(12))
+ // Simple field (msec)
+ lengthInBits += 12
// Simple field (dow)
lengthInBits += 4
@@ -182,75 +182,54 @@ func DateAndTimeParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer
currentPos := positionAware.GetPos()
_ = currentPos
- // Manual Field (year)
- _year, _yearErr := BcdToInt(ctx, readBuffer)
+ // Simple Field (year)
+ _year, _yearErr := readBuffer.ReadUint8("year", 8)
if _yearErr != nil {
return nil, errors.Wrap(_yearErr, "Error parsing 'year' field of DateAndTime")
}
- var year uint8
- if _year != nil {
- year = _year.(uint8)
- }
+ year := _year
- // Manual Field (month)
- _month, _monthErr := BcdToInt(ctx, readBuffer)
+ // Simple Field (month)
+ _month, _monthErr := readBuffer.ReadUint8("month", 8)
if _monthErr != nil {
return nil, errors.Wrap(_monthErr, "Error parsing 'month' field of DateAndTime")
}
- var month uint8
- if _month != nil {
- month = _month.(uint8)
- }
+ month := _month
- // Manual Field (day)
- _day, _dayErr := BcdToInt(ctx, readBuffer)
+ // Simple Field (day)
+ _day, _dayErr := readBuffer.ReadUint8("day", 8)
if _dayErr != nil {
return nil, errors.Wrap(_dayErr, "Error parsing 'day' field of DateAndTime")
}
- var day uint8
- if _day != nil {
- day = _day.(uint8)
- }
+ day := _day
- // Manual Field (hour)
- _hour, _hourErr := BcdToInt(ctx, readBuffer)
+ // Simple Field (hour)
+ _hour, _hourErr := readBuffer.ReadUint8("hour", 8)
if _hourErr != nil {
return nil, errors.Wrap(_hourErr, "Error parsing 'hour' field of DateAndTime")
}
- var hour uint8
- if _hour != nil {
- hour = _hour.(uint8)
- }
+ hour := _hour
- // Manual Field (minutes)
- _minutes, _minutesErr := BcdToInt(ctx, readBuffer)
+ // Simple Field (minutes)
+ _minutes, _minutesErr := readBuffer.ReadUint8("minutes", 8)
if _minutesErr != nil {
return nil, errors.Wrap(_minutesErr, "Error parsing 'minutes' field of DateAndTime")
}
- var minutes uint8
- if _minutes != nil {
- minutes = _minutes.(uint8)
- }
+ minutes := _minutes
- // Manual Field (seconds)
- _seconds, _secondsErr := BcdToInt(ctx, readBuffer)
+ // Simple Field (seconds)
+ _seconds, _secondsErr := readBuffer.ReadUint8("seconds", 8)
if _secondsErr != nil {
return nil, errors.Wrap(_secondsErr, "Error parsing 'seconds' field of DateAndTime")
}
- var seconds uint8
- if _seconds != nil {
- seconds = _seconds.(uint8)
- }
+ seconds := _seconds
- // Manual Field (msec)
- _msec, _msecErr := S7msecToInt(ctx, readBuffer)
+ // Simple Field (msec)
+ _msec, _msecErr := readBuffer.ReadUint16("msec", 12)
if _msecErr != nil {
return nil, errors.Wrap(_msecErr, "Error parsing 'msec' field of DateAndTime")
}
- var msec uint16
- if _msec != nil {
- msec = _msec.(uint16)
- }
+ msec := _msec
// Simple Field (dow)
_dow, _dowErr := readBuffer.ReadUint8("dow", 4)
@@ -293,44 +272,51 @@ func (m *_DateAndTime) SerializeWithWriteBuffer(ctx context.Context, writeBuffer
return errors.Wrap(pushErr, "Error pushing for DateAndTime")
}
- // Manual Field (year)
- _yearErr := ByteToBcd(ctx, writeBuffer, m.GetYear())
+ // Simple Field (year)
+ year := uint8(m.GetYear())
+ _yearErr := writeBuffer.WriteUint8("year", 8, uint8((year)))
if _yearErr != nil {
return errors.Wrap(_yearErr, "Error serializing 'year' field")
}
- // Manual Field (month)
- _monthErr := ByteToBcd(ctx, writeBuffer, m.GetMonth())
+ // Simple Field (month)
+ month := uint8(m.GetMonth())
+ _monthErr := writeBuffer.WriteUint8("month", 8, uint8((month)))
if _monthErr != nil {
return errors.Wrap(_monthErr, "Error serializing 'month' field")
}
- // Manual Field (day)
- _dayErr := ByteToBcd(ctx, writeBuffer, m.GetDay())
+ // Simple Field (day)
+ day := uint8(m.GetDay())
+ _dayErr := writeBuffer.WriteUint8("day", 8, uint8((day)))
if _dayErr != nil {
return errors.Wrap(_dayErr, "Error serializing 'day' field")
}
- // Manual Field (hour)
- _hourErr := ByteToBcd(ctx, writeBuffer, m.GetHour())
+ // Simple Field (hour)
+ hour := uint8(m.GetHour())
+ _hourErr := writeBuffer.WriteUint8("hour", 8, uint8((hour)))
if _hourErr != nil {
return errors.Wrap(_hourErr, "Error serializing 'hour' field")
}
- // Manual Field (minutes)
- _minutesErr := ByteToBcd(ctx, writeBuffer, m.GetMinutes())
+ // Simple Field (minutes)
+ minutes := uint8(m.GetMinutes())
+ _minutesErr := writeBuffer.WriteUint8("minutes", 8, uint8((minutes)))
if _minutesErr != nil {
return errors.Wrap(_minutesErr, "Error serializing 'minutes' field")
}
- // Manual Field (seconds)
- _secondsErr := ByteToBcd(ctx, writeBuffer, m.GetSeconds())
+ // Simple Field (seconds)
+ seconds := uint8(m.GetSeconds())
+ _secondsErr := writeBuffer.WriteUint8("seconds", 8, uint8((seconds)))
if _secondsErr != nil {
return errors.Wrap(_secondsErr, "Error serializing 'seconds' field")
}
- // Manual Field (msec)
- _msecErr := IntToS7msec(ctx, writeBuffer, m.GetMsec())
+ // Simple Field (msec)
+ msec := uint16(m.GetMsec())
+ _msecErr := writeBuffer.WriteUint16("msec", 12, uint16((msec)))
if _msecErr != nil {
return errors.Wrap(_msecErr, "Error serializing 'msec' field")
}
diff --git a/plc4go/protocols/s7/readwrite/model/S7PayloadDiagnosticMessage.go b/plc4go/protocols/s7/readwrite/model/S7PayloadDiagnosticMessage.go
index 783f99f39d..059023e637 100644
--- a/plc4go/protocols/s7/readwrite/model/S7PayloadDiagnosticMessage.go
+++ b/plc4go/protocols/s7/readwrite/model/S7PayloadDiagnosticMessage.go
@@ -141,15 +141,15 @@ func (m *_S7PayloadDiagnosticMessage) GetTimeStamp() DateAndTime {
///////////////////////////////////////////////////////////
// NewS7PayloadDiagnosticMessage factory function for _S7PayloadDiagnosticMessage
-func NewS7PayloadDiagnosticMessage(EventId uint16, PriorityClass uint8, ObNumber uint8, DatId uint16, Info1 uint16, Info2 uint32, TimeStamp DateAndTime, returnCode DataTransportErrorCode, transportSize DataTransportSize, dataLength uint16) *_S7PayloadDiagnosticMessage {
+func NewS7PayloadDiagnosticMessage(eventId uint16, priorityClass uint8, obNumber uint8, datId uint16, info1 uint16, info2 uint32, timeStamp DateAndTime, returnCode DataTransportErrorCode, transportSize DataTransportSize, dataLength uint16) *_S7PayloadDiagnosticMessage {
_result := &_S7PayloadDiagnosticMessage{
- EventId: EventId,
- PriorityClass: PriorityClass,
- ObNumber: ObNumber,
- DatId: DatId,
- Info1: Info1,
- Info2: Info2,
- TimeStamp: TimeStamp,
+ EventId: eventId,
+ PriorityClass: priorityClass,
+ ObNumber: obNumber,
+ DatId: datId,
+ Info1: info1,
+ Info2: info2,
+ TimeStamp: timeStamp,
_S7PayloadUserDataItem: NewS7PayloadUserDataItem(returnCode, transportSize, dataLength),
}
_result._S7PayloadUserDataItem._S7PayloadUserDataItemChildRequirements = _result
@@ -174,25 +174,25 @@ func (m *_S7PayloadDiagnosticMessage) GetTypeName() string {
func (m *_S7PayloadDiagnosticMessage) GetLengthInBits(ctx context.Context) uint16 {
lengthInBits := uint16(m.GetParentLengthInBits(ctx))
- // Simple field (EventId)
+ // Simple field (eventId)
lengthInBits += 16
- // Simple field (PriorityClass)
+ // Simple field (priorityClass)
lengthInBits += 8
- // Simple field (ObNumber)
+ // Simple field (obNumber)
lengthInBits += 8
- // Simple field (DatId)
+ // Simple field (datId)
lengthInBits += 16
- // Simple field (Info1)
+ // Simple field (info1)
lengthInBits += 16
- // Simple field (Info2)
+ // Simple field (info2)
lengthInBits += 32
- // Simple field (TimeStamp)
+ // Simple field (timeStamp)
lengthInBits += m.TimeStamp.GetLengthInBits(ctx)
return lengthInBits
@@ -217,59 +217,59 @@ func S7PayloadDiagnosticMessageParseWithBuffer(ctx context.Context, readBuffer u
currentPos := positionAware.GetPos()
_ = currentPos
- // Simple Field (EventId)
- _EventId, _EventIdErr := readBuffer.ReadUint16("EventId", 16)
- if _EventIdErr != nil {
- return nil, errors.Wrap(_EventIdErr, "Error parsing 'EventId' field of S7PayloadDiagnosticMessage")
+ // Simple Field (eventId)
+ _eventId, _eventIdErr := readBuffer.ReadUint16("eventId", 16)
+ if _eventIdErr != nil {
+ return nil, errors.Wrap(_eventIdErr, "Error parsing 'eventId' field of S7PayloadDiagnosticMessage")
}
- EventId := _EventId
+ eventId := _eventId
- // Simple Field (PriorityClass)
- _PriorityClass, _PriorityClassErr := readBuffer.ReadUint8("PriorityClass", 8)
- if _PriorityClassErr != nil {
- return nil, errors.Wrap(_PriorityClassErr, "Error parsing 'PriorityClass' field of S7PayloadDiagnosticMessage")
+ // Simple Field (priorityClass)
+ _priorityClass, _priorityClassErr := readBuffer.ReadUint8("priorityClass", 8)
+ if _priorityClassErr != nil {
+ return nil, errors.Wrap(_priorityClassErr, "Error parsing 'priorityClass' field of S7PayloadDiagnosticMessage")
}
- PriorityClass := _PriorityClass
+ priorityClass := _priorityClass
- // Simple Field (ObNumber)
- _ObNumber, _ObNumberErr := readBuffer.ReadUint8("ObNumber", 8)
- if _ObNumberErr != nil {
- return nil, errors.Wrap(_ObNumberErr, "Error parsing 'ObNumber' field of S7PayloadDiagnosticMessage")
+ // Simple Field (obNumber)
+ _obNumber, _obNumberErr := readBuffer.ReadUint8("obNumber", 8)
+ if _obNumberErr != nil {
+ return nil, errors.Wrap(_obNumberErr, "Error parsing 'obNumber' field of S7PayloadDiagnosticMessage")
}
- ObNumber := _ObNumber
+ obNumber := _obNumber
- // Simple Field (DatId)
- _DatId, _DatIdErr := readBuffer.ReadUint16("DatId", 16)
- if _DatIdErr != nil {
- return nil, errors.Wrap(_DatIdErr, "Error parsing 'DatId' field of S7PayloadDiagnosticMessage")
+ // Simple Field (datId)
+ _datId, _datIdErr := readBuffer.ReadUint16("datId", 16)
+ if _datIdErr != nil {
+ return nil, errors.Wrap(_datIdErr, "Error parsing 'datId' field of S7PayloadDiagnosticMessage")
}
- DatId := _DatId
+ datId := _datId
- // Simple Field (Info1)
- _Info1, _Info1Err := readBuffer.ReadUint16("Info1", 16)
- if _Info1Err != nil {
- return nil, errors.Wrap(_Info1Err, "Error parsing 'Info1' field of S7PayloadDiagnosticMessage")
+ // Simple Field (info1)
+ _info1, _info1Err := readBuffer.ReadUint16("info1", 16)
+ if _info1Err != nil {
+ return nil, errors.Wrap(_info1Err, "Error parsing 'info1' field of S7PayloadDiagnosticMessage")
}
- Info1 := _Info1
+ info1 := _info1
- // Simple Field (Info2)
- _Info2, _Info2Err := readBuffer.ReadUint32("Info2", 32)
- if _Info2Err != nil {
- return nil, errors.Wrap(_Info2Err, "Error parsing 'Info2' field of S7PayloadDiagnosticMessage")
+ // Simple Field (info2)
+ _info2, _info2Err := readBuffer.ReadUint32("info2", 32)
+ if _info2Err != nil {
+ return nil, errors.Wrap(_info2Err, "Error parsing 'info2' field of S7PayloadDiagnosticMessage")
}
- Info2 := _Info2
+ info2 := _info2
- // Simple Field (TimeStamp)
- if pullErr := readBuffer.PullContext("TimeStamp"); pullErr != nil {
- return nil, errors.Wrap(pullErr, "Error pulling for TimeStamp")
+ // Simple Field (timeStamp)
+ if pullErr := readBuffer.PullContext("timeStamp"); pullErr != nil {
+ return nil, errors.Wrap(pullErr, "Error pulling for timeStamp")
}
- _TimeStamp, _TimeStampErr := DateAndTimeParseWithBuffer(ctx, readBuffer)
- if _TimeStampErr != nil {
- return nil, errors.Wrap(_TimeStampErr, "Error parsing 'TimeStamp' field of S7PayloadDiagnosticMessage")
+ _timeStamp, _timeStampErr := DateAndTimeParseWithBuffer(ctx, readBuffer)
+ if _timeStampErr != nil {
+ return nil, errors.Wrap(_timeStampErr, "Error parsing 'timeStamp' field of S7PayloadDiagnosticMessage")
}
- TimeStamp := _TimeStamp.(DateAndTime)
- if closeErr := readBuffer.CloseContext("TimeStamp"); closeErr != nil {
- return nil, errors.Wrap(closeErr, "Error closing for TimeStamp")
+ timeStamp := _timeStamp.(DateAndTime)
+ if closeErr := readBuffer.CloseContext("timeStamp"); closeErr != nil {
+ return nil, errors.Wrap(closeErr, "Error closing for timeStamp")
}
if closeErr := readBuffer.CloseContext("S7PayloadDiagnosticMessage"); closeErr != nil {
@@ -279,13 +279,13 @@ func S7PayloadDiagnosticMessageParseWithBuffer(ctx context.Context, readBuffer u
// Create a partially initialized instance
_child := &_S7PayloadDiagnosticMessage{
_S7PayloadUserDataItem: &_S7PayloadUserDataItem{},
- EventId: EventId,
- PriorityClass: PriorityClass,
- ObNumber: ObNumber,
- DatId: DatId,
- Info1: Info1,
- Info2: Info2,
- TimeStamp: TimeStamp,
+ EventId: eventId,
+ PriorityClass: priorityClass,
+ ObNumber: obNumber,
+ DatId: datId,
+ Info1: info1,
+ Info2: info2,
+ TimeStamp: timeStamp,
}
_child._S7PayloadUserDataItem._S7PayloadUserDataItemChildRequirements = _child
return _child, nil
@@ -309,58 +309,58 @@ func (m *_S7PayloadDiagnosticMessage) SerializeWithWriteBuffer(ctx context.Conte
return errors.Wrap(pushErr, "Error pushing for S7PayloadDiagnosticMessage")
}
- // Simple Field (EventId)
- EventId := uint16(m.GetEventId())
- _EventIdErr := writeBuffer.WriteUint16("EventId", 16, uint16((EventId)))
- if _EventIdErr != nil {
- return errors.Wrap(_EventIdErr, "Error serializing 'EventId' field")
+ // Simple Field (eventId)
+ eventId := uint16(m.GetEventId())
+ _eventIdErr := writeBuffer.WriteUint16("eventId", 16, uint16((eventId)))
+ if _eventIdErr != nil {
+ return errors.Wrap(_eventIdErr, "Error serializing 'eventId' field")
}
- // Simple Field (PriorityClass)
- PriorityClass := uint8(m.GetPriorityClass())
- _PriorityClassErr := writeBuffer.WriteUint8("PriorityClass", 8, uint8((PriorityClass)))
- if _PriorityClassErr != nil {
- return errors.Wrap(_PriorityClassErr, "Error serializing 'PriorityClass' field")
+ // Simple Field (priorityClass)
+ priorityClass := uint8(m.GetPriorityClass())
+ _priorityClassErr := writeBuffer.WriteUint8("priorityClass", 8, uint8((priorityClass)))
+ if _priorityClassErr != nil {
+ return errors.Wrap(_priorityClassErr, "Error serializing 'priorityClass' field")
}
- // Simple Field (ObNumber)
- ObNumber := uint8(m.GetObNumber())
- _ObNumberErr := writeBuffer.WriteUint8("ObNumber", 8, uint8((ObNumber)))
- if _ObNumberErr != nil {
- return errors.Wrap(_ObNumberErr, "Error serializing 'ObNumber' field")
+ // Simple Field (obNumber)
+ obNumber := uint8(m.GetObNumber())
+ _obNumberErr := writeBuffer.WriteUint8("obNumber", 8, uint8((obNumber)))
+ if _obNumberErr != nil {
+ return errors.Wrap(_obNumberErr, "Error serializing 'obNumber' field")
}
- // Simple Field (DatId)
- DatId := uint16(m.GetDatId())
- _DatIdErr := writeBuffer.WriteUint16("DatId", 16, uint16((DatId)))
- if _DatIdErr != nil {
- return errors.Wrap(_DatIdErr, "Error serializing 'DatId' field")
+ // Simple Field (datId)
+ datId := uint16(m.GetDatId())
+ _datIdErr := writeBuffer.WriteUint16("datId", 16, uint16((datId)))
+ if _datIdErr != nil {
+ return errors.Wrap(_datIdErr, "Error serializing 'datId' field")
}
- // Simple Field (Info1)
- Info1 := uint16(m.GetInfo1())
- _Info1Err := writeBuffer.WriteUint16("Info1", 16, uint16((Info1)))
- if _Info1Err != nil {
- return errors.Wrap(_Info1Err, "Error serializing 'Info1' field")
+ // Simple Field (info1)
+ info1 := uint16(m.GetInfo1())
+ _info1Err := writeBuffer.WriteUint16("info1", 16, uint16((info1)))
+ if _info1Err != nil {
+ return errors.Wrap(_info1Err, "Error serializing 'info1' field")
}
- // Simple Field (Info2)
- Info2 := uint32(m.GetInfo2())
- _Info2Err := writeBuffer.WriteUint32("Info2", 32, uint32((Info2)))
- if _Info2Err != nil {
- return errors.Wrap(_Info2Err, "Error serializing 'Info2' field")
+ // Simple Field (info2)
+ info2 := uint32(m.GetInfo2())
+ _info2Err := writeBuffer.WriteUint32("info2", 32, uint32((info2)))
+ if _info2Err != nil {
+ return errors.Wrap(_info2Err, "Error serializing 'info2' field")
}
- // Simple Field (TimeStamp)
- if pushErr := writeBuffer.PushContext("TimeStamp"); pushErr != nil {
- return errors.Wrap(pushErr, "Error pushing for TimeStamp")
+ // Simple Field (timeStamp)
+ if pushErr := writeBuffer.PushContext("timeStamp"); pushErr != nil {
+ return errors.Wrap(pushErr, "Error pushing for timeStamp")
}
- _TimeStampErr := writeBuffer.WriteSerializable(ctx, m.GetTimeStamp())
- if popErr := writeBuffer.PopContext("TimeStamp"); popErr != nil {
- return errors.Wrap(popErr, "Error popping for TimeStamp")
+ _timeStampErr := writeBuffer.WriteSerializable(ctx, m.GetTimeStamp())
+ if popErr := writeBuffer.PopContext("timeStamp"); popErr != nil {
+ return errors.Wrap(popErr, "Error popping for timeStamp")
}
- if _TimeStampErr != nil {
- return errors.Wrap(_TimeStampErr, "Error serializing 'TimeStamp' field")
+ if _timeStampErr != nil {
+ return errors.Wrap(_timeStampErr, "Error serializing 'timeStamp' field")
}
if popErr := writeBuffer.PopContext("S7PayloadDiagnosticMessage"); popErr != nil {
diff --git a/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkFResponse.go b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkFResponse.go
index 7765579600..46b412e4f1 100644
--- a/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkFResponse.go
+++ b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkFResponse.go
@@ -35,8 +35,8 @@ type S7PayloadUserDataItemClkFResponse interface {
utils.LengthAware
utils.Serializable
S7PayloadUserDataItem
- // GetReserved returns Reserved (property field)
- GetReserved() uint8
+ // GetRes returns Res (property field)
+ GetRes() uint8
// GetYear1 returns Year1 (property field)
GetYear1() uint8
// GetTimeStamp returns TimeStamp (property field)
@@ -53,7 +53,7 @@ type S7PayloadUserDataItemClkFResponseExactly interface {
// _S7PayloadUserDataItemClkFResponse is the data-structure of this message
type _S7PayloadUserDataItemClkFResponse struct {
*_S7PayloadUserDataItem
- Reserved uint8
+ Res uint8
Year1 uint8
TimeStamp DateAndTime
}
@@ -95,8 +95,8 @@ func (m *_S7PayloadUserDataItemClkFResponse) GetParent() S7PayloadUserDataItem {
/////////////////////// Accessors for property fields.
///////////////////////
-func (m *_S7PayloadUserDataItemClkFResponse) GetReserved() uint8 {
- return m.Reserved
+func (m *_S7PayloadUserDataItemClkFResponse) GetRes() uint8 {
+ return m.Res
}
func (m *_S7PayloadUserDataItemClkFResponse) GetYear1() uint8 {
@@ -113,11 +113,11 @@ func (m *_S7PayloadUserDataItemClkFResponse) GetTimeStamp() DateAndTime {
///////////////////////////////////////////////////////////
// NewS7PayloadUserDataItemClkFResponse factory function for _S7PayloadUserDataItemClkFResponse
-func NewS7PayloadUserDataItemClkFResponse(Reserved uint8, Year1 uint8, TimeStamp DateAndTime, returnCode DataTransportErrorCode, transportSize DataTransportSize, dataLength uint16) *_S7PayloadUserDataItemClkFResponse {
+func NewS7PayloadUserDataItemClkFResponse(res uint8, year1 uint8, timeStamp DateAndTime, returnCode DataTransportErrorCode, transportSize DataTransportSize, dataLength uint16) *_S7PayloadUserDataItemClkFResponse {
_result := &_S7PayloadUserDataItemClkFResponse{
- Reserved: Reserved,
- Year1: Year1,
- TimeStamp: TimeStamp,
+ Res: res,
+ Year1: year1,
+ TimeStamp: timeStamp,
_S7PayloadUserDataItem: NewS7PayloadUserDataItem(returnCode, transportSize, dataLength),
}
_result._S7PayloadUserDataItem._S7PayloadUserDataItemChildRequirements = _result
@@ -142,13 +142,13 @@ func (m *_S7PayloadUserDataItemClkFResponse) GetTypeName() string {
func (m *_S7PayloadUserDataItemClkFResponse) GetLengthInBits(ctx context.Context) uint16 {
lengthInBits := uint16(m.GetParentLengthInBits(ctx))
- // Simple field (Reserved)
+ // Simple field (res)
lengthInBits += 8
- // Simple field (Year1)
+ // Simple field (year1)
lengthInBits += 8
- // Simple field (TimeStamp)
+ // Simple field (timeStamp)
lengthInBits += m.TimeStamp.GetLengthInBits(ctx)
return lengthInBits
@@ -173,31 +173,31 @@ func S7PayloadUserDataItemClkFResponseParseWithBuffer(ctx context.Context, readB
currentPos := positionAware.GetPos()
_ = currentPos
- // Simple Field (Reserved)
- _Reserved, _ReservedErr := readBuffer.ReadUint8("Reserved", 8)
- if _ReservedErr != nil {
- return nil, errors.Wrap(_ReservedErr, "Error parsing 'Reserved' field of S7PayloadUserDataItemClkFResponse")
+ // Simple Field (res)
+ _res, _resErr := readBuffer.ReadUint8("res", 8)
+ if _resErr != nil {
+ return nil, errors.Wrap(_resErr, "Error parsing 'res' field of S7PayloadUserDataItemClkFResponse")
}
- Reserved := _Reserved
+ res := _res
- // Simple Field (Year1)
- _Year1, _Year1Err := readBuffer.ReadUint8("Year1", 8)
- if _Year1Err != nil {
- return nil, errors.Wrap(_Year1Err, "Error parsing 'Year1' field of S7PayloadUserDataItemClkFResponse")
+ // Simple Field (year1)
+ _year1, _year1Err := readBuffer.ReadUint8("year1", 8)
+ if _year1Err != nil {
+ return nil, errors.Wrap(_year1Err, "Error parsing 'year1' field of S7PayloadUserDataItemClkFResponse")
}
- Year1 := _Year1
+ year1 := _year1
- // Simple Field (TimeStamp)
- if pullErr := readBuffer.PullContext("TimeStamp"); pullErr != nil {
- return nil, errors.Wrap(pullErr, "Error pulling for TimeStamp")
+ // Simple Field (timeStamp)
+ if pullErr := readBuffer.PullContext("timeStamp"); pullErr != nil {
+ return nil, errors.Wrap(pullErr, "Error pulling for timeStamp")
}
- _TimeStamp, _TimeStampErr := DateAndTimeParseWithBuffer(ctx, readBuffer)
- if _TimeStampErr != nil {
- return nil, errors.Wrap(_TimeStampErr, "Error parsing 'TimeStamp' field of S7PayloadUserDataItemClkFResponse")
+ _timeStamp, _timeStampErr := DateAndTimeParseWithBuffer(ctx, readBuffer)
+ if _timeStampErr != nil {
+ return nil, errors.Wrap(_timeStampErr, "Error parsing 'timeStamp' field of S7PayloadUserDataItemClkFResponse")
}
- TimeStamp := _TimeStamp.(DateAndTime)
- if closeErr := readBuffer.CloseContext("TimeStamp"); closeErr != nil {
- return nil, errors.Wrap(closeErr, "Error closing for TimeStamp")
+ timeStamp := _timeStamp.(DateAndTime)
+ if closeErr := readBuffer.CloseContext("timeStamp"); closeErr != nil {
+ return nil, errors.Wrap(closeErr, "Error closing for timeStamp")
}
if closeErr := readBuffer.CloseContext("S7PayloadUserDataItemClkFResponse"); closeErr != nil {
@@ -207,9 +207,9 @@ func S7PayloadUserDataItemClkFResponseParseWithBuffer(ctx context.Context, readB
// Create a partially initialized instance
_child := &_S7PayloadUserDataItemClkFResponse{
_S7PayloadUserDataItem: &_S7PayloadUserDataItem{},
- Reserved: Reserved,
- Year1: Year1,
- TimeStamp: TimeStamp,
+ Res: res,
+ Year1: year1,
+ TimeStamp: timeStamp,
}
_child._S7PayloadUserDataItem._S7PayloadUserDataItemChildRequirements = _child
return _child, nil
@@ -233,30 +233,30 @@ func (m *_S7PayloadUserDataItemClkFResponse) SerializeWithWriteBuffer(ctx contex
return errors.Wrap(pushErr, "Error pushing for S7PayloadUserDataItemClkFResponse")
}
- // Simple Field (Reserved)
- Reserved := uint8(m.GetReserved())
- _ReservedErr := writeBuffer.WriteUint8("Reserved", 8, uint8((Reserved)))
- if _ReservedErr != nil {
- return errors.Wrap(_ReservedErr, "Error serializing 'Reserved' field")
+ // Simple Field (res)
+ res := uint8(m.GetRes())
+ _resErr := writeBuffer.WriteUint8("res", 8, uint8((res)))
+ if _resErr != nil {
+ return errors.Wrap(_resErr, "Error serializing 'res' field")
}
- // Simple Field (Year1)
- Year1 := uint8(m.GetYear1())
- _Year1Err := writeBuffer.WriteUint8("Year1", 8, uint8((Year1)))
- if _Year1Err != nil {
- return errors.Wrap(_Year1Err, "Error serializing 'Year1' field")
+ // Simple Field (year1)
+ year1 := uint8(m.GetYear1())
+ _year1Err := writeBuffer.WriteUint8("year1", 8, uint8((year1)))
+ if _year1Err != nil {
+ return errors.Wrap(_year1Err, "Error serializing 'year1' field")
}
- // Simple Field (TimeStamp)
- if pushErr := writeBuffer.PushContext("TimeStamp"); pushErr != nil {
- return errors.Wrap(pushErr, "Error pushing for TimeStamp")
+ // Simple Field (timeStamp)
+ if pushErr := writeBuffer.PushContext("timeStamp"); pushErr != nil {
+ return errors.Wrap(pushErr, "Error pushing for timeStamp")
}
- _TimeStampErr := writeBuffer.WriteSerializable(ctx, m.GetTimeStamp())
- if popErr := writeBuffer.PopContext("TimeStamp"); popErr != nil {
- return errors.Wrap(popErr, "Error popping for TimeStamp")
+ _timeStampErr := writeBuffer.WriteSerializable(ctx, m.GetTimeStamp())
+ if popErr := writeBuffer.PopContext("timeStamp"); popErr != nil {
+ return errors.Wrap(popErr, "Error popping for timeStamp")
}
- if _TimeStampErr != nil {
- return errors.Wrap(_TimeStampErr, "Error serializing 'TimeStamp' field")
+ if _timeStampErr != nil {
+ return errors.Wrap(_timeStampErr, "Error serializing 'timeStamp' field")
}
if popErr := writeBuffer.PopContext("S7PayloadUserDataItemClkFResponse"); popErr != nil {
diff --git a/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkResponse.go b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkResponse.go
index 1f6e57b95a..d2165b4763 100644
--- a/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkResponse.go
+++ b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkResponse.go
@@ -35,8 +35,8 @@ type S7PayloadUserDataItemClkResponse interface {
utils.LengthAware
utils.Serializable
S7PayloadUserDataItem
- // GetReserved returns Reserved (property field)
- GetReserved() uint8
+ // GetRes returns Res (property field)
+ GetRes() uint8
// GetYear1 returns Year1 (property field)
GetYear1() uint8
// GetTimeStamp returns TimeStamp (property field)
@@ -53,7 +53,7 @@ type S7PayloadUserDataItemClkResponseExactly interface {
// _S7PayloadUserDataItemClkResponse is the data-structure of this message
type _S7PayloadUserDataItemClkResponse struct {
*_S7PayloadUserDataItem
- Reserved uint8
+ Res uint8
Year1 uint8
TimeStamp DateAndTime
}
@@ -95,8 +95,8 @@ func (m *_S7PayloadUserDataItemClkResponse) GetParent() S7PayloadUserDataItem {
/////////////////////// Accessors for property fields.
///////////////////////
-func (m *_S7PayloadUserDataItemClkResponse) GetReserved() uint8 {
- return m.Reserved
+func (m *_S7PayloadUserDataItemClkResponse) GetRes() uint8 {
+ return m.Res
}
func (m *_S7PayloadUserDataItemClkResponse) GetYear1() uint8 {
@@ -113,11 +113,11 @@ func (m *_S7PayloadUserDataItemClkResponse) GetTimeStamp() DateAndTime {
///////////////////////////////////////////////////////////
// NewS7PayloadUserDataItemClkResponse factory function for _S7PayloadUserDataItemClkResponse
-func NewS7PayloadUserDataItemClkResponse(Reserved uint8, Year1 uint8, TimeStamp DateAndTime, returnCode DataTransportErrorCode, transportSize DataTransportSize, dataLength uint16) *_S7PayloadUserDataItemClkResponse {
+func NewS7PayloadUserDataItemClkResponse(res uint8, year1 uint8, timeStamp DateAndTime, returnCode DataTransportErrorCode, transportSize DataTransportSize, dataLength uint16) *_S7PayloadUserDataItemClkResponse {
_result := &_S7PayloadUserDataItemClkResponse{
- Reserved: Reserved,
- Year1: Year1,
- TimeStamp: TimeStamp,
+ Res: res,
+ Year1: year1,
+ TimeStamp: timeStamp,
_S7PayloadUserDataItem: NewS7PayloadUserDataItem(returnCode, transportSize, dataLength),
}
_result._S7PayloadUserDataItem._S7PayloadUserDataItemChildRequirements = _result
@@ -142,13 +142,13 @@ func (m *_S7PayloadUserDataItemClkResponse) GetTypeName() string {
func (m *_S7PayloadUserDataItemClkResponse) GetLengthInBits(ctx context.Context) uint16 {
lengthInBits := uint16(m.GetParentLengthInBits(ctx))
- // Simple field (Reserved)
+ // Simple field (res)
lengthInBits += 8
- // Simple field (Year1)
+ // Simple field (year1)
lengthInBits += 8
- // Simple field (TimeStamp)
+ // Simple field (timeStamp)
lengthInBits += m.TimeStamp.GetLengthInBits(ctx)
return lengthInBits
@@ -173,31 +173,31 @@ func S7PayloadUserDataItemClkResponseParseWithBuffer(ctx context.Context, readBu
currentPos := positionAware.GetPos()
_ = currentPos
- // Simple Field (Reserved)
- _Reserved, _ReservedErr := readBuffer.ReadUint8("Reserved", 8)
- if _ReservedErr != nil {
- return nil, errors.Wrap(_ReservedErr, "Error parsing 'Reserved' field of S7PayloadUserDataItemClkResponse")
+ // Simple Field (res)
+ _res, _resErr := readBuffer.ReadUint8("res", 8)
+ if _resErr != nil {
+ return nil, errors.Wrap(_resErr, "Error parsing 'res' field of S7PayloadUserDataItemClkResponse")
}
- Reserved := _Reserved
+ res := _res
- // Simple Field (Year1)
- _Year1, _Year1Err := readBuffer.ReadUint8("Year1", 8)
- if _Year1Err != nil {
- return nil, errors.Wrap(_Year1Err, "Error parsing 'Year1' field of S7PayloadUserDataItemClkResponse")
+ // Simple Field (year1)
+ _year1, _year1Err := readBuffer.ReadUint8("year1", 8)
+ if _year1Err != nil {
+ return nil, errors.Wrap(_year1Err, "Error parsing 'year1' field of S7PayloadUserDataItemClkResponse")
}
- Year1 := _Year1
+ year1 := _year1
- // Simple Field (TimeStamp)
- if pullErr := readBuffer.PullContext("TimeStamp"); pullErr != nil {
- return nil, errors.Wrap(pullErr, "Error pulling for TimeStamp")
+ // Simple Field (timeStamp)
+ if pullErr := readBuffer.PullContext("timeStamp"); pullErr != nil {
+ return nil, errors.Wrap(pullErr, "Error pulling for timeStamp")
}
- _TimeStamp, _TimeStampErr := DateAndTimeParseWithBuffer(ctx, readBuffer)
- if _TimeStampErr != nil {
- return nil, errors.Wrap(_TimeStampErr, "Error parsing 'TimeStamp' field of S7PayloadUserDataItemClkResponse")
+ _timeStamp, _timeStampErr := DateAndTimeParseWithBuffer(ctx, readBuffer)
+ if _timeStampErr != nil {
+ return nil, errors.Wrap(_timeStampErr, "Error parsing 'timeStamp' field of S7PayloadUserDataItemClkResponse")
}
- TimeStamp := _TimeStamp.(DateAndTime)
- if closeErr := readBuffer.CloseContext("TimeStamp"); closeErr != nil {
- return nil, errors.Wrap(closeErr, "Error closing for TimeStamp")
+ timeStamp := _timeStamp.(DateAndTime)
+ if closeErr := readBuffer.CloseContext("timeStamp"); closeErr != nil {
+ return nil, errors.Wrap(closeErr, "Error closing for timeStamp")
}
if closeErr := readBuffer.CloseContext("S7PayloadUserDataItemClkResponse"); closeErr != nil {
@@ -207,9 +207,9 @@ func S7PayloadUserDataItemClkResponseParseWithBuffer(ctx context.Context, readBu
// Create a partially initialized instance
_child := &_S7PayloadUserDataItemClkResponse{
_S7PayloadUserDataItem: &_S7PayloadUserDataItem{},
- Reserved: Reserved,
- Year1: Year1,
- TimeStamp: TimeStamp,
+ Res: res,
+ Year1: year1,
+ TimeStamp: timeStamp,
}
_child._S7PayloadUserDataItem._S7PayloadUserDataItemChildRequirements = _child
return _child, nil
@@ -233,30 +233,30 @@ func (m *_S7PayloadUserDataItemClkResponse) SerializeWithWriteBuffer(ctx context
return errors.Wrap(pushErr, "Error pushing for S7PayloadUserDataItemClkResponse")
}
- // Simple Field (Reserved)
- Reserved := uint8(m.GetReserved())
- _ReservedErr := writeBuffer.WriteUint8("Reserved", 8, uint8((Reserved)))
- if _ReservedErr != nil {
- return errors.Wrap(_ReservedErr, "Error serializing 'Reserved' field")
+ // Simple Field (res)
+ res := uint8(m.GetRes())
+ _resErr := writeBuffer.WriteUint8("res", 8, uint8((res)))
+ if _resErr != nil {
+ return errors.Wrap(_resErr, "Error serializing 'res' field")
}
- // Simple Field (Year1)
- Year1 := uint8(m.GetYear1())
- _Year1Err := writeBuffer.WriteUint8("Year1", 8, uint8((Year1)))
- if _Year1Err != nil {
- return errors.Wrap(_Year1Err, "Error serializing 'Year1' field")
+ // Simple Field (year1)
+ year1 := uint8(m.GetYear1())
+ _year1Err := writeBuffer.WriteUint8("year1", 8, uint8((year1)))
+ if _year1Err != nil {
+ return errors.Wrap(_year1Err, "Error serializing 'year1' field")
}
- // Simple Field (TimeStamp)
- if pushErr := writeBuffer.PushContext("TimeStamp"); pushErr != nil {
- return errors.Wrap(pushErr, "Error pushing for TimeStamp")
+ // Simple Field (timeStamp)
+ if pushErr := writeBuffer.PushContext("timeStamp"); pushErr != nil {
+ return errors.Wrap(pushErr, "Error pushing for timeStamp")
}
- _TimeStampErr := writeBuffer.WriteSerializable(ctx, m.GetTimeStamp())
- if popErr := writeBuffer.PopContext("TimeStamp"); popErr != nil {
- return errors.Wrap(popErr, "Error popping for TimeStamp")
+ _timeStampErr := writeBuffer.WriteSerializable(ctx, m.GetTimeStamp())
+ if popErr := writeBuffer.PopContext("timeStamp"); popErr != nil {
+ return errors.Wrap(popErr, "Error popping for timeStamp")
}
- if _TimeStampErr != nil {
- return errors.Wrap(_TimeStampErr, "Error serializing 'TimeStamp' field")
+ if _timeStampErr != nil {
+ return errors.Wrap(_timeStampErr, "Error serializing 'timeStamp' field")
}
if popErr := writeBuffer.PopContext("S7PayloadUserDataItemClkResponse"); popErr != nil {
diff --git a/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkSetRequest.go b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkSetRequest.go
index 74cc05224d..833414a61d 100644
--- a/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkSetRequest.go
+++ b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemClkSetRequest.go
@@ -102,9 +102,9 @@ func (m *_S7PayloadUserDataItemClkSetRequest) GetTimeStamp() DateAndTime {
///////////////////////////////////////////////////////////
// NewS7PayloadUserDataItemClkSetRequest factory function for _S7PayloadUserDataItemClkSetRequest
-func NewS7PayloadUserDataItemClkSetRequest(TimeStamp DateAndTime, returnCode DataTransportErrorCode, transportSize DataTransportSize, dataLength uint16) *_S7PayloadUserDataItemClkSetRequest {
+func NewS7PayloadUserDataItemClkSetRequest(timeStamp DateAndTime, returnCode DataTransportErrorCode, transportSize DataTransportSize, dataLength uint16) *_S7PayloadUserDataItemClkSetRequest {
_result := &_S7PayloadUserDataItemClkSetRequest{
- TimeStamp: TimeStamp,
+ TimeStamp: timeStamp,
_S7PayloadUserDataItem: NewS7PayloadUserDataItem(returnCode, transportSize, dataLength),
}
_result._S7PayloadUserDataItem._S7PayloadUserDataItemChildRequirements = _result
@@ -135,7 +135,7 @@ func (m *_S7PayloadUserDataItemClkSetRequest) GetLengthInBits(ctx context.Contex
// Reserved Field (reserved)
lengthInBits += 8
- // Simple field (TimeStamp)
+ // Simple field (timeStamp)
lengthInBits += m.TimeStamp.GetLengthInBits(ctx)
return lengthInBits
@@ -194,17 +194,17 @@ func S7PayloadUserDataItemClkSetRequestParseWithBuffer(ctx context.Context, read
}
}
- // Simple Field (TimeStamp)
- if pullErr := readBuffer.PullContext("TimeStamp"); pullErr != nil {
- return nil, errors.Wrap(pullErr, "Error pulling for TimeStamp")
+ // Simple Field (timeStamp)
+ if pullErr := readBuffer.PullContext("timeStamp"); pullErr != nil {
+ return nil, errors.Wrap(pullErr, "Error pulling for timeStamp")
}
- _TimeStamp, _TimeStampErr := DateAndTimeParseWithBuffer(ctx, readBuffer)
- if _TimeStampErr != nil {
- return nil, errors.Wrap(_TimeStampErr, "Error parsing 'TimeStamp' field of S7PayloadUserDataItemClkSetRequest")
+ _timeStamp, _timeStampErr := DateAndTimeParseWithBuffer(ctx, readBuffer)
+ if _timeStampErr != nil {
+ return nil, errors.Wrap(_timeStampErr, "Error parsing 'timeStamp' field of S7PayloadUserDataItemClkSetRequest")
}
- TimeStamp := _TimeStamp.(DateAndTime)
- if closeErr := readBuffer.CloseContext("TimeStamp"); closeErr != nil {
- return nil, errors.Wrap(closeErr, "Error closing for TimeStamp")
+ timeStamp := _timeStamp.(DateAndTime)
+ if closeErr := readBuffer.CloseContext("timeStamp"); closeErr != nil {
+ return nil, errors.Wrap(closeErr, "Error closing for timeStamp")
}
if closeErr := readBuffer.CloseContext("S7PayloadUserDataItemClkSetRequest"); closeErr != nil {
@@ -214,7 +214,7 @@ func S7PayloadUserDataItemClkSetRequestParseWithBuffer(ctx context.Context, read
// Create a partially initialized instance
_child := &_S7PayloadUserDataItemClkSetRequest{
_S7PayloadUserDataItem: &_S7PayloadUserDataItem{},
- TimeStamp: TimeStamp,
+ TimeStamp: timeStamp,
reservedField0: reservedField0,
reservedField1: reservedField1,
}
@@ -272,16 +272,16 @@ func (m *_S7PayloadUserDataItemClkSetRequest) SerializeWithWriteBuffer(ctx conte
}
}
- // Simple Field (TimeStamp)
- if pushErr := writeBuffer.PushContext("TimeStamp"); pushErr != nil {
- return errors.Wrap(pushErr, "Error pushing for TimeStamp")
+ // Simple Field (timeStamp)
+ if pushErr := writeBuffer.PushContext("timeStamp"); pushErr != nil {
+ return errors.Wrap(pushErr, "Error pushing for timeStamp")
}
- _TimeStampErr := writeBuffer.WriteSerializable(ctx, m.GetTimeStamp())
- if popErr := writeBuffer.PopContext("TimeStamp"); popErr != nil {
- return errors.Wrap(popErr, "Error popping for TimeStamp")
+ _timeStampErr := writeBuffer.WriteSerializable(ctx, m.GetTimeStamp())
+ if popErr := writeBuffer.PopContext("timeStamp"); popErr != nil {
+ return errors.Wrap(popErr, "Error popping for timeStamp")
}
- if _TimeStampErr != nil {
- return errors.Wrap(_TimeStampErr, "Error serializing 'TimeStamp' field")
+ if _timeStampErr != nil {
+ return errors.Wrap(_timeStampErr, "Error serializing 'timeStamp' field")
}
if popErr := writeBuffer.PopContext("S7PayloadUserDataItemClkSetRequest"); popErr != nil {
diff --git a/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequest.go b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequest.go
index d98ac5d164..7d8cae2cc4 100644
--- a/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequest.go
+++ b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequest.go
@@ -122,12 +122,12 @@ func (m *_S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequest) GetReserve() *
///////////////////////////////////////////////////////////
// NewS7PayloadUserDataItemCpuFunctionMsgSubscriptionRequest factory function for _S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequest
-func NewS7PayloadUserDataItemCpuFunctionMsgSubscriptionRequest(Subscription uint8, magicKey string, Alarmtype *AlarmStateType, Reserve *uint8, returnCode DataTransportErrorCode, transportSize DataTransportSize, dataLength uint16) *_S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequest {
+func NewS7PayloadUserDataItemCpuFunctionMsgSubscriptionRequest(subscription uint8, magicKey string, alarmtype *AlarmStateType, reserve *uint8, returnCode DataTransportErrorCode, transportSize DataTransportSize, dataLength uint16) *_S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequest {
_result := &_S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequest{
- Subscription: Subscription,
+ Subscription: subscription,
MagicKey: magicKey,
- Alarmtype: Alarmtype,
- Reserve: Reserve,
+ Alarmtype: alarmtype,
+ Reserve: reserve,
_S7PayloadUserDataItem: NewS7PayloadUserDataItem(returnCode, transportSize, dataLength),
}
_result._S7PayloadUserDataItem._S7PayloadUserDataItemChildRequirements = _result
@@ -152,7 +152,7 @@ func (m *_S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequest) GetTypeName()
func (m *_S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequest) GetLengthInBits(ctx context.Context) uint16 {
lengthInBits := uint16(m.GetParentLengthInBits(ctx))
- // Simple field (Subscription)
+ // Simple field (subscription)
lengthInBits += 8
// Reserved Field (reserved)
@@ -161,12 +161,12 @@ func (m *_S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequest) GetLengthInBit
// Simple field (magicKey)
lengthInBits += 64
- // Optional Field (Alarmtype)
+ // Optional Field (alarmtype)
if m.Alarmtype != nil {
lengthInBits += 8
}
- // Optional Field (Reserve)
+ // Optional Field (reserve)
if m.Reserve != nil {
lengthInBits += 8
}
@@ -193,12 +193,12 @@ func S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequestParseWithBuffer(ctx c
currentPos := positionAware.GetPos()
_ = currentPos
- // Simple Field (Subscription)
- _Subscription, _SubscriptionErr := readBuffer.ReadUint8("Subscription", 8)
- if _SubscriptionErr != nil {
- return nil, errors.Wrap(_SubscriptionErr, "Error parsing 'Subscription' field of S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequest")
+ // Simple Field (subscription)
+ _subscription, _subscriptionErr := readBuffer.ReadUint8("subscription", 8)
+ if _subscriptionErr != nil {
+ return nil, errors.Wrap(_subscriptionErr, "Error parsing 'subscription' field of S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequest")
}
- Subscription := _Subscription
+ subscription := _subscription
var reservedField0 *uint8
// Reserved Field (Compartmentalized so the "reserved" variable can't leak)
@@ -224,30 +224,30 @@ func S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequestParseWithBuffer(ctx c
}
magicKey := _magicKey
- // Optional Field (Alarmtype) (Can be skipped, if a given expression evaluates to false)
- var Alarmtype *AlarmStateType = nil
- if bool((Subscription) >= (128)) {
- if pullErr := readBuffer.PullContext("Alarmtype"); pullErr != nil {
- return nil, errors.Wrap(pullErr, "Error pulling for Alarmtype")
+ // Optional Field (alarmtype) (Can be skipped, if a given expression evaluates to false)
+ var alarmtype *AlarmStateType = nil
+ if bool((subscription) >= (128)) {
+ if pullErr := readBuffer.PullContext("alarmtype"); pullErr != nil {
+ return nil, errors.Wrap(pullErr, "Error pulling for alarmtype")
}
_val, _err := AlarmStateTypeParseWithBuffer(ctx, readBuffer)
if _err != nil {
- return nil, errors.Wrap(_err, "Error parsing 'Alarmtype' field of S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequest")
+ return nil, errors.Wrap(_err, "Error parsing 'alarmtype' field of S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequest")
}
- Alarmtype = &_val
- if closeErr := readBuffer.CloseContext("Alarmtype"); closeErr != nil {
- return nil, errors.Wrap(closeErr, "Error closing for Alarmtype")
+ alarmtype = &_val
+ if closeErr := readBuffer.CloseContext("alarmtype"); closeErr != nil {
+ return nil, errors.Wrap(closeErr, "Error closing for alarmtype")
}
}
- // Optional Field (Reserve) (Can be skipped, if a given expression evaluates to false)
- var Reserve *uint8 = nil
- if bool((Subscription) >= (128)) {
- _val, _err := readBuffer.ReadUint8("Reserve", 8)
+ // Optional Field (reserve) (Can be skipped, if a given expression evaluates to false)
+ var reserve *uint8 = nil
+ if bool((subscription) >= (128)) {
+ _val, _err := readBuffer.ReadUint8("reserve", 8)
if _err != nil {
- return nil, errors.Wrap(_err, "Error parsing 'Reserve' field of S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequest")
+ return nil, errors.Wrap(_err, "Error parsing 'reserve' field of S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequest")
}
- Reserve = &_val
+ reserve = &_val
}
if closeErr := readBuffer.CloseContext("S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequest"); closeErr != nil {
@@ -257,10 +257,10 @@ func S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequestParseWithBuffer(ctx c
// Create a partially initialized instance
_child := &_S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequest{
_S7PayloadUserDataItem: &_S7PayloadUserDataItem{},
- Subscription: Subscription,
+ Subscription: subscription,
MagicKey: magicKey,
- Alarmtype: Alarmtype,
- Reserve: Reserve,
+ Alarmtype: alarmtype,
+ Reserve: reserve,
reservedField0: reservedField0,
}
_child._S7PayloadUserDataItem._S7PayloadUserDataItemChildRequirements = _child
@@ -285,11 +285,11 @@ func (m *_S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequest) SerializeWithW
return errors.Wrap(pushErr, "Error pushing for S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequest")
}
- // Simple Field (Subscription)
- Subscription := uint8(m.GetSubscription())
- _SubscriptionErr := writeBuffer.WriteUint8("Subscription", 8, uint8((Subscription)))
- if _SubscriptionErr != nil {
- return errors.Wrap(_SubscriptionErr, "Error serializing 'Subscription' field")
+ // Simple Field (subscription)
+ subscription := uint8(m.GetSubscription())
+ _subscriptionErr := writeBuffer.WriteUint8("subscription", 8, uint8((subscription)))
+ if _subscriptionErr != nil {
+ return errors.Wrap(_subscriptionErr, "Error serializing 'subscription' field")
}
// Reserved Field (reserved)
@@ -315,29 +315,29 @@ func (m *_S7PayloadUserDataItemCpuFunctionMsgSubscriptionRequest) SerializeWithW
return errors.Wrap(_magicKeyErr, "Error serializing 'magicKey' field")
}
- // Optional Field (Alarmtype) (Can be skipped, if the value is null)
- var Alarmtype *AlarmStateType = nil
+ // Optional Field (alarmtype) (Can be skipped, if the value is null)
+ var alarmtype *AlarmStateType = nil
if m.GetAlarmtype() != nil {
- if pushErr := writeBuffer.PushContext("Alarmtype"); pushErr != nil {
- return errors.Wrap(pushErr, "Error pushing for Alarmtype")
+ if pushErr := writeBuffer.PushContext("alarmtype"); pushErr != nil {
+ return errors.Wrap(pushErr, "Error pushing for alarmtype")
}
- Alarmtype = m.GetAlarmtype()
- _AlarmtypeErr := writeBuffer.WriteSerializable(ctx, Alarmtype)
- if popErr := writeBuffer.PopContext("Alarmtype"); popErr != nil {
- return errors.Wrap(popErr, "Error popping for Alarmtype")
+ alarmtype = m.GetAlarmtype()
+ _alarmtypeErr := writeBuffer.WriteSerializable(ctx, alarmtype)
+ if popErr := writeBuffer.PopContext("alarmtype"); popErr != nil {
+ return errors.Wrap(popErr, "Error popping for alarmtype")
}
- if _AlarmtypeErr != nil {
- return errors.Wrap(_AlarmtypeErr, "Error serializing 'Alarmtype' field")
+ if _alarmtypeErr != nil {
+ return errors.Wrap(_alarmtypeErr, "Error serializing 'alarmtype' field")
}
}
- // Optional Field (Reserve) (Can be skipped, if the value is null)
- var Reserve *uint8 = nil
+ // Optional Field (reserve) (Can be skipped, if the value is null)
+ var reserve *uint8 = nil
if m.GetReserve() != nil {
- Reserve = m.GetReserve()
- _ReserveErr := writeBuffer.WriteUint8("Reserve", 8, uint8(*(Reserve)))
- if _ReserveErr != nil {
- return errors.Wrap(_ReserveErr, "Error serializing 'Reserve' field")
+ reserve = m.GetReserve()
+ _reserveErr := writeBuffer.WriteUint8("reserve", 8, uint8(*(reserve)))
+ if _reserveErr != nil {
+ return errors.Wrap(_reserveErr, "Error serializing 'reserve' field")
}
}
diff --git a/plc4go/protocols/s7/readwrite/model/TransportSize.go b/plc4go/protocols/s7/readwrite/model/TransportSize.go
index a799544fa9..c2208af40e 100644
--- a/plc4go/protocols/s7/readwrite/model/TransportSize.go
+++ b/plc4go/protocols/s7/readwrite/model/TransportSize.go
@@ -472,7 +472,7 @@ func (e TransportSize) Code() uint8 {
}
case 0x1A:
{ /* '0x1A' */
- return 0x0F
+ return 0x0E
}
case 0x1B:
{ /* '0x1B' */
@@ -598,7 +598,7 @@ func (e TransportSize) SizeInBytes() uint8 {
}
case 0x1A:
{ /* '0x1A' */
- return 12
+ return 8
}
case 0x1B:
{ /* '0x1B' */
diff --git a/plc4j/drivers/ads/src/main/generated/org/apache/plc4x/java/ads/readwrite/DataItem.java b/plc4j/drivers/ads/src/main/generated/org/apache/plc4x/java/ads/readwrite/DataItem.java
index 1b69b1172c..95b5ea3249 100644
--- a/plc4j/drivers/ads/src/main/generated/org/apache/plc4x/java/ads/readwrite/DataItem.java
+++ b/plc4j/drivers/ads/src/main/generated/org/apache/plc4x/java/ads/readwrite/DataItem.java
@@ -18,19 +18,22 @@
*/
package org.apache.plc4x.java.ads.readwrite;
+import static org.apache.plc4x.java.spi.codegen.fields.FieldReaderFactory.*;
+import static org.apache.plc4x.java.spi.codegen.fields.FieldWriterFactory.*;
+import static org.apache.plc4x.java.spi.codegen.io.DataReaderFactory.*;
+import static org.apache.plc4x.java.spi.codegen.io.DataWriterFactory.*;
import static org.apache.plc4x.java.spi.generation.StaticHelper.*;
import java.math.BigInteger;
import java.time.*;
+import java.time.temporal.ChronoField;
import java.util.*;
+import org.apache.plc4x.java.api.exceptions.*;
import org.apache.plc4x.java.api.value.*;
-import org.apache.plc4x.java.spi.codegen.WithOption;
-import org.apache.plc4x.java.spi.generation.ByteOrder;
-import org.apache.plc4x.java.spi.generation.EvaluationHelper;
-import org.apache.plc4x.java.spi.generation.ParseException;
-import org.apache.plc4x.java.spi.generation.ReadBuffer;
-import org.apache.plc4x.java.spi.generation.SerializationException;
-import org.apache.plc4x.java.spi.generation.WriteBuffer;
+import org.apache.plc4x.java.spi.codegen.*;
+import org.apache.plc4x.java.spi.codegen.fields.*;
+import org.apache.plc4x.java.spi.codegen.io.*;
+import org.apache.plc4x.java.spi.generation.*;
import org.apache.plc4x.java.spi.values.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -45,490 +48,380 @@ public class DataItem {
ReadBuffer readBuffer, PlcValueType plcValueType, Integer stringLength)
throws ParseException {
if (EvaluationHelper.equals(plcValueType, PlcValueType.BOOL)) { // BOOL
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 7), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 7);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Boolean value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
+ boolean value = readSimpleField("value", readBoolean(readBuffer));
return new PlcBOOL(value);
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.BYTE)) { // BYTE
-
- // Simple Field (value)
- Short value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedShort("", 8);
-
+ short value = readSimpleField("value", readUnsignedShort(readBuffer, 8));
return new PlcBYTE(value);
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.WORD)) { // WORD
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedInt("", 16);
-
+ int value = readSimpleField("value", readUnsignedInt(readBuffer, 16));
return new PlcWORD(value);
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.DWORD)) { // DWORD
-
- // Simple Field (value)
- Long value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedLong("", 32);
-
+ long value = readSimpleField("value", readUnsignedLong(readBuffer, 32));
return new PlcDWORD(value);
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.LWORD)) { // LWORD
-
- // Simple Field (value)
- BigInteger value = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedBigInteger("", 64);
-
+ BigInteger value = readSimpleField("value", readUnsignedBigInteger(readBuffer, 64));
return new PlcLWORD(value);
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.SINT)) { // SINT
-
- // Simple Field (value)
- Byte value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readSignedByte("", 8);
-
+ byte value = readSimpleField("value", readSignedByte(readBuffer, 8));
return new PlcSINT(value);
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.USINT)) { // USINT
-
- // Simple Field (value)
- Short value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedShort("", 8);
-
+ short value = readSimpleField("value", readUnsignedShort(readBuffer, 8));
return new PlcUSINT(value);
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.INT)) { // INT
-
- // Simple Field (value)
- Short value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readShort("", 16);
-
+ short value = readSimpleField("value", readSignedShort(readBuffer, 16));
return new PlcINT(value);
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.UINT)) { // UINT
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedInt("", 16);
-
+ int value = readSimpleField("value", readUnsignedInt(readBuffer, 16));
return new PlcUINT(value);
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.DINT)) { // DINT
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readInt("", 32);
-
+ int value = readSimpleField("value", readSignedInt(readBuffer, 32));
return new PlcDINT(value);
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.UDINT)) { // UDINT
-
- // Simple Field (value)
- Long value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedLong("", 32);
-
+ long value = readSimpleField("value", readUnsignedLong(readBuffer, 32));
return new PlcUDINT(value);
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.LINT)) { // LINT
-
- // Simple Field (value)
- Long value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readLong("", 64);
-
+ long value = readSimpleField("value", readSignedLong(readBuffer, 64));
return new PlcLINT(value);
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.ULINT)) { // ULINT
-
- // Simple Field (value)
- BigInteger value = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedBigInteger("", 64);
-
+ BigInteger value = readSimpleField("value", readUnsignedBigInteger(readBuffer, 64));
return new PlcULINT(value);
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.REAL)) { // REAL
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.LREAL)) { // LREAL
-
- // Simple Field (value)
- Double value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readDouble("", 64);
-
+ double value = readSimpleField("value", readDouble(readBuffer, 64));
return new PlcLREAL(value);
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.CHAR)) { // CHAR
-
- // Simple Field (value)
- String value = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readString("", 8, WithOption.WithEncoding("Windows-1252"));
-
+ String value =
+ readSimpleField(
+ "value", readString(readBuffer, 8), WithOption.WithEncoding("Windows-1252"));
return new PlcCHAR(value);
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.WCHAR)) { // WCHAR
-
- // Simple Field (value)
- String value = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readString("", 16, WithOption.WithEncoding("UTF-16LE"));
-
+ String value =
+ readSimpleField("value", readString(readBuffer, 16), WithOption.WithEncoding("UTF-16LE"));
return new PlcWCHAR(value);
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.STRING)) { // STRING
-
- // Simple Field (value)
- String value = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readString("", (stringLength) * (8), WithOption.WithEncoding("Windows-1252"));
-
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
+ String value =
+ readSimpleField(
+ "value",
+ readString(readBuffer, (stringLength) * (8)),
+ WithOption.WithEncoding("Windows-1252"));
+
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
return new PlcSTRING(value);
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.WSTRING)) { // WSTRING
-
- // Simple Field (value)
- String value = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readString(
- "", ((stringLength) * (8)) * (2), WithOption.WithEncoding("UTF-16LE"));
-
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- int reserved = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedInt("", 16);
- if (reserved != (int) 0x0000) {
- LOGGER.info(
- "Expected constant value "
- + 0x0000
- + " but got "
- + reserved
- + " for reserved field.");
- }
- }
-
+ String value =
+ readSimpleField(
+ "value",
+ readString(readBuffer, ((stringLength) * (8)) * (2)),
+ WithOption.WithEncoding("UTF-16LE"));
+
+ Integer reservedField0 =
+ readReservedField("reserved", readUnsignedInt(readBuffer, 16), (int) 0x0000);
return new PlcWSTRING(value);
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.TIME)) { // TIME
-
- // Simple Field (milliseconds)
- Long milliseconds = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedLong("", 32);
-
+ long milliseconds = readSimpleField("milliseconds", readUnsignedLong(readBuffer, 32));
return PlcTIME.ofMilliseconds(milliseconds);
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.LTIME)) { // LTIME
-
- // Simple Field (nanoseconds)
- BigInteger nanoseconds = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedBigInteger("", 64);
-
+ BigInteger nanoseconds =
+ readSimpleField("nanoseconds", readUnsignedBigInteger(readBuffer, 64));
return PlcLTIME.ofNanoseconds(nanoseconds);
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.DATE)) { // DATE
-
- // Simple Field (secondsSinceEpoch)
- Long secondsSinceEpoch = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedLong("", 32);
-
+ long secondsSinceEpoch =
+ readSimpleField("secondsSinceEpoch", readUnsignedLong(readBuffer, 32));
return PlcDATE.ofSecondsSinceEpoch(secondsSinceEpoch);
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.LDATE)) { // LDATE
-
- // Simple Field (nanosecondsSinceEpoch)
- BigInteger nanosecondsSinceEpoch = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedBigInteger("", 64);
-
+ BigInteger nanosecondsSinceEpoch =
+ readSimpleField("nanosecondsSinceEpoch", readUnsignedBigInteger(readBuffer, 64));
return PlcLDATE.ofNanosecondsSinceEpoch(nanosecondsSinceEpoch);
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.TIME_OF_DAY)) { // TIME_OF_DAY
-
- // Simple Field (millisecondsSinceMidnight)
- Long millisecondsSinceMidnight = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedLong("", 32);
-
+ long millisecondsSinceMidnight =
+ readSimpleField("millisecondsSinceMidnight", readUnsignedLong(readBuffer, 32));
return PlcTIME_OF_DAY.ofMillisecondsSinceMidnight(millisecondsSinceMidnight);
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.LTIME_OF_DAY)) { // LTIME_OF_DAY
-
- // Simple Field (nanosecondsSinceMidnight)
- BigInteger nanosecondsSinceMidnight = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedBigInteger("", 64);
-
+ BigInteger nanosecondsSinceMidnight =
+ readSimpleField("nanosecondsSinceMidnight", readUnsignedBigInteger(readBuffer, 64));
return PlcLTIME_OF_DAY.ofNanosecondsSinceMidnight(nanosecondsSinceMidnight);
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.DATE_AND_TIME)) { // DATE_AND_TIME
-
- // Simple Field (secondsSinceEpoch)
- Long secondsSinceEpoch = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedLong("", 32);
-
+ long secondsSinceEpoch =
+ readSimpleField("secondsSinceEpoch", readUnsignedLong(readBuffer, 32));
return PlcDATE_AND_TIME.ofSecondsSinceEpoch(secondsSinceEpoch);
} else if (EvaluationHelper.equals(
plcValueType, PlcValueType.LDATE_AND_TIME)) { // LDATE_AND_TIME
-
- // Simple Field (nanosecondsSinceEpoch)
- BigInteger nanosecondsSinceEpoch = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedBigInteger("", 64);
-
+ BigInteger nanosecondsSinceEpoch =
+ readSimpleField("nanosecondsSinceEpoch", readUnsignedBigInteger(readBuffer, 64));
return PlcLDATE_AND_TIME.ofNanosecondsSinceEpoch(nanosecondsSinceEpoch);
}
return null;
}
- public static void staticSerialize(
- WriteBuffer writeBuffer, PlcValue _value, PlcValueType plcValueType, Integer stringLength)
- throws SerializationException {
- staticSerialize(writeBuffer, _value, plcValueType, stringLength, ByteOrder.BIG_ENDIAN);
+ public static int getLengthInBytes(
+ PlcValue _value, PlcValueType plcValueType, Integer stringLength) {
+ return (int) Math.ceil((float) getLengthInBits(_value, plcValueType, stringLength) / 8.0);
}
- public static void staticSerialize(
- WriteBuffer writeBuffer,
- PlcValue _value,
- PlcValueType plcValueType,
- Integer stringLength,
- ByteOrder byteOrder)
- throws SerializationException {
+ public static int getLengthInBits(
+ PlcValue _value, PlcValueType plcValueType, Integer stringLength) {
+ int lengthInBits = 0;
if (EvaluationHelper.equals(plcValueType, PlcValueType.BOOL)) { // BOOL
- // Reserved Field
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedByte("", 7, ((Number) (byte) 0x00).byteValue());
- // Simple Field (value)
- boolean value = (boolean) _value.getBoolean();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeBit("", (boolean) (value));
+ // Reserved Field (reserved)
+ lengthInBits += 7;
+
+ // Simple field (value)
+ lengthInBits += 1;
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.BYTE)) { // BYTE
- // Simple Field (value)
- short value = (short) _value.getShort();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedShort("", 8, ((Number) (value)).shortValue());
+ // Simple field (value)
+ lengthInBits += 8;
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.WORD)) { // WORD
- // Simple Field (value)
- int value = (int) _value.getInt();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedInt("", 16, ((Number) (value)).intValue());
+ // Simple field (value)
+ lengthInBits += 16;
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.DWORD)) { // DWORD
- // Simple Field (value)
- long value = (long) _value.getLong();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedLong("", 32, ((Number) (value)).longValue());
+ // Simple field (value)
+ lengthInBits += 32;
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.LWORD)) { // LWORD
- // Simple Field (value)
- BigInteger value = (BigInteger) _value.getBigInteger();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedBigInteger("", 64, (BigInteger) (value));
+ // Simple field (value)
+ lengthInBits += 64;
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.SINT)) { // SINT
- // Simple Field (value)
- byte value = (byte) _value.getByte();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeSignedByte("", 8, ((Number) (value)).byteValue());
+ // Simple field (value)
+ lengthInBits += 8;
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.USINT)) { // USINT
- // Simple Field (value)
- short value = (short) _value.getShort();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedShort("", 8, ((Number) (value)).shortValue());
+ // Simple field (value)
+ lengthInBits += 8;
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.INT)) { // INT
- // Simple Field (value)
- short value = (short) _value.getShort();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeShort("", 16, ((Number) (value)).shortValue());
+ // Simple field (value)
+ lengthInBits += 16;
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.UINT)) { // UINT
- // Simple Field (value)
- int value = (int) _value.getInt();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedInt("", 16, ((Number) (value)).intValue());
+ // Simple field (value)
+ lengthInBits += 16;
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.DINT)) { // DINT
- // Simple Field (value)
- int value = (int) _value.getInt();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeInt("", 32, ((Number) (value)).intValue());
+ // Simple field (value)
+ lengthInBits += 32;
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.UDINT)) { // UDINT
- // Simple Field (value)
- long value = (long) _value.getLong();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedLong("", 32, ((Number) (value)).longValue());
+ // Simple field (value)
+ lengthInBits += 32;
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.LINT)) { // LINT
- // Simple Field (value)
- long value = (long) _value.getLong();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeLong("", 64, ((Number) (value)).longValue());
+ // Simple field (value)
+ lengthInBits += 64;
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.ULINT)) { // ULINT
- // Simple Field (value)
- BigInteger value = (BigInteger) _value.getBigInteger();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedBigInteger("", 64, (BigInteger) (value));
+ // Simple field (value)
+ lengthInBits += 64;
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.REAL)) { // REAL
- // Simple Field (value)
- float value = (float) _value.getFloat();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeFloat("", 32, (value));
+ // Simple field (value)
+ lengthInBits += 32;
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.LREAL)) { // LREAL
- // Simple Field (value)
- double value = (double) _value.getDouble();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeDouble("", 64, (value));
+ // Simple field (value)
+ lengthInBits += 64;
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.CHAR)) { // CHAR
- // Simple Field (value)
- String value = (String) _value.getString();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeString(
- "", 8, (String) (value), WithOption.WithEncoding("Windows-1252"));
+ // Simple field (value)
+ lengthInBits += 8;
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.WCHAR)) { // WCHAR
- // Simple Field (value)
- String value = (String) _value.getString();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeString(
- "", 16, (String) (value), WithOption.WithEncoding("UTF-16LE"));
+ // Simple field (value)
+ lengthInBits += 16;
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.STRING)) { // STRING
- // Simple Field (value)
- String value = (String) _value.getString();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeString(
- "", (stringLength) * (8), (String) (value), WithOption.WithEncoding("Windows-1252"));
- // Reserved Field
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedShort(
- "", 8, ((Number) (short) 0x00).shortValue());
+ // Simple field (value)
+ lengthInBits += (stringLength) * (8);
+
+ // Reserved Field (reserved)
+ lengthInBits += 8;
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.WSTRING)) { // WSTRING
- // Simple Field (value)
- String value = (String) _value.getString();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeString(
- "", ((stringLength) * (8)) * (2), (String) (value), WithOption.WithEncoding("UTF-16LE"));
- // Reserved Field
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedInt("", 16, ((Number) (int) 0x0000).intValue());
+ // Simple field (value)
+ lengthInBits += ((stringLength) * (8)) * (2);
+
+ // Reserved Field (reserved)
+ lengthInBits += 16;
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.TIME)) { // TIME
- // Simple Field (milliseconds)
- long milliseconds = (long) _value.getLong();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedLong(
- "", 32, ((Number) (milliseconds)).longValue());
+ // Simple field (milliseconds)
+ lengthInBits += 32;
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.LTIME)) { // LTIME
- // Simple Field (nanoseconds)
- BigInteger nanoseconds = (BigInteger) _value.getBigInteger();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedBigInteger("", 64, (BigInteger) (nanoseconds));
+ // Simple field (nanoseconds)
+ lengthInBits += 64;
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.DATE)) { // DATE
- // Simple Field (secondsSinceEpoch)
- long secondsSinceEpoch = (long) _value.getLong();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedLong(
- "", 32, ((Number) (secondsSinceEpoch)).longValue());
+ // Simple field (secondsSinceEpoch)
+ lengthInBits += 32;
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.LDATE)) { // LDATE
- // Simple Field (nanosecondsSinceEpoch)
- BigInteger nanosecondsSinceEpoch = (BigInteger) _value.getBigInteger();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedBigInteger(
- "", 64, (BigInteger) (nanosecondsSinceEpoch));
+ // Simple field (nanosecondsSinceEpoch)
+ lengthInBits += 64;
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.TIME_OF_DAY)) { // TIME_OF_DAY
- // Simple Field (millisecondsSinceMidnight)
- long millisecondsSinceMidnight = (long) _value.getLong();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedLong(
- "", 32, ((Number) (millisecondsSinceMidnight)).longValue());
+ // Simple field (millisecondsSinceMidnight)
+ lengthInBits += 32;
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.LTIME_OF_DAY)) { // LTIME_OF_DAY
- // Simple Field (nanosecondsSinceMidnight)
- BigInteger nanosecondsSinceMidnight = (BigInteger) _value.getBigInteger();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedBigInteger(
- "", 64, (BigInteger) (nanosecondsSinceMidnight));
+ // Simple field (nanosecondsSinceMidnight)
+ lengthInBits += 64;
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.DATE_AND_TIME)) { // DATE_AND_TIME
- // Simple Field (secondsSinceEpoch)
- long secondsSinceEpoch = (long) _value.getLong();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedLong(
- "", 32, ((Number) (secondsSinceEpoch)).longValue());
+ // Simple field (secondsSinceEpoch)
+ lengthInBits += 32;
} else if (EvaluationHelper.equals(
plcValueType, PlcValueType.LDATE_AND_TIME)) { // LDATE_AND_TIME
- // Simple Field (nanosecondsSinceEpoch)
- BigInteger nanosecondsSinceEpoch = (BigInteger) _value.getBigInteger();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedBigInteger(
- "", 64, (BigInteger) (nanosecondsSinceEpoch));
+ // Simple field (nanosecondsSinceEpoch)
+ lengthInBits += 64;
}
+
+ return lengthInBits;
}
- public static int getLengthInBytes(
- PlcValue _value, PlcValueType plcValueType, Integer stringLength) {
- return (int) Math.ceil((float) getLengthInBits(_value, plcValueType, stringLength) / 8.0);
+ public static void staticSerialize(
+ WriteBuffer writeBuffer, PlcValue _value, PlcValueType plcValueType, Integer stringLength)
+ throws SerializationException {
+ staticSerialize(writeBuffer, _value, plcValueType, stringLength, ByteOrder.BIG_ENDIAN);
}
- public static int getLengthInBits(
- PlcValue _value, PlcValueType plcValueType, Integer stringLength) {
- int sizeInBits = 0;
+ public static void staticSerialize(
+ WriteBuffer writeBuffer,
+ PlcValue _value,
+ PlcValueType plcValueType,
+ Integer stringLength,
+ ByteOrder byteOrder)
+ throws SerializationException {
if (EvaluationHelper.equals(plcValueType, PlcValueType.BOOL)) { // BOOL
- // Reserved Field
- sizeInBits += 7;
+ // Reserved Field (reserved)
+ writeReservedField("reserved", (byte) 0x00, writeUnsignedByte(writeBuffer, 7));
+
// Simple Field (value)
- sizeInBits += 1;
+ writeSimpleField("value", (boolean) _value.getBoolean(), writeBoolean(writeBuffer));
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.BYTE)) { // BYTE
// Simple Field (value)
- sizeInBits += 8;
+ writeSimpleField("value", (short) _value.getShort(), writeUnsignedShort(writeBuffer, 8));
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.WORD)) { // WORD
// Simple Field (value)
- sizeInBits += 16;
+ writeSimpleField("value", (int) _value.getInteger(), writeUnsignedInt(writeBuffer, 16));
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.DWORD)) { // DWORD
// Simple Field (value)
- sizeInBits += 32;
+ writeSimpleField("value", (long) _value.getLong(), writeUnsignedLong(writeBuffer, 32));
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.LWORD)) { // LWORD
// Simple Field (value)
- sizeInBits += 64;
+ writeSimpleField(
+ "value", (BigInteger) _value.getBigInteger(), writeUnsignedBigInteger(writeBuffer, 64));
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.SINT)) { // SINT
// Simple Field (value)
- sizeInBits += 8;
+ writeSimpleField("value", (byte) _value.getByte(), writeSignedByte(writeBuffer, 8));
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.USINT)) { // USINT
// Simple Field (value)
- sizeInBits += 8;
+ writeSimpleField("value", (short) _value.getShort(), writeUnsignedShort(writeBuffer, 8));
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.INT)) { // INT
// Simple Field (value)
- sizeInBits += 16;
+ writeSimpleField("value", (short) _value.getShort(), writeSignedShort(writeBuffer, 16));
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.UINT)) { // UINT
// Simple Field (value)
- sizeInBits += 16;
+ writeSimpleField("value", (int) _value.getInteger(), writeUnsignedInt(writeBuffer, 16));
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.DINT)) { // DINT
// Simple Field (value)
- sizeInBits += 32;
+ writeSimpleField("value", (int) _value.getInteger(), writeSignedInt(writeBuffer, 32));
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.UDINT)) { // UDINT
// Simple Field (value)
- sizeInBits += 32;
+ writeSimpleField("value", (long) _value.getLong(), writeUnsignedLong(writeBuffer, 32));
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.LINT)) { // LINT
// Simple Field (value)
- sizeInBits += 64;
+ writeSimpleField("value", (long) _value.getLong(), writeSignedLong(writeBuffer, 64));
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.ULINT)) { // ULINT
// Simple Field (value)
- sizeInBits += 64;
+ writeSimpleField(
+ "value", (BigInteger) _value.getBigInteger(), writeUnsignedBigInteger(writeBuffer, 64));
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.REAL)) { // REAL
// Simple Field (value)
- sizeInBits += 32;
+ writeSimpleField("value", (float) _value.getFloat(), writeFloat(writeBuffer, 32));
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.LREAL)) { // LREAL
// Simple Field (value)
- sizeInBits += 64;
+ writeSimpleField("value", (double) _value.getDouble(), writeDouble(writeBuffer, 64));
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.CHAR)) { // CHAR
// Simple Field (value)
- sizeInBits += 8;
+ writeSimpleField(
+ "value",
+ (String) _value.getString(),
+ writeString(writeBuffer, 8),
+ WithOption.WithEncoding("Windows-1252"));
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.WCHAR)) { // WCHAR
// Simple Field (value)
- sizeInBits += 16;
+ writeSimpleField(
+ "value",
+ (String) _value.getString(),
+ writeString(writeBuffer, 16),
+ WithOption.WithEncoding("UTF-16LE"));
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.STRING)) { // STRING
// Simple Field (value)
- sizeInBits += -1;
- // Reserved Field
- sizeInBits += 8;
+ writeSimpleField(
+ "value",
+ (String) _value.getString(),
+ writeString(writeBuffer, (stringLength) * (8)),
+ WithOption.WithEncoding("Windows-1252"));
+
+ // Reserved Field (reserved)
+ writeReservedField("reserved", (short) 0x00, writeUnsignedShort(writeBuffer, 8));
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.WSTRING)) { // WSTRING
// Simple Field (value)
- sizeInBits += -1;
- // Reserved Field
- sizeInBits += 16;
+ writeSimpleField(
+ "value",
+ (String) _value.getString(),
+ writeString(writeBuffer, ((stringLength) * (8)) * (2)),
+ WithOption.WithEncoding("UTF-16LE"));
+
+ // Reserved Field (reserved)
+ writeReservedField("reserved", (int) 0x0000, writeUnsignedInt(writeBuffer, 16));
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.TIME)) { // TIME
// Simple Field (milliseconds)
- sizeInBits += 32;
+ writeSimpleField(
+ "milliseconds",
+ (long) _value.getDuration().toMillis(),
+ writeUnsignedLong(writeBuffer, 32));
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.LTIME)) { // LTIME
// Simple Field (nanoseconds)
- sizeInBits += 64;
+ writeSimpleField(
+ "nanoseconds",
+ (BigInteger) BigInteger.valueOf(_value.getDuration().toNanos()),
+ writeUnsignedBigInteger(writeBuffer, 64));
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.DATE)) { // DATE
// Simple Field (secondsSinceEpoch)
- sizeInBits += 32;
+ writeSimpleField(
+ "secondsSinceEpoch",
+ (long) _value.getDateTime().toEpochSecond(OffsetDateTime.now().getOffset()),
+ writeUnsignedLong(writeBuffer, 32));
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.LDATE)) { // LDATE
// Simple Field (nanosecondsSinceEpoch)
- sizeInBits += 64;
+ writeSimpleField(
+ "nanosecondsSinceEpoch",
+ (BigInteger)
+ BigInteger.valueOf(
+ _value
+ .getDateTime()
+ .toEpochSecond(ZoneOffset.of(ZoneId.systemDefault().getId())))
+ .multiply(BigInteger.valueOf(1000000000))
+ .add(BigInteger.valueOf(_value.getDateTime().getNano())),
+ writeUnsignedBigInteger(writeBuffer, 64));
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.TIME_OF_DAY)) { // TIME_OF_DAY
// Simple Field (millisecondsSinceMidnight)
- sizeInBits += 32;
+ writeSimpleField(
+ "millisecondsSinceMidnight",
+ (long) _value.getTime().getLong(ChronoField.MILLI_OF_DAY),
+ writeUnsignedLong(writeBuffer, 32));
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.LTIME_OF_DAY)) { // LTIME_OF_DAY
// Simple Field (nanosecondsSinceMidnight)
- sizeInBits += 64;
+ writeSimpleField(
+ "nanosecondsSinceMidnight",
+ (BigInteger) BigInteger.valueOf(_value.getTime().getLong(ChronoField.NANO_OF_DAY)),
+ writeUnsignedBigInteger(writeBuffer, 64));
} else if (EvaluationHelper.equals(plcValueType, PlcValueType.DATE_AND_TIME)) { // DATE_AND_TIME
// Simple Field (secondsSinceEpoch)
- sizeInBits += 32;
+ writeSimpleField(
+ "secondsSinceEpoch",
+ (long) _value.getDateTime().toEpochSecond(OffsetDateTime.now().getOffset()),
+ writeUnsignedLong(writeBuffer, 32));
} else if (EvaluationHelper.equals(
plcValueType, PlcValueType.LDATE_AND_TIME)) { // LDATE_AND_TIME
// Simple Field (nanosecondsSinceEpoch)
- sizeInBits += 64;
+ writeSimpleField(
+ "nanosecondsSinceEpoch",
+ (BigInteger)
+ BigInteger.valueOf(
+ _value
+ .getDateTime()
+ .toEpochSecond(ZoneOffset.of(ZoneId.systemDefault().getId())))
+ .multiply(BigInteger.valueOf(1000000000))
+ .add(BigInteger.valueOf(_value.getDateTime().getNano())),
+ writeUnsignedBigInteger(writeBuffer, 64));
}
- return sizeInBits;
}
}
diff --git a/plc4j/drivers/can/src/main/generated/org/apache/plc4x/java/genericcan/readwrite/DataItem.java b/plc4j/drivers/can/src/main/generated/org/apache/plc4x/java/genericcan/readwrite/DataItem.java
index cca0596d5b..dd8315b8c3 100644
--- a/plc4j/drivers/can/src/main/generated/org/apache/plc4x/java/genericcan/readwrite/DataItem.java
+++ b/plc4j/drivers/can/src/main/generated/org/apache/plc4x/java/genericcan/readwrite/DataItem.java
@@ -18,18 +18,21 @@
*/
package org.apache.plc4x.java.genericcan.readwrite;
+import static org.apache.plc4x.java.spi.codegen.fields.FieldReaderFactory.*;
+import static org.apache.plc4x.java.spi.codegen.fields.FieldWriterFactory.*;
+import static org.apache.plc4x.java.spi.codegen.io.DataReaderFactory.*;
+import static org.apache.plc4x.java.spi.codegen.io.DataWriterFactory.*;
import static org.apache.plc4x.java.spi.generation.StaticHelper.*;
import java.math.BigInteger;
import java.time.*;
import java.util.*;
+import org.apache.plc4x.java.api.exceptions.*;
import org.apache.plc4x.java.api.value.*;
-import org.apache.plc4x.java.spi.generation.ByteOrder;
-import org.apache.plc4x.java.spi.generation.EvaluationHelper;
-import org.apache.plc4x.java.spi.generation.ParseException;
-import org.apache.plc4x.java.spi.generation.ReadBuffer;
-import org.apache.plc4x.java.spi.generation.SerializationException;
-import org.apache.plc4x.java.spi.generation.WriteBuffer;
+import org.apache.plc4x.java.spi.codegen.*;
+import org.apache.plc4x.java.spi.codegen.fields.*;
+import org.apache.plc4x.java.spi.codegen.io.*;
+import org.apache.plc4x.java.spi.generation.*;
import org.apache.plc4x.java.spi.values.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -43,309 +46,365 @@ public class DataItem {
public static PlcValue staticParse(ReadBuffer readBuffer, GenericCANDataType dataType)
throws ParseException {
if (EvaluationHelper.equals(dataType, GenericCANDataType.BYTE)) { // BYTE
-
- // Simple Field (value)
- Byte value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readByte("");
-
+ byte value =
+ readSimpleField(
+ "value", readByte(readBuffer, 8), WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
return new PlcBYTE(value);
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.BOOLEAN)) { // BOOL
-
- // Simple Field (value)
- Boolean value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
+ boolean value =
+ readSimpleField(
+ "value", readBoolean(readBuffer), WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
return new PlcBOOL(value);
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.UNSIGNED8)) { // USINT
-
- // Simple Field (value)
- Short value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedShort("", 8);
-
+ short value =
+ readSimpleField(
+ "value",
+ readUnsignedShort(readBuffer, 8),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
return new PlcUSINT(value);
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.UNSIGNED16)) { // UINT
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedInt("", 16);
-
+ int value =
+ readSimpleField(
+ "value",
+ readUnsignedInt(readBuffer, 16),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
return new PlcUINT(value);
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.UNSIGNED24)) { // UDINT
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedInt("", 24);
-
+ int value =
+ readSimpleField(
+ "value",
+ readUnsignedInt(readBuffer, 24),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
return new PlcUDINT(value);
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.UNSIGNED32)) { // UDINT
-
- // Simple Field (value)
- Long value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedLong("", 32);
-
+ long value =
+ readSimpleField(
+ "value",
+ readUnsignedLong(readBuffer, 32),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
return new PlcUDINT(value);
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.UNSIGNED40)) { // ULINT
-
- // Simple Field (value)
- Long value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedLong("", 40);
-
+ long value =
+ readSimpleField(
+ "value",
+ readUnsignedLong(readBuffer, 40),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
return new PlcULINT(value);
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.UNSIGNED48)) { // ULINT
-
- // Simple Field (value)
- Long value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedLong("", 48);
-
+ long value =
+ readSimpleField(
+ "value",
+ readUnsignedLong(readBuffer, 48),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
return new PlcULINT(value);
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.UNSIGNED56)) { // ULINT
-
- // Simple Field (value)
- Long value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedLong("", 56);
-
+ long value =
+ readSimpleField(
+ "value",
+ readUnsignedLong(readBuffer, 56),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
return new PlcULINT(value);
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.UNSIGNED64)) { // ULINT
-
- // Simple Field (value)
- BigInteger value = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedBigInteger("", 64);
-
+ BigInteger value =
+ readSimpleField(
+ "value",
+ readUnsignedBigInteger(readBuffer, 64),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
return new PlcULINT(value);
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.INTEGER8)) { // SINT
-
- // Simple Field (value)
- Byte value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readSignedByte("", 8);
-
+ byte value =
+ readSimpleField(
+ "value",
+ readSignedByte(readBuffer, 8),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
return new PlcSINT(value);
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.INTEGER16)) { // INT
-
- // Simple Field (value)
- Short value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readShort("", 16);
-
+ short value =
+ readSimpleField(
+ "value",
+ readSignedShort(readBuffer, 16),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
return new PlcINT(value);
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.INTEGER24)) { // DINT
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readInt("", 24);
-
+ int value =
+ readSimpleField(
+ "value",
+ readSignedInt(readBuffer, 24),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
return new PlcDINT(value);
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.INTEGER32)) { // DINT
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readInt("", 32);
-
+ int value =
+ readSimpleField(
+ "value",
+ readSignedInt(readBuffer, 32),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
return new PlcDINT(value);
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.INTEGER40)) { // LINT
-
- // Simple Field (value)
- Long value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readLong("", 40);
-
+ long value =
+ readSimpleField(
+ "value",
+ readSignedLong(readBuffer, 40),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
return new PlcLINT(value);
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.INTEGER48)) { // LINT
-
- // Simple Field (value)
- Long value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readLong("", 48);
-
+ long value =
+ readSimpleField(
+ "value",
+ readSignedLong(readBuffer, 48),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
return new PlcLINT(value);
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.INTEGER56)) { // LINT
-
- // Simple Field (value)
- Long value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readLong("", 56);
-
+ long value =
+ readSimpleField(
+ "value",
+ readSignedLong(readBuffer, 56),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
return new PlcLINT(value);
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.INTEGER64)) { // LINT
-
- // Simple Field (value)
- Long value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readLong("", 64);
-
+ long value =
+ readSimpleField(
+ "value",
+ readSignedLong(readBuffer, 64),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
return new PlcLINT(value);
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.REAL32)) { // REAL
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value =
+ readSimpleField(
+ "value",
+ readFloat(readBuffer, 32),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.REAL64)) { // LREAL
-
- // Simple Field (value)
- Double value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readDouble("", 64);
-
+ double value =
+ readSimpleField(
+ "value",
+ readDouble(readBuffer, 64),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
return new PlcLREAL(value);
}
return null;
}
- public static void staticSerialize(
- WriteBuffer writeBuffer, PlcValue _value, GenericCANDataType dataType)
- throws SerializationException {
- staticSerialize(writeBuffer, _value, dataType, ByteOrder.BIG_ENDIAN);
+ public static int getLengthInBytes(PlcValue _value, GenericCANDataType dataType) {
+ return (int) Math.ceil((float) getLengthInBits(_value, dataType) / 8.0);
}
- public static void staticSerialize(
- WriteBuffer writeBuffer, PlcValue _value, GenericCANDataType dataType, ByteOrder byteOrder)
- throws SerializationException {
+ public static int getLengthInBits(PlcValue _value, GenericCANDataType dataType) {
+ int lengthInBits = 0;
if (EvaluationHelper.equals(dataType, GenericCANDataType.BYTE)) { // BYTE
- // Simple Field (value)
- byte value = (byte) _value.getByte();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeByte("", ((Number) (value)).byteValue());
+ // Simple field (value)
+ lengthInBits += 8;
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.BOOLEAN)) { // BOOL
- // Simple Field (value)
- boolean value = (boolean) _value.getBoolean();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeBit("", (boolean) (value));
+ // Simple field (value)
+ lengthInBits += 1;
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.UNSIGNED8)) { // USINT
- // Simple Field (value)
- short value = (short) _value.getShort();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedShort("", 8, ((Number) (value)).shortValue());
+ // Simple field (value)
+ lengthInBits += 8;
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.UNSIGNED16)) { // UINT
- // Simple Field (value)
- int value = (int) _value.getInt();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedInt("", 16, ((Number) (value)).intValue());
+ // Simple field (value)
+ lengthInBits += 16;
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.UNSIGNED24)) { // UDINT
- // Simple Field (value)
- int value = (int) _value.getInt();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedInt("", 24, ((Number) (value)).intValue());
+ // Simple field (value)
+ lengthInBits += 24;
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.UNSIGNED32)) { // UDINT
- // Simple Field (value)
- long value = (long) _value.getLong();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedLong("", 32, ((Number) (value)).longValue());
+ // Simple field (value)
+ lengthInBits += 32;
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.UNSIGNED40)) { // ULINT
- // Simple Field (value)
- long value = (long) _value.getLong();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedLong("", 40, ((Number) (value)).longValue());
+ // Simple field (value)
+ lengthInBits += 40;
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.UNSIGNED48)) { // ULINT
- // Simple Field (value)
- long value = (long) _value.getLong();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedLong("", 48, ((Number) (value)).longValue());
+ // Simple field (value)
+ lengthInBits += 48;
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.UNSIGNED56)) { // ULINT
- // Simple Field (value)
- long value = (long) _value.getLong();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedLong("", 56, ((Number) (value)).longValue());
+ // Simple field (value)
+ lengthInBits += 56;
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.UNSIGNED64)) { // ULINT
- // Simple Field (value)
- BigInteger value = (BigInteger) _value.getBigInteger();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedBigInteger("", 64, (BigInteger) (value));
+ // Simple field (value)
+ lengthInBits += 64;
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.INTEGER8)) { // SINT
- // Simple Field (value)
- byte value = (byte) _value.getByte();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeSignedByte("", 8, ((Number) (value)).byteValue());
+ // Simple field (value)
+ lengthInBits += 8;
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.INTEGER16)) { // INT
- // Simple Field (value)
- short value = (short) _value.getShort();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeShort("", 16, ((Number) (value)).shortValue());
+ // Simple field (value)
+ lengthInBits += 16;
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.INTEGER24)) { // DINT
- // Simple Field (value)
- int value = (int) _value.getInt();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeInt("", 24, ((Number) (value)).intValue());
+ // Simple field (value)
+ lengthInBits += 24;
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.INTEGER32)) { // DINT
- // Simple Field (value)
- int value = (int) _value.getInt();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeInt("", 32, ((Number) (value)).intValue());
+ // Simple field (value)
+ lengthInBits += 32;
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.INTEGER40)) { // LINT
- // Simple Field (value)
- long value = (long) _value.getLong();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeLong("", 40, ((Number) (value)).longValue());
+ // Simple field (value)
+ lengthInBits += 40;
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.INTEGER48)) { // LINT
- // Simple Field (value)
- long value = (long) _value.getLong();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeLong("", 48, ((Number) (value)).longValue());
+ // Simple field (value)
+ lengthInBits += 48;
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.INTEGER56)) { // LINT
- // Simple Field (value)
- long value = (long) _value.getLong();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeLong("", 56, ((Number) (value)).longValue());
+ // Simple field (value)
+ lengthInBits += 56;
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.INTEGER64)) { // LINT
- // Simple Field (value)
- long value = (long) _value.getLong();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeLong("", 64, ((Number) (value)).longValue());
+ // Simple field (value)
+ lengthInBits += 64;
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.REAL32)) { // REAL
- // Simple Field (value)
- float value = (float) _value.getFloat();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeFloat("", 32, (value));
+ // Simple field (value)
+ lengthInBits += 32;
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.REAL64)) { // LREAL
- // Simple Field (value)
- double value = (double) _value.getDouble();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeDouble("", 64, (value));
+ // Simple field (value)
+ lengthInBits += 64;
}
+
+ return lengthInBits;
}
- public static int getLengthInBytes(PlcValue _value, GenericCANDataType dataType) {
- return (int) Math.ceil((float) getLengthInBits(_value, dataType) / 8.0);
+ public static void staticSerialize(
+ WriteBuffer writeBuffer, PlcValue _value, GenericCANDataType dataType)
+ throws SerializationException {
+ staticSerialize(writeBuffer, _value, dataType, ByteOrder.BIG_ENDIAN);
}
- public static int getLengthInBits(PlcValue _value, GenericCANDataType dataType) {
- int sizeInBits = 0;
+ public static void staticSerialize(
+ WriteBuffer writeBuffer, PlcValue _value, GenericCANDataType dataType, ByteOrder byteOrder)
+ throws SerializationException {
if (EvaluationHelper.equals(dataType, GenericCANDataType.BYTE)) { // BYTE
// Simple Field (value)
- sizeInBits += 8;
+ writeSimpleField(
+ "value",
+ (byte) _value.getByte(),
+ writeByte(writeBuffer, 8),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.BOOLEAN)) { // BOOL
// Simple Field (value)
- sizeInBits += 1;
+ writeSimpleField(
+ "value",
+ (boolean) _value.getBoolean(),
+ writeBoolean(writeBuffer),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.UNSIGNED8)) { // USINT
// Simple Field (value)
- sizeInBits += 8;
+ writeSimpleField(
+ "value",
+ (short) _value.getShort(),
+ writeUnsignedShort(writeBuffer, 8),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.UNSIGNED16)) { // UINT
// Simple Field (value)
- sizeInBits += 16;
+ writeSimpleField(
+ "value",
+ (int) _value.getInteger(),
+ writeUnsignedInt(writeBuffer, 16),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.UNSIGNED24)) { // UDINT
// Simple Field (value)
- sizeInBits += 24;
+ writeSimpleField(
+ "value",
+ (int) _value.getInteger(),
+ writeUnsignedInt(writeBuffer, 24),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.UNSIGNED32)) { // UDINT
// Simple Field (value)
- sizeInBits += 32;
+ writeSimpleField(
+ "value",
+ (long) _value.getLong(),
+ writeUnsignedLong(writeBuffer, 32),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.UNSIGNED40)) { // ULINT
// Simple Field (value)
- sizeInBits += 40;
+ writeSimpleField(
+ "value",
+ (long) _value.getLong(),
+ writeUnsignedLong(writeBuffer, 40),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.UNSIGNED48)) { // ULINT
// Simple Field (value)
- sizeInBits += 48;
+ writeSimpleField(
+ "value",
+ (long) _value.getLong(),
+ writeUnsignedLong(writeBuffer, 48),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.UNSIGNED56)) { // ULINT
// Simple Field (value)
- sizeInBits += 56;
+ writeSimpleField(
+ "value",
+ (long) _value.getLong(),
+ writeUnsignedLong(writeBuffer, 56),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.UNSIGNED64)) { // ULINT
// Simple Field (value)
- sizeInBits += 64;
+ writeSimpleField(
+ "value",
+ (BigInteger) _value.getBigInteger(),
+ writeUnsignedBigInteger(writeBuffer, 64),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.INTEGER8)) { // SINT
// Simple Field (value)
- sizeInBits += 8;
+ writeSimpleField(
+ "value",
+ (byte) _value.getByte(),
+ writeSignedByte(writeBuffer, 8),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.INTEGER16)) { // INT
// Simple Field (value)
- sizeInBits += 16;
+ writeSimpleField(
+ "value",
+ (short) _value.getShort(),
+ writeSignedShort(writeBuffer, 16),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.INTEGER24)) { // DINT
// Simple Field (value)
- sizeInBits += 24;
+ writeSimpleField(
+ "value",
+ (int) _value.getInteger(),
+ writeSignedInt(writeBuffer, 24),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.INTEGER32)) { // DINT
// Simple Field (value)
- sizeInBits += 32;
+ writeSimpleField(
+ "value",
+ (int) _value.getInteger(),
+ writeSignedInt(writeBuffer, 32),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.INTEGER40)) { // LINT
// Simple Field (value)
- sizeInBits += 40;
+ writeSimpleField(
+ "value",
+ (long) _value.getLong(),
+ writeSignedLong(writeBuffer, 40),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.INTEGER48)) { // LINT
// Simple Field (value)
- sizeInBits += 48;
+ writeSimpleField(
+ "value",
+ (long) _value.getLong(),
+ writeSignedLong(writeBuffer, 48),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.INTEGER56)) { // LINT
// Simple Field (value)
- sizeInBits += 56;
+ writeSimpleField(
+ "value",
+ (long) _value.getLong(),
+ writeSignedLong(writeBuffer, 56),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.INTEGER64)) { // LINT
// Simple Field (value)
- sizeInBits += 64;
+ writeSimpleField(
+ "value",
+ (long) _value.getLong(),
+ writeSignedLong(writeBuffer, 64),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.REAL32)) { // REAL
// Simple Field (value)
- sizeInBits += 32;
+ writeSimpleField(
+ "value",
+ (float) _value.getFloat(),
+ writeFloat(writeBuffer, 32),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
} else if (EvaluationHelper.equals(dataType, GenericCANDataType.REAL64)) { // LREAL
// Simple Field (value)
- sizeInBits += 64;
+ writeSimpleField(
+ "value",
+ (double) _value.getDouble(),
+ writeDouble(writeBuffer, 64),
+ WithOption.WithByteOrder(ByteOrder.LITTLE_ENDIAN));
}
- return sizeInBits;
}
}
diff --git a/plc4j/drivers/canopen/src/main/generated/org/apache/plc4x/java/canopen/readwrite/DataItem.java b/plc4j/drivers/canopen/src/main/generated/org/apache/plc4x/java/canopen/readwrite/DataItem.java
index b1e7647997..fc04e1caf4 100644
--- a/plc4j/drivers/canopen/src/main/generated/org/apache/plc4x/java/canopen/readwrite/DataItem.java
+++ b/plc4j/drivers/canopen/src/main/generated/org/apache/plc4x/java/canopen/readwrite/DataItem.java
@@ -18,19 +18,21 @@
*/
package org.apache.plc4x.java.canopen.readwrite;
+import static org.apache.plc4x.java.spi.codegen.fields.FieldReaderFactory.*;
+import static org.apache.plc4x.java.spi.codegen.fields.FieldWriterFactory.*;
+import static org.apache.plc4x.java.spi.codegen.io.DataReaderFactory.*;
+import static org.apache.plc4x.java.spi.codegen.io.DataWriterFactory.*;
import static org.apache.plc4x.java.spi.generation.StaticHelper.*;
import java.math.BigInteger;
import java.time.*;
import java.util.*;
+import org.apache.plc4x.java.api.exceptions.*;
import org.apache.plc4x.java.api.value.*;
-import org.apache.plc4x.java.spi.codegen.WithOption;
-import org.apache.plc4x.java.spi.generation.ByteOrder;
-import org.apache.plc4x.java.spi.generation.EvaluationHelper;
-import org.apache.plc4x.java.spi.generation.ParseException;
-import org.apache.plc4x.java.spi.generation.ReadBuffer;
-import org.apache.plc4x.java.spi.generation.SerializationException;
-import org.apache.plc4x.java.spi.generation.WriteBuffer;
+import org.apache.plc4x.java.spi.codegen.*;
+import org.apache.plc4x.java.spi.codegen.fields.*;
+import org.apache.plc4x.java.spi.codegen.io.*;
+import org.apache.plc4x.java.spi.generation.*;
import org.apache.plc4x.java.spi.values.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -44,369 +46,244 @@ public class DataItem {
public static PlcValue staticParse(ReadBuffer readBuffer, CANOpenDataType dataType, Integer size)
throws ParseException {
if (EvaluationHelper.equals(dataType, CANOpenDataType.BOOLEAN)) { // BOOL
-
- // Simple Field (value)
- Boolean value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
+ boolean value = readSimpleField("value", readBoolean(readBuffer));
return new PlcBOOL(value);
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.UNSIGNED8)) { // USINT
-
- // Simple Field (value)
- Short value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedShort("", 8);
-
+ short value = readSimpleField("value", readUnsignedShort(readBuffer, 8));
return new PlcUSINT(value);
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.UNSIGNED16)) { // UINT
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedInt("", 16);
-
+ int value = readSimpleField("value", readUnsignedInt(readBuffer, 16));
return new PlcUINT(value);
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.UNSIGNED24)) { // UDINT
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedInt("", 24);
-
+ int value = readSimpleField("value", readUnsignedInt(readBuffer, 24));
return new PlcUDINT(value);
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.UNSIGNED32)) { // UDINT
-
- // Simple Field (value)
- Long value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedLong("", 32);
-
+ long value = readSimpleField("value", readUnsignedLong(readBuffer, 32));
return new PlcUDINT(value);
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.UNSIGNED40)) { // ULINT
-
- // Simple Field (value)
- Long value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedLong("", 40);
-
+ long value = readSimpleField("value", readUnsignedLong(readBuffer, 40));
return new PlcULINT(value);
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.UNSIGNED48)) { // ULINT
-
- // Simple Field (value)
- Long value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedLong("", 48);
-
+ long value = readSimpleField("value", readUnsignedLong(readBuffer, 48));
return new PlcULINT(value);
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.UNSIGNED56)) { // ULINT
-
- // Simple Field (value)
- Long value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedLong("", 56);
-
+ long value = readSimpleField("value", readUnsignedLong(readBuffer, 56));
return new PlcULINT(value);
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.UNSIGNED64)) { // ULINT
-
- // Simple Field (value)
- BigInteger value = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedBigInteger("", 64);
-
+ BigInteger value = readSimpleField("value", readUnsignedBigInteger(readBuffer, 64));
return new PlcULINT(value);
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.INTEGER8)) { // SINT
-
- // Simple Field (value)
- Byte value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readSignedByte("", 8);
-
+ byte value = readSimpleField("value", readSignedByte(readBuffer, 8));
return new PlcSINT(value);
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.INTEGER16)) { // INT
-
- // Simple Field (value)
- Short value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readShort("", 16);
-
+ short value = readSimpleField("value", readSignedShort(readBuffer, 16));
return new PlcINT(value);
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.INTEGER24)) { // DINT
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readInt("", 24);
-
+ int value = readSimpleField("value", readSignedInt(readBuffer, 24));
return new PlcDINT(value);
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.INTEGER32)) { // DINT
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readInt("", 32);
-
+ int value = readSimpleField("value", readSignedInt(readBuffer, 32));
return new PlcDINT(value);
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.INTEGER40)) { // LINT
-
- // Simple Field (value)
- Long value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readLong("", 40);
-
+ long value = readSimpleField("value", readSignedLong(readBuffer, 40));
return new PlcLINT(value);
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.INTEGER48)) { // LINT
-
- // Simple Field (value)
- Long value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readLong("", 48);
-
+ long value = readSimpleField("value", readSignedLong(readBuffer, 48));
return new PlcLINT(value);
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.INTEGER56)) { // LINT
-
- // Simple Field (value)
- Long value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readLong("", 56);
-
+ long value = readSimpleField("value", readSignedLong(readBuffer, 56));
return new PlcLINT(value);
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.INTEGER64)) { // LINT
-
- // Simple Field (value)
- Long value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readLong("", 64);
-
+ long value = readSimpleField("value", readSignedLong(readBuffer, 64));
return new PlcLINT(value);
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.REAL32)) { // REAL
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.REAL64)) { // LREAL
-
- // Simple Field (value)
- Double value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readDouble("", 64);
-
+ double value = readSimpleField("value", readDouble(readBuffer, 64));
return new PlcLREAL(value);
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.RECORD)) { // List
- // Array field (value)
- // Length array
- long _valueLength = size;
- long valueEndPos = readBuffer.getPos() + _valueLength;
- List<PlcValue> value = new LinkedList<>();
- while (readBuffer.getPos() < valueEndPos) {
- value.add(new PlcSINT(/*TODO: migrate me*//*TODO: migrate me*/ readBuffer.readByte("")));
- }
-
- return new PlcList(value);
+ byte[] value = readBuffer.readByteArray("value", Math.toIntExact(size));
+ return new PlcRawByteArray(value);
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.OCTET_STRING)) { // STRING
-
- // Simple Field (value)
- String value = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readString("", size, WithOption.WithEncoding("UTF-8"));
-
+ String value = readSimpleField("value", readString(readBuffer, size));
return new PlcSTRING(value);
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.VISIBLE_STRING)) { // STRING
-
- // Simple Field (value)
- String value = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readString("", size, WithOption.WithEncoding("UTF-8"));
-
+ String value = readSimpleField("value", readString(readBuffer, size));
return new PlcSTRING(value);
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.UNICODE_STRING)) { // STRING
-
- // Simple Field (value)
- String value = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readString("", (size) / (8), WithOption.WithEncoding("UTF-8"));
-
+ String value = readSimpleField("value", readString(readBuffer, (size) / (8)));
return new PlcSTRING(value);
}
return null;
}
- public static void staticSerialize(
- WriteBuffer writeBuffer, PlcValue _value, CANOpenDataType dataType, Integer size)
- throws SerializationException {
- staticSerialize(writeBuffer, _value, dataType, size, ByteOrder.BIG_ENDIAN);
+ public static int getLengthInBytes(PlcValue _value, CANOpenDataType dataType, Integer size) {
+ return (int) Math.ceil((float) getLengthInBits(_value, dataType, size) / 8.0);
}
- public static void staticSerialize(
- WriteBuffer writeBuffer,
- PlcValue _value,
- CANOpenDataType dataType,
- Integer size,
- ByteOrder byteOrder)
- throws SerializationException {
+ public static int getLengthInBits(PlcValue _value, CANOpenDataType dataType, Integer size) {
+ int lengthInBits = 0;
if (EvaluationHelper.equals(dataType, CANOpenDataType.BOOLEAN)) { // BOOL
- // Simple Field (value)
- boolean value = (boolean) _value.getBoolean();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeBit("", (boolean) (value));
+ // Simple field (value)
+ lengthInBits += 1;
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.UNSIGNED8)) { // USINT
- // Simple Field (value)
- short value = (short) _value.getShort();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedShort("", 8, ((Number) (value)).shortValue());
+ // Simple field (value)
+ lengthInBits += 8;
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.UNSIGNED16)) { // UINT
- // Simple Field (value)
- int value = (int) _value.getInt();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedInt("", 16, ((Number) (value)).intValue());
+ // Simple field (value)
+ lengthInBits += 16;
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.UNSIGNED24)) { // UDINT
- // Simple Field (value)
- int value = (int) _value.getInt();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedInt("", 24, ((Number) (value)).intValue());
+ // Simple field (value)
+ lengthInBits += 24;
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.UNSIGNED32)) { // UDINT
- // Simple Field (value)
- long value = (long) _value.getLong();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedLong("", 32, ((Number) (value)).longValue());
+ // Simple field (value)
+ lengthInBits += 32;
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.UNSIGNED40)) { // ULINT
- // Simple Field (value)
- long value = (long) _value.getLong();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedLong("", 40, ((Number) (value)).longValue());
+ // Simple field (value)
+ lengthInBits += 40;
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.UNSIGNED48)) { // ULINT
- // Simple Field (value)
- long value = (long) _value.getLong();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedLong("", 48, ((Number) (value)).longValue());
+ // Simple field (value)
+ lengthInBits += 48;
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.UNSIGNED56)) { // ULINT
- // Simple Field (value)
- long value = (long) _value.getLong();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedLong("", 56, ((Number) (value)).longValue());
+ // Simple field (value)
+ lengthInBits += 56;
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.UNSIGNED64)) { // ULINT
- // Simple Field (value)
- BigInteger value = (BigInteger) _value.getBigInteger();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeUnsignedBigInteger("", 64, (BigInteger) (value));
+ // Simple field (value)
+ lengthInBits += 64;
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.INTEGER8)) { // SINT
- // Simple Field (value)
- byte value = (byte) _value.getByte();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeSignedByte("", 8, ((Number) (value)).byteValue());
+ // Simple field (value)
+ lengthInBits += 8;
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.INTEGER16)) { // INT
- // Simple Field (value)
- short value = (short) _value.getShort();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeShort("", 16, ((Number) (value)).shortValue());
+ // Simple field (value)
+ lengthInBits += 16;
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.INTEGER24)) { // DINT
- // Simple Field (value)
- int value = (int) _value.getInt();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeInt("", 24, ((Number) (value)).intValue());
+ // Simple field (value)
+ lengthInBits += 24;
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.INTEGER32)) { // DINT
- // Simple Field (value)
- int value = (int) _value.getInt();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeInt("", 32, ((Number) (value)).intValue());
+ // Simple field (value)
+ lengthInBits += 32;
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.INTEGER40)) { // LINT
- // Simple Field (value)
- long value = (long) _value.getLong();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeLong("", 40, ((Number) (value)).longValue());
+ // Simple field (value)
+ lengthInBits += 40;
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.INTEGER48)) { // LINT
- // Simple Field (value)
- long value = (long) _value.getLong();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeLong("", 48, ((Number) (value)).longValue());
+ // Simple field (value)
+ lengthInBits += 48;
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.INTEGER56)) { // LINT
- // Simple Field (value)
- long value = (long) _value.getLong();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeLong("", 56, ((Number) (value)).longValue());
+ // Simple field (value)
+ lengthInBits += 56;
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.INTEGER64)) { // LINT
- // Simple Field (value)
- long value = (long) _value.getLong();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeLong("", 64, ((Number) (value)).longValue());
+ // Simple field (value)
+ lengthInBits += 64;
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.REAL32)) { // REAL
- // Simple Field (value)
- float value = (float) _value.getFloat();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeFloat("", 32, (value));
+ // Simple field (value)
+ lengthInBits += 32;
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.REAL64)) { // LREAL
- // Simple Field (value)
- double value = (double) _value.getDouble();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeDouble("", 64, (value));
+ // Simple field (value)
+ lengthInBits += 64;
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.RECORD)) { // List
- PlcList values = (PlcList) _value;
-
- for (PlcValue val : ((List<PlcValue>) values.getList())) {
- byte[] value = (byte[]) val.getRaw();
- writeBuffer.writeByteArray("", value);
+ // Array field
+ if (_value != null) {
+ lengthInBits += 8 * _value.getRaw().length;
}
-
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.OCTET_STRING)) { // STRING
- // Simple Field (value)
- String value = (String) _value.getString();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeString(
- "", size, (String) (value), WithOption.WithEncoding("UTF-8"));
+ // Simple field (value)
+ lengthInBits += size;
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.VISIBLE_STRING)) { // STRING
- // Simple Field (value)
- String value = (String) _value.getString();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeString(
- "", size, (String) (value), WithOption.WithEncoding("UTF-8"));
+ // Simple field (value)
+ lengthInBits += size;
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.UNICODE_STRING)) { // STRING
- // Simple Field (value)
- String value = (String) _value.getString();
- /*TODO: migrate me*/
- /*TODO: migrate me*/ writeBuffer.writeString(
- "", (size) / (8), (String) (value), WithOption.WithEncoding("UTF-8"));
+ // Simple field (value)
+ lengthInBits += (size) / (8);
}
+
+ return lengthInBits;
}
- public static int getLengthInBytes(PlcValue _value, CANOpenDataType dataType, Integer size) {
- return (int) Math.ceil((float) getLengthInBits(_value, dataType, size) / 8.0);
+ public static void staticSerialize(
+ WriteBuffer writeBuffer, PlcValue _value, CANOpenDataType dataType, Integer size)
+ throws SerializationException {
+ staticSerialize(writeBuffer, _value, dataType, size, ByteOrder.BIG_ENDIAN);
}
- public static int getLengthInBits(PlcValue _value, CANOpenDataType dataType, Integer size) {
- int sizeInBits = 0;
+ public static void staticSerialize(
+ WriteBuffer writeBuffer,
+ PlcValue _value,
+ CANOpenDataType dataType,
+ Integer size,
+ ByteOrder byteOrder)
+ throws SerializationException {
if (EvaluationHelper.equals(dataType, CANOpenDataType.BOOLEAN)) { // BOOL
// Simple Field (value)
- sizeInBits += 1;
+ writeSimpleField("value", (boolean) _value.getBoolean(), writeBoolean(writeBuffer));
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.UNSIGNED8)) { // USINT
// Simple Field (value)
- sizeInBits += 8;
+ writeSimpleField("value", (short) _value.getShort(), writeUnsignedShort(writeBuffer, 8));
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.UNSIGNED16)) { // UINT
// Simple Field (value)
- sizeInBits += 16;
+ writeSimpleField("value", (int) _value.getInteger(), writeUnsignedInt(writeBuffer, 16));
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.UNSIGNED24)) { // UDINT
// Simple Field (value)
- sizeInBits += 24;
+ writeSimpleField("value", (int) _value.getInteger(), writeUnsignedInt(writeBuffer, 24));
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.UNSIGNED32)) { // UDINT
// Simple Field (value)
- sizeInBits += 32;
+ writeSimpleField("value", (long) _value.getLong(), writeUnsignedLong(writeBuffer, 32));
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.UNSIGNED40)) { // ULINT
// Simple Field (value)
- sizeInBits += 40;
+ writeSimpleField("value", (long) _value.getLong(), writeUnsignedLong(writeBuffer, 40));
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.UNSIGNED48)) { // ULINT
// Simple Field (value)
- sizeInBits += 48;
+ writeSimpleField("value", (long) _value.getLong(), writeUnsignedLong(writeBuffer, 48));
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.UNSIGNED56)) { // ULINT
// Simple Field (value)
- sizeInBits += 56;
+ writeSimpleField("value", (long) _value.getLong(), writeUnsignedLong(writeBuffer, 56));
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.UNSIGNED64)) { // ULINT
// Simple Field (value)
- sizeInBits += 64;
+ writeSimpleField(
+ "value", (BigInteger) _value.getBigInteger(), writeUnsignedBigInteger(writeBuffer, 64));
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.INTEGER8)) { // SINT
// Simple Field (value)
- sizeInBits += 8;
+ writeSimpleField("value", (byte) _value.getByte(), writeSignedByte(writeBuffer, 8));
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.INTEGER16)) { // INT
// Simple Field (value)
- sizeInBits += 16;
+ writeSimpleField("value", (short) _value.getShort(), writeSignedShort(writeBuffer, 16));
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.INTEGER24)) { // DINT
// Simple Field (value)
- sizeInBits += 24;
+ writeSimpleField("value", (int) _value.getInteger(), writeSignedInt(writeBuffer, 24));
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.INTEGER32)) { // DINT
// Simple Field (value)
- sizeInBits += 32;
+ writeSimpleField("value", (int) _value.getInteger(), writeSignedInt(writeBuffer, 32));
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.INTEGER40)) { // LINT
// Simple Field (value)
- sizeInBits += 40;
+ writeSimpleField("value", (long) _value.getLong(), writeSignedLong(writeBuffer, 40));
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.INTEGER48)) { // LINT
// Simple Field (value)
- sizeInBits += 48;
+ writeSimpleField("value", (long) _value.getLong(), writeSignedLong(writeBuffer, 48));
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.INTEGER56)) { // LINT
// Simple Field (value)
- sizeInBits += 56;
+ writeSimpleField("value", (long) _value.getLong(), writeSignedLong(writeBuffer, 56));
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.INTEGER64)) { // LINT
// Simple Field (value)
- sizeInBits += 64;
+ writeSimpleField("value", (long) _value.getLong(), writeSignedLong(writeBuffer, 64));
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.REAL32)) { // REAL
// Simple Field (value)
- sizeInBits += 32;
+ writeSimpleField("value", (float) _value.getFloat(), writeFloat(writeBuffer, 32));
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.REAL64)) { // LREAL
// Simple Field (value)
- sizeInBits += 64;
+ writeSimpleField("value", (double) _value.getDouble(), writeDouble(writeBuffer, 64));
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.RECORD)) { // List
- PlcList values = (PlcList) _value;
- sizeInBits += values.getList().size() * 8;
+ // Array Field (value)
+ writeByteArrayField("value", _value.getRaw(), writeByteArray(writeBuffer, 8));
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.OCTET_STRING)) { // STRING
// Simple Field (value)
- sizeInBits += -1;
+ writeSimpleField("value", (String) _value.getString(), writeString(writeBuffer, size));
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.VISIBLE_STRING)) { // STRING
// Simple Field (value)
- sizeInBits += -1;
+ writeSimpleField("value", (String) _value.getString(), writeString(writeBuffer, size));
} else if (EvaluationHelper.equals(dataType, CANOpenDataType.UNICODE_STRING)) { // STRING
// Simple Field (value)
- sizeInBits += -1;
+ writeSimpleField(
+ "value", (String) _value.getString(), writeString(writeBuffer, (size) / (8)));
}
- return sizeInBits;
}
}
diff --git a/plc4j/drivers/knxnetip/src/main/generated/org/apache/plc4x/java/knxnetip/readwrite/KnxDatapoint.java b/plc4j/drivers/knxnetip/src/main/generated/org/apache/plc4x/java/knxnetip/readwrite/KnxDatapoint.java
index dfe02653e1..0ab4a24ac1 100644
--- a/plc4j/drivers/knxnetip/src/main/generated/org/apache/plc4x/java/knxnetip/readwrite/KnxDatapoint.java
+++ b/plc4j/drivers/knxnetip/src/main/generated/org/apache/plc4x/java/knxnetip/readwrite/KnxDatapoint.java
@@ -18,19 +18,22 @@
*/
package org.apache.plc4x.java.knxnetip.readwrite;
+import static org.apache.plc4x.java.spi.codegen.fields.FieldReaderFactory.*;
+import static org.apache.plc4x.java.spi.codegen.fields.FieldWriterFactory.*;
+import static org.apache.plc4x.java.spi.codegen.io.DataReaderFactory.*;
+import static org.apache.plc4x.java.spi.codegen.io.DataWriterFactory.*;
import static org.apache.plc4x.java.spi.generation.StaticHelper.*;
import java.math.BigInteger;
import java.time.*;
+import java.time.temporal.ChronoField;
import java.util.*;
+import org.apache.plc4x.java.api.exceptions.*;
import org.apache.plc4x.java.api.value.*;
-import org.apache.plc4x.java.spi.codegen.WithOption;
-import org.apache.plc4x.java.spi.generation.ByteOrder;
-import org.apache.plc4x.java.spi.generation.EvaluationHelper;
-import org.apache.plc4x.java.spi.generation.ParseException;
-import org.apache.plc4x.java.spi.generation.ReadBuffer;
-import org.apache.plc4x.java.spi.generation.SerializationException;
-import org.apache.plc4x.java.spi.generation.WriteBuffer;
+import org.apache.plc4x.java.spi.codegen.*;
+import org.apache.plc4x.java.spi.codegen.fields.*;
+import org.apache.plc4x.java.spi.codegen.io.*;
+import org.apache.plc4x.java.spi.generation.*;
import org.apache.plc4x.java.spi.values.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -44,1392 +47,598 @@ public class KnxDatapoint {
public static PlcValue staticParse(ReadBuffer readBuffer, KnxDatapointType datapointType)
throws ParseException {
if (EvaluationHelper.equals(datapointType, KnxDatapointType.BOOL)) { // BOOL
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 7), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 7);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Boolean value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
+ boolean value = readSimpleField("value", readBoolean(readBuffer));
return new PlcBOOL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.BYTE)) { // BYTE
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Short value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedShort("", 8);
-
+ short value = readSimpleField("value", readUnsignedShort(readBuffer, 8));
return new PlcBYTE(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.WORD)) { // WORD
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedInt("", 16);
-
+ int value = readSimpleField("value", readUnsignedInt(readBuffer, 16));
return new PlcWORD(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DWORD)) { // DWORD
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Long value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedLong("", 32);
-
+ long value = readSimpleField("value", readUnsignedLong(readBuffer, 32));
return new PlcDWORD(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.LWORD)) { // LWORD
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- BigInteger value = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedBigInteger("", 64);
-
+ BigInteger value = readSimpleField("value", readUnsignedBigInteger(readBuffer, 64));
return new PlcLWORD(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.USINT)) { // USINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Short value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedShort("", 8);
-
+ short value = readSimpleField("value", readUnsignedShort(readBuffer, 8));
return new PlcUSINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.SINT)) { // SINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Byte value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readSignedByte("", 8);
-
+ byte value = readSimpleField("value", readSignedByte(readBuffer, 8));
return new PlcSINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.UINT)) { // UINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedInt("", 16);
-
+ int value = readSimpleField("value", readUnsignedInt(readBuffer, 16));
return new PlcUINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.INT)) { // INT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Short value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readShort("", 16);
-
+ short value = readSimpleField("value", readSignedShort(readBuffer, 16));
return new PlcINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.UDINT)) { // UDINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Long value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedLong("", 32);
-
+ long value = readSimpleField("value", readUnsignedLong(readBuffer, 32));
return new PlcUDINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DINT)) { // DINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readInt("", 32);
-
+ int value = readSimpleField("value", readSignedInt(readBuffer, 32));
return new PlcDINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.ULINT)) { // ULINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- BigInteger value = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedBigInteger("", 64);
-
+ BigInteger value = readSimpleField("value", readUnsignedBigInteger(readBuffer, 64));
return new PlcULINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.LINT)) { // LINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Long value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readLong("", 64);
-
+ long value = readSimpleField("value", readSignedLong(readBuffer, 64));
return new PlcLINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.REAL)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.LREAL)) { // LREAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Double value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readDouble("", 64);
-
+ double value = readSimpleField("value", readDouble(readBuffer, 64));
return new PlcLREAL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.CHAR)) { // CHAR
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- String value = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readString("", 8, WithOption.WithEncoding("UTF-8"));
-
+ String value =
+ readSimpleField("value", readString(readBuffer, 8), WithOption.WithEncoding("UTF-8"));
return new PlcCHAR(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.WCHAR)) { // WCHAR
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- String value = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readString("", 16, WithOption.WithEncoding("UTF-16"));
-
+ String value =
+ readSimpleField("value", readString(readBuffer, 16), WithOption.WithEncoding("UTF-16"));
return new PlcWCHAR(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.TIME)) { // TIME
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (milliseconds)
- Long milliseconds = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedLong("", 32);
-
+ long milliseconds = readSimpleField("milliseconds", readUnsignedLong(readBuffer, 32));
return PlcTIME.ofMilliseconds(milliseconds);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.LTIME)) { // LTIME
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (nanoseconds)
- BigInteger nanoseconds = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedBigInteger("", 64);
-
+ BigInteger nanoseconds =
+ readSimpleField("nanoseconds", readUnsignedBigInteger(readBuffer, 64));
return PlcLTIME.ofNanoseconds(nanoseconds);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DATE)) { // DATE
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (secondsSinceEpoch)
- Long secondsSinceEpoch = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedLong("", 32);
-
+ long secondsSinceEpoch =
+ readSimpleField("secondsSinceEpoch", readUnsignedLong(readBuffer, 32));
return PlcDATE.ofSecondsSinceEpoch(secondsSinceEpoch);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.TIME_OF_DAY)) { // TIME_OF_DAY
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (millisecondsSinceMidnight)
- Long millisecondsSinceMidnight = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedLong("", 32);
-
+ long millisecondsSinceMidnight =
+ readSimpleField("millisecondsSinceMidnight", readUnsignedLong(readBuffer, 32));
return PlcTIME_OF_DAY.ofMillisecondsSinceMidnight(millisecondsSinceMidnight);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.TOD)) { // TIME_OF_DAY
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (millisecondsSinceMidnight)
- Long millisecondsSinceMidnight = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedLong("", 32);
-
+ long millisecondsSinceMidnight =
+ readSimpleField("millisecondsSinceMidnight", readUnsignedLong(readBuffer, 32));
return PlcTIME_OF_DAY.ofMillisecondsSinceMidnight(millisecondsSinceMidnight);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DATE_AND_TIME)) { // DATE_AND_TIME
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (year)
- Integer year = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedInt("", 16);
+ int year = readSimpleField("year", readUnsignedInt(readBuffer, 16));
- // Simple Field (month)
- Short month = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedShort("", 8);
+ short month = readSimpleField("month", readUnsignedShort(readBuffer, 8));
- // Simple Field (day)
- Short day = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedShort("", 8);
+ short day = readSimpleField("day", readUnsignedShort(readBuffer, 8));
- // Simple Field (dayOfWeek)
- Short dayOfWeek = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
+ short dayOfWeek = readSimpleField("dayOfWeek", readUnsignedShort(readBuffer, 8));
- // Simple Field (hour)
- Short hour = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedShort("", 8);
+ short hour = readSimpleField("hour", readUnsignedShort(readBuffer, 8));
- // Simple Field (minutes)
- Short minutes = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedShort("", 8);
+ short minutes = readSimpleField("minutes", readUnsignedShort(readBuffer, 8));
- // Simple Field (seconds)
- Short seconds = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedShort("", 8);
+ short seconds = readSimpleField("seconds", readUnsignedShort(readBuffer, 8));
- // Simple Field (nanoseconds)
- Long nanoseconds = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedLong("", 32);
-
- return PlcDATE_AND_TIME.ofSegments(
- year.intValue(),
- (month == 0) ? 1 : month.intValue(),
- (day == 0) ? 1 : day.intValue(),
- hour.intValue(),
- minutes.intValue(),
- seconds.intValue(),
- nanoseconds.intValue());
+ long nanoseconds = readSimpleField("nanoseconds", readUnsignedLong(readBuffer, 32));
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DT)) { // DATE_AND_TIME
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (year)
- Integer year = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedInt("", 16);
+ int year = readSimpleField("year", readUnsignedInt(readBuffer, 16));
- // Simple Field (month)
- Short month = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedShort("", 8);
+ short month = readSimpleField("month", readUnsignedShort(readBuffer, 8));
- // Simple Field (day)
- Short day = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedShort("", 8);
+ short day = readSimpleField("day", readUnsignedShort(readBuffer, 8));
- // Simple Field (dayOfWeek)
- Short dayOfWeek = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
+ short dayOfWeek = readSimpleField("dayOfWeek", readUnsignedShort(readBuffer, 8));
- // Simple Field (hour)
- Short hour = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedShort("", 8);
+ short hour = readSimpleField("hour", readUnsignedShort(readBuffer, 8));
- // Simple Field (minutes)
- Short minutes = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedShort("", 8);
+ short minutes = readSimpleField("minutes", readUnsignedShort(readBuffer, 8));
- // Simple Field (seconds)
- Short seconds = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedShort("", 8);
+ short seconds = readSimpleField("seconds", readUnsignedShort(readBuffer, 8));
- // Simple Field (nanoseconds)
- Long nanoseconds = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedLong("", 32);
-
- return PlcDATE_AND_TIME.ofSegments(
- year.intValue(),
- (month == 0) ? 1 : month.intValue(),
- (day == 0) ? 1 : day.intValue(),
- hour.intValue(),
- minutes.intValue(),
- seconds.intValue(),
- nanoseconds.intValue());
+ long nanoseconds = readSimpleField("nanoseconds", readUnsignedLong(readBuffer, 32));
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Switch)) { // BOOL
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 7), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 7);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Boolean value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
+ boolean value = readSimpleField("value", readBoolean(readBuffer));
return new PlcBOOL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Bool)) { // BOOL
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 7), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 7);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Boolean value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
+ boolean value = readSimpleField("value", readBoolean(readBuffer));
return new PlcBOOL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Enable)) { // BOOL
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 7), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 7);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Boolean value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
+ boolean value = readSimpleField("value", readBoolean(readBuffer));
return new PlcBOOL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Ramp)) { // BOOL
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 7), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 7);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Boolean value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
+ boolean value = readSimpleField("value", readBoolean(readBuffer));
return new PlcBOOL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Alarm)) { // BOOL
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 7), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 7);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Boolean value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
+ boolean value = readSimpleField("value", readBoolean(readBuffer));
return new PlcBOOL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_BinaryValue)) { // BOOL
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 7), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 7);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Boolean value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
+ boolean value = readSimpleField("value", readBoolean(readBuffer));
return new PlcBOOL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Step)) { // BOOL
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 7), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 7);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Boolean value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
+ boolean value = readSimpleField("value", readBoolean(readBuffer));
return new PlcBOOL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_UpDown)) { // BOOL
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 7), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 7);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Boolean value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
+ boolean value = readSimpleField("value", readBoolean(readBuffer));
return new PlcBOOL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_OpenClose)) { // BOOL
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 7), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 7);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Boolean value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
+ boolean value = readSimpleField("value", readBoolean(readBuffer));
return new PlcBOOL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Start)) { // BOOL
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 7), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 7);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Boolean value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
+ boolean value = readSimpleField("value", readBoolean(readBuffer));
return new PlcBOOL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_State)) { // BOOL
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 7), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 7);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Boolean value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
+ boolean value = readSimpleField("value", readBoolean(readBuffer));
return new PlcBOOL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Invert)) { // BOOL
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 7), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 7);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Boolean value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
+ boolean value = readSimpleField("value", readBoolean(readBuffer));
return new PlcBOOL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_DimSendStyle)) { // BOOL
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 7), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 7);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Boolean value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
+ boolean value = readSimpleField("value", readBoolean(readBuffer));
return new PlcBOOL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_InputSource)) { // BOOL
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 7), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 7);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Boolean value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
+ boolean value = readSimpleField("value", readBoolean(readBuffer));
return new PlcBOOL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Reset)) { // BOOL
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 7), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 7);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Boolean value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
+ boolean value = readSimpleField("value", readBoolean(readBuffer));
return new PlcBOOL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Ack)) { // BOOL
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 7), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 7);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Boolean value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
+ boolean value = readSimpleField("value", readBoolean(readBuffer));
return new PlcBOOL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Trigger)) { // BOOL
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 7), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 7);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Boolean value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
+ boolean value = readSimpleField("value", readBoolean(readBuffer));
return new PlcBOOL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Occupancy)) { // BOOL
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 7), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 7);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Boolean value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
+ boolean value = readSimpleField("value", readBoolean(readBuffer));
return new PlcBOOL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Window_Door)) { // BOOL
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 7), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 7);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Boolean value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
+ boolean value = readSimpleField("value", readBoolean(readBuffer));
return new PlcBOOL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_LogicalFunction)) { // BOOL
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 7), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 7);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Boolean value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
+ boolean value = readSimpleField("value", readBoolean(readBuffer));
return new PlcBOOL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Scene_AB)) { // BOOL
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 7), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 7);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Boolean value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
+ boolean value = readSimpleField("value", readBoolean(readBuffer));
return new PlcBOOL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_ShutterBlinds_Mode)) { // BOOL
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 7), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 7);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Boolean value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
+ boolean value = readSimpleField("value", readBoolean(readBuffer));
return new PlcBOOL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_DayNight)) { // BOOL
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 7), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 7);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Boolean value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
+ boolean value = readSimpleField("value", readBoolean(readBuffer));
return new PlcBOOL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Heat_Cool)) { // BOOL
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 7), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 7);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Boolean value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
+ boolean value = readSimpleField("value", readBoolean(readBuffer));
return new PlcBOOL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Switch_Control)) { // Struct
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 6), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 6);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
+ boolean control = readSimpleField("control", readBoolean(readBuffer));
- // Simple Field (control)
- Boolean control = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
- // Simple Field (on)
- Boolean on = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
+ boolean on = readSimpleField("on", readBoolean(readBuffer));
Map<String, PlcValue> _map = new HashMap<>();
_map.put("control", new PlcBOOL(control));
_map.put("on", new PlcBOOL(on));
-
return new PlcStruct(_map);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Bool_Control)) { // Struct
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 6), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 6);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
+ boolean control = readSimpleField("control", readBoolean(readBuffer));
- // Simple Field (control)
- Boolean control = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
- // Simple Field (valueTrue)
- Boolean valueTrue = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
+ boolean valueTrue = readSimpleField("valueTrue", readBoolean(readBuffer));
Map<String, PlcValue> _map = new HashMap<>();
_map.put("control", new PlcBOOL(control));
_map.put("valueTrue", new PlcBOOL(valueTrue));
-
return new PlcStruct(_map);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Enable_Control)) { // Struct
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 6), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 6);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
+ boolean control = readSimpleField("control", readBoolean(readBuffer));
- // Simple Field (control)
- Boolean control = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
- // Simple Field (enable)
- Boolean enable = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
+ boolean enable = readSimpleField("enable", readBoolean(readBuffer));
Map<String, PlcValue> _map = new HashMap<>();
_map.put("control", new PlcBOOL(control));
_map.put("enable", new PlcBOOL(enable));
-
return new PlcStruct(_map);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Ramp_Control)) { // Struct
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 6), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 6);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
+ boolean control = readSimpleField("control", readBoolean(readBuffer));
- // Simple Field (control)
- Boolean control = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
- // Simple Field (ramp)
- Boolean ramp = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
+ boolean ramp = readSimpleField("ramp", readBoolean(readBuffer));
Map<String, PlcValue> _map = new HashMap<>();
_map.put("control", new PlcBOOL(control));
_map.put("ramp", new PlcBOOL(ramp));
-
return new PlcStruct(_map);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Alarm_Control)) { // Struct
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 6), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 6);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
+ boolean control = readSimpleField("control", readBoolean(readBuffer));
- // Simple Field (control)
- Boolean control = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
- // Simple Field (alarm)
- Boolean alarm = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
+ boolean alarm = readSimpleField("alarm", readBoolean(readBuffer));
Map<String, PlcValue> _map = new HashMap<>();
_map.put("control", new PlcBOOL(control));
_map.put("alarm", new PlcBOOL(alarm));
-
return new PlcStruct(_map);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_BinaryValue_Control)) { // Struct
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 6), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 6);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
+ boolean control = readSimpleField("control", readBoolean(readBuffer));
- // Simple Field (control)
- Boolean control = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
- // Simple Field (high)
- Boolean high = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
+ boolean high = readSimpleField("high", readBoolean(readBuffer));
Map<String, PlcValue> _map = new HashMap<>();
_map.put("control", new PlcBOOL(control));
_map.put("high", new PlcBOOL(high));
-
return new PlcStruct(_map);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Step_Control)) { // Struct
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 6), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 6);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
+ boolean control = readSimpleField("control", readBoolean(readBuffer));
- // Simple Field (control)
- Boolean control = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
- // Simple Field (increase)
- Boolean increase = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
+ boolean increase = readSimpleField("increase", readBoolean(readBuffer));
Map<String, PlcValue> _map = new HashMap<>();
_map.put("control", new PlcBOOL(control));
_map.put("increase", new PlcBOOL(increase));
-
return new PlcStruct(_map);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Direction1_Control)) { // Struct
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 6), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 6);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
+ boolean control = readSimpleField("control", readBoolean(readBuffer));
- // Simple Field (control)
- Boolean control = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
- // Simple Field (down)
- Boolean down = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
+ boolean down = readSimpleField("down", readBoolean(readBuffer));
Map<String, PlcValue> _map = new HashMap<>();
_map.put("control", new PlcBOOL(control));
_map.put("down", new PlcBOOL(down));
-
return new PlcStruct(_map);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Direction2_Control)) { // Struct
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 6), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 6);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
+ boolean control = readSimpleField("control", readBoolean(readBuffer));
- // Simple Field (control)
- Boolean control = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
- // Simple Field (close)
- Boolean close = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
+ boolean close = readSimpleField("close", readBoolean(readBuffer));
Map<String, PlcValue> _map = new HashMap<>();
_map.put("control", new PlcBOOL(control));
_map.put("close", new PlcBOOL(close));
-
return new PlcStruct(_map);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Start_Control)) { // Struct
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 6), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 6);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
+ boolean control = readSimpleField("control", readBoolean(readBuffer));
- // Simple Field (control)
- Boolean control = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
- // Simple Field (start)
- Boolean start = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
+ boolean start = readSimpleField("start", readBoolean(readBuffer));
Map<String, PlcValue> _map = new HashMap<>();
_map.put("control", new PlcBOOL(control));
_map.put("start", new PlcBOOL(start));
-
return new PlcStruct(_map);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_State_Control)) { // Struct
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 6), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 6);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
+ boolean control = readSimpleField("control", readBoolean(readBuffer));
- // Simple Field (control)
- Boolean control = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
- // Simple Field (active)
- Boolean active = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
+ boolean active = readSimpleField("active", readBoolean(readBuffer));
Map<String, PlcValue> _map = new HashMap<>();
_map.put("control", new PlcBOOL(control));
_map.put("active", new PlcBOOL(active));
-
return new PlcStruct(_map);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Invert_Control)) { // Struct
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 6), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 6);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
+ boolean control = readSimpleField("control", readBoolean(readBuffer));
- // Simple Field (control)
- Boolean control = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
- // Simple Field (inverted)
- Boolean inverted = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
+ boolean inverted = readSimpleField("inverted", readBoolean(readBuffer));
Map<String, PlcValue> _map = new HashMap<>();
_map.put("control", new PlcBOOL(control));
_map.put("inverted", new PlcBOOL(inverted));
-
return new PlcStruct(_map);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Control_Dimming)) { // Struct
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 4), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 4);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
+ boolean increase = readSimpleField("increase", readBoolean(readBuffer));
- // Simple Field (increase)
- Boolean increase = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
- // Simple Field (stepcode)
- Byte stepcode = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedByte("", 3);
+ byte stepcode = readSimpleField("stepcode", readUnsignedByte(readBuffer, 3));
Map<String, PlcValue> _map = new HashMap<>();
_map.put("increase", new PlcBOOL(increase));
- _map.put("stepcode", new PlcSINT(stepcode));
-
+ _map.put("stepcode", new PlcUSINT(stepcode));
return new PlcStruct(_map);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Control_Blinds)) { // Struct
+ Byte reservedField0 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 4), (byte) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 4);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
+ boolean down = readSimpleField("down", readBoolean(readBuffer));
- // Simple Field (down)
- Boolean down = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
-
- // Simple Field (stepcode)
- Byte stepcode = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedByte("", 3);
+ byte stepcode = readSimpleField("stepcode", readUnsignedByte(readBuffer, 3));
Map<String, PlcValue> _map = new HashMap<>();
_map.put("down", new PlcBOOL(down));
- _map.put("stepcode", new PlcSINT(stepcode));
-
+ _map.put("stepcode", new PlcUSINT(stepcode));
return new PlcStruct(_map);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Char_ASCII)) { // STRING
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- String value = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readString("", 8, WithOption.WithEncoding("ASCII"));
-
+ String value =
+ readSimpleField("value", readString(readBuffer, 8), WithOption.WithEncoding("ASCII"));
return new PlcSTRING(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Char_8859_1)) { // STRING
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- String value = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readString("", 8, WithOption.WithEncoding("ISO-8859-1"));
-
+ String value =
+ readSimpleField(
+ "value", readString(readBuffer, 8), WithOption.WithEncoding("ISO-8859-1"));
return new PlcSTRING(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Scaling)) { // USINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Short value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedShort("", 8);
-
+ short value = readSimpleField("value", readUnsignedShort(readBuffer, 8));
return new PlcUSINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Angle)) { // USINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Short value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedShort("", 8);
-
+ short value = readSimpleField("value", readUnsignedShort(readBuffer, 8));
return new PlcUSINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Percent_U8)) { // USINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Short value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedShort("", 8);
-
+ short value = readSimpleField("value", readUnsignedShort(readBuffer, 8));
return new PlcUSINT(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_DecimalFactor)) { // USINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Short value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedShort("", 8);
-
+ short value = readSimpleField("value", readUnsignedShort(readBuffer, 8));
return new PlcUSINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Tariff)) { // USINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Short value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedShort("", 8);
-
+ short value = readSimpleField("value", readUnsignedShort(readBuffer, 8));
return new PlcUSINT(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_1_Ucount)) { // USINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Short value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedShort("", 8);
-
+ short value = readSimpleField("value", readUnsignedShort(readBuffer, 8));
return new PlcUSINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_FanStage)) { // USINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Short value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedShort("", 8);
-
+ short value = readSimpleField("value", readUnsignedShort(readBuffer, 8));
return new PlcUSINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Percent_V8)) { // SINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Byte value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readSignedByte("", 8);
-
+ byte value = readSimpleField("value", readSignedByte(readBuffer, 8));
return new PlcSINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Value_1_Count)) { // SINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Byte value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readSignedByte("", 8);
-
+ byte value = readSimpleField("value", readSignedByte(readBuffer, 8));
return new PlcSINT(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Status_Mode3)) { // Struct
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (statusA)
- Boolean statusA = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
+ boolean statusA = readSimpleField("statusA", readBoolean(readBuffer));
- // Simple Field (statusB)
- Boolean statusB = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
+ boolean statusB = readSimpleField("statusB", readBoolean(readBuffer));
- // Simple Field (statusC)
- Boolean statusC = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
+ boolean statusC = readSimpleField("statusC", readBoolean(readBuffer));
- // Simple Field (statusD)
- Boolean statusD = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
+ boolean statusD = readSimpleField("statusD", readBoolean(readBuffer));
- // Simple Field (statusE)
- Boolean statusE = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readBit("");
+ boolean statusE = readSimpleField("statusE", readBoolean(readBuffer));
- // Simple Field (mode)
- Byte mode = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedByte("", 3);
+ byte mode = readSimpleField("mode", readUnsignedByte(readBuffer, 3));
Map<String, PlcValue> _map = new HashMap<>();
_map.put("statusA", new PlcBOOL(statusA));
@@ -1437,2820 +646,1170 @@ public class KnxDatapoint {
_map.put("statusC", new PlcBOOL(statusC));
_map.put("statusD", new PlcBOOL(statusD));
_map.put("statusE", new PlcBOOL(statusE));
- _map.put("mode", new PlcSINT(mode));
-
+ _map.put("mode", new PlcUSINT(mode));
return new PlcStruct(_map);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_2_Ucount)) { // UINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedInt("", 16);
-
+ int value = readSimpleField("value", readUnsignedInt(readBuffer, 16));
return new PlcUINT(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_TimePeriodMsec)) { // UINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedInt("", 16);
-
+ int value = readSimpleField("value", readUnsignedInt(readBuffer, 16));
return new PlcUINT(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_TimePeriod10Msec)) { // UINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedInt("", 16);
-
+ int value = readSimpleField("value", readUnsignedInt(readBuffer, 16));
return new PlcUINT(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_TimePeriod100Msec)) { // UINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedInt("", 16);
-
+ int value = readSimpleField("value", readUnsignedInt(readBuffer, 16));
return new PlcUINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_TimePeriodSec)) { // UINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedInt("", 16);
-
+ int value = readSimpleField("value", readUnsignedInt(readBuffer, 16));
return new PlcUINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_TimePeriodMin)) { // UINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedInt("", 16);
-
+ int value = readSimpleField("value", readUnsignedInt(readBuffer, 16));
return new PlcUINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_TimePeriodHrs)) { // UINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedInt("", 16);
-
+ int value = readSimpleField("value", readUnsignedInt(readBuffer, 16));
return new PlcUINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_PropDataType)) { // UINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedInt("", 16);
-
+ int value = readSimpleField("value", readUnsignedInt(readBuffer, 16));
return new PlcUINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Length_mm)) { // UINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedInt("", 16);
-
+ int value = readSimpleField("value", readUnsignedInt(readBuffer, 16));
return new PlcUINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_UElCurrentmA)) { // UINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedInt("", 16);
-
+ int value = readSimpleField("value", readUnsignedInt(readBuffer, 16));
return new PlcUINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Brightness)) { // UINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedInt("", 16);
-
+ int value = readSimpleField("value", readUnsignedInt(readBuffer, 16));
return new PlcUINT(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Absolute_Colour_Temperature)) { // UINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedInt("", 16);
-
+ int value = readSimpleField("value", readUnsignedInt(readBuffer, 16));
return new PlcUINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Value_2_Count)) { // INT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Short value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readShort("", 16);
-
+ short value = readSimpleField("value", readSignedShort(readBuffer, 16));
return new PlcINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_DeltaTimeMsec)) { // INT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Short value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readShort("", 16);
-
+ short value = readSimpleField("value", readSignedShort(readBuffer, 16));
return new PlcINT(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_DeltaTime10Msec)) { // INT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Short value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readShort("", 16);
-
+ short value = readSimpleField("value", readSignedShort(readBuffer, 16));
return new PlcINT(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_DeltaTime100Msec)) { // INT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Short value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readShort("", 16);
-
+ short value = readSimpleField("value", readSignedShort(readBuffer, 16));
return new PlcINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_DeltaTimeSec)) { // INT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Short value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readShort("", 16);
-
+ short value = readSimpleField("value", readSignedShort(readBuffer, 16));
return new PlcINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_DeltaTimeMin)) { // INT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Short value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readShort("", 16);
-
+ short value = readSimpleField("value", readSignedShort(readBuffer, 16));
return new PlcINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_DeltaTimeHrs)) { // INT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Short value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readShort("", 16);
-
+ short value = readSimpleField("value", readSignedShort(readBuffer, 16));
return new PlcINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Percent_V16)) { // INT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Short value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readShort("", 16);
-
+ short value = readSimpleField("value", readSignedShort(readBuffer, 16));
return new PlcINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Rotation_Angle)) { // INT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Short value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readShort("", 16);
-
+ short value = readSimpleField("value", readSignedShort(readBuffer, 16));
return new PlcINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Length_m)) { // INT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Short value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readShort("", 16);
-
+ short value = readSimpleField("value", readSignedShort(readBuffer, 16));
return new PlcINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Value_Temp)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 16);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 16));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Value_Tempd)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 16);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 16));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Value_Tempa)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 16);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 16));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Value_Lux)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 16);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 16));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Value_Wsp)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 16);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 16));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Value_Pres)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 16);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 16));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Humidity)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 16);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 16));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_AirQuality)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 16);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 16));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Value_AirFlow)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 16);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 16));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Value_Time1)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 16);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 16));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Value_Time2)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 16);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 16));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Value_Volt)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 16);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 16));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Value_Curr)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 16);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 16));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_PowerDensity)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 16);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 16));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_KelvinPerPercent)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 16);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 16));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Power)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 16);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 16));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Volume_Flow)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 16);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 16));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Rain_Amount)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 16);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 16));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Value_Temp_F)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 16);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 16));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Value_Wsp_kmh)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 16);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 16));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Absolute_Humidity)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 16);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 16));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Concentration_ygm3)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 16);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 16));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Coefficient)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 16);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 16));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_TimeOfDay)) { // Struct
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
+ byte day = readSimpleField("day", readUnsignedByte(readBuffer, 3));
- // Simple Field (day)
- Byte day = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedByte("", 3);
+ byte hour = readSimpleField("hour", readUnsignedByte(readBuffer, 5));
- // Simple Field (hour)
- Byte hour = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedByte("", 5);
-
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 2);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
+ Byte reservedField1 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 2), (byte) 0x00);
- // Simple Field (minutes)
- Byte minutes = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedByte("", 6);
-
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 2);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
+ byte minutes = readSimpleField("minutes", readUnsignedByte(readBuffer, 6));
- // Simple Field (seconds)
- Byte seconds = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedByte("", 6);
+ Byte reservedField2 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 2), (byte) 0x00);
- Map<String, PlcValue> _map = new HashMap<>();
- _map.put("day", new PlcSINT(day));
- _map.put("hour", new PlcSINT(hour));
- _map.put("minutes", new PlcSINT(minutes));
- _map.put("seconds", new PlcSINT(seconds));
+ byte seconds = readSimpleField("seconds", readUnsignedByte(readBuffer, 6));
+ Map<String, PlcValue> _map = new HashMap<>();
+ _map.put("day", new PlcUSINT(day));
+ _map.put("hour", new PlcUSINT(hour));
+ _map.put("minutes", new PlcUSINT(minutes));
+ _map.put("seconds", new PlcUSINT(seconds));
return new PlcStruct(_map);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Date)) { // Struct
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 3);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (dayOfMonth)
- Byte dayOfMonth = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 5);
-
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 4);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
+ Byte reservedField1 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 3), (byte) 0x00);
- // Simple Field (month)
- Byte month = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedByte("", 4);
-
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- byte reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedByte("", 1);
- if (reserved != (byte) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
+ byte dayOfMonth = readSimpleField("dayOfMonth", readUnsignedByte(readBuffer, 5));
- // Simple Field (year)
- Byte year = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedByte("", 7);
+ Byte reservedField2 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 4), (byte) 0x00);
- Map<String, PlcValue> _map = new HashMap<>();
- _map.put("dayOfMonth", new PlcSINT(dayOfMonth));
- _map.put("month", new PlcSINT(month));
- _map.put("year", new PlcSINT(year));
+ byte month = readSimpleField("month", readUnsignedByte(readBuffer, 4));
+
+ Byte reservedField3 =
+ readReservedField("reserved", readUnsignedByte(readBuffer, 1), (byte) 0x00);
+ byte year = readSimpleField("year", readUnsignedByte(readBuffer, 7));
+
+ Map<String, PlcValue> _map = new HashMap<>();
+ _map.put("dayOfMonth", new PlcUSINT(dayOfMonth));
+ _map.put("month", new PlcUSINT(month));
+ _map.put("year", new PlcUSINT(year));
return new PlcStruct(_map);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_4_Ucount)) { // UDINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Long value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedLong("", 32);
-
+ long value = readSimpleField("value", readUnsignedLong(readBuffer, 32));
return new PlcUDINT(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_LongTimePeriod_Sec)) { // UDINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Long value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedLong("", 32);
-
+ long value = readSimpleField("value", readUnsignedLong(readBuffer, 32));
return new PlcUDINT(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_LongTimePeriod_Min)) { // UDINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Long value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedLong("", 32);
-
+ long value = readSimpleField("value", readUnsignedLong(readBuffer, 32));
return new PlcUDINT(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_LongTimePeriod_Hrs)) { // UDINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Long value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedLong("", 32);
-
+ long value = readSimpleField("value", readUnsignedLong(readBuffer, 32));
return new PlcUDINT(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_VolumeLiquid_Litre)) { // UDINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Long value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedLong("", 32);
-
+ long value = readSimpleField("value", readUnsignedLong(readBuffer, 32));
return new PlcUDINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Volume_m_3)) { // UDINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Long value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readUnsignedLong("", 32);
-
+ long value = readSimpleField("value", readUnsignedLong(readBuffer, 32));
return new PlcUDINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Value_4_Count)) { // DINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readInt("", 32);
-
+ int value = readSimpleField("value", readSignedInt(readBuffer, 32));
return new PlcDINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_FlowRate_m3h)) { // DINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readInt("", 32);
-
+ int value = readSimpleField("value", readSignedInt(readBuffer, 32));
return new PlcDINT(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_ActiveEnergy)) { // DINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readInt("", 32);
-
+ int value = readSimpleField("value", readSignedInt(readBuffer, 32));
return new PlcDINT(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_ApparantEnergy)) { // DINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readInt("", 32);
-
+ int value = readSimpleField("value", readSignedInt(readBuffer, 32));
return new PlcDINT(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_ReactiveEnergy)) { // DINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readInt("", 32);
-
+ int value = readSimpleField("value", readSignedInt(readBuffer, 32));
return new PlcDINT(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_ActiveEnergy_kWh)) { // DINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readInt("", 32);
-
+ int value = readSimpleField("value", readSignedInt(readBuffer, 32));
return new PlcDINT(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_ApparantEnergy_kVAh)) { // DINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readInt("", 32);
-
+ int value = readSimpleField("value", readSignedInt(readBuffer, 32));
return new PlcDINT(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_ReactiveEnergy_kVARh)) { // DINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readInt("", 32);
-
+ int value = readSimpleField("value", readSignedInt(readBuffer, 32));
return new PlcDINT(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_ActiveEnergy_MWh)) { // DINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readInt("", 32);
-
+ int value = readSimpleField("value", readSignedInt(readBuffer, 32));
return new PlcDINT(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_LongDeltaTimeSec)) { // DINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readInt("", 32);
-
+ int value = readSimpleField("value", readSignedInt(readBuffer, 32));
return new PlcDINT(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_DeltaVolumeLiquid_Litre)) { // DINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readInt("", 32);
-
+ int value = readSimpleField("value", readSignedInt(readBuffer, 32));
return new PlcDINT(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_DeltaVolume_m_3)) { // DINT
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Integer value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readInt("", 32);
-
+ int value = readSimpleField("value", readSignedInt(readBuffer, 32));
return new PlcDINT(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Acceleration)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Acceleration_Angular)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Activation_Energy)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Activity)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Value_Mol)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Amplitude)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_AngleRad)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_AngleDeg)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Angular_Momentum)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Angular_Velocity)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Value_Area)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Capacitance)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Charge_DensitySurface)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Charge_DensityVolume)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Compressibility)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Conductance)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Electrical_Conductivity)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Value_Density)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Electric_Charge)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Electric_Current)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Electric_CurrentDensity)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Electric_DipoleMoment)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Electric_Displacement)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Electric_FieldStrength)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Electric_Flux)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Electric_FluxDensity)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Electric_Polarization)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Electric_Potential)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Electric_PotentialDifference)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_ElectromagneticMoment)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Electromotive_Force)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
- return new PlcREAL(value);
- } else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Value_Energy)) { // REAL
-
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
+ return new PlcREAL(value);
+ } else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Value_Energy)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Value_Force)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Frequency)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Angular_Frequency)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Heat_Capacity)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Heat_FlowRate)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Heat_Quantity)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Impedance)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Value_Length)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Light_Quantity)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Luminance)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Luminous_Flux)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Luminous_Intensity)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Magnetic_FieldStrength)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Magnetic_Flux)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Magnetic_FluxDensity)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Magnetic_Moment)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Magnetic_Polarization)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Magnetization)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_MagnetomotiveForce)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Value_Mass)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_MassFlux)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Momentum)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Phase_AngleRad)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Phase_AngleDeg)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Value_Power)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Power_Factor)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Pressure)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Reactance)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Resistance)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Resistivity)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_SelfInductance)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_SolidAngle)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(
datapointType, KnxDatapointType.DPT_Value_Sound_Intensity)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Value_Speed)) { // REAL
+ Short reservedField0 =
+ readReservedField("reserved", readUnsignedShort(readBuffer, 8), (short) 0x00);
- // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
- {
- short reserved = /*TODO: migrate me*/ /*TODO: migrate me*/
- readBuffer.readUnsignedShort("", 8);
- if (reserved != (short) 0x00) {
- LOGGER.info(
- "Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
- }
- }
-
- // Simple Field (value)
- Float value = /*TODO: migrate me*/ /*TODO: migrate me*/ readBuffer.readFloat("", 32);
-
+ float value = readSimpleField("value", readFloat(readBuffer, 32));
return new PlcREAL(value);
} else if (EvaluationHelper.equals(datapointType, KnxDatapointType.DPT_Value_Stress)) { // REAL
+ Short reservedField0 =
... 29695 lines suppressed ...