You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@plc4x.apache.org by sr...@apache.org on 2021/11/30 12:38:11 UTC
[plc4x] 02/02: feat(bacnet): implement BACnetTagApplicationDate and BACnetTagApplicationTime
This is an automated email from the ASF dual-hosted git repository.
sruehl pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/plc4x.git
commit f19d8f79f77ff18d356e858974396c785aa4042e
Author: Sebastian Rühl <sr...@apache.org>
AuthorDate: Tue Nov 30 13:38:00 2021 +0100
feat(bacnet): implement BACnetTagApplicationDate and BACnetTagApplicationTime
+ fixed golang not propagating virtual fields
+ fixed virtual field assignment with field indirection
---
.../language/go/GoLanguageTemplateHelper.java | 24 +--
.../resources/templates/go/model-template.go.ftlh | 6 +-
.../bacnetip/readwrite/model/BACnetComplexTag.go | 9 +-
.../readwrite/model/BACnetComplexTagBitString.go | 10 +-
.../model/BACnetComplexTagCharacterString.go | 10 +-
.../readwrite/model/BACnetComplexTagDate.go | 165 +++++++++++++++++++-
.../readwrite/model/BACnetComplexTagEnumerated.go | 8 +-
.../readwrite/model/BACnetComplexTagOctetString.go | 8 +-
.../model/BACnetComplexTagSignedInteger.go | 16 +-
.../readwrite/model/BACnetComplexTagTime.go | 125 ++++++++++++++-
.../model/BACnetComplexTagUnsignedInteger.go | 16 +-
.../plc4go/bacnetip/readwrite/model/BACnetTag.go | 9 +-
.../model/BACnetTagApplicationCharacterString.go | 10 +-
.../readwrite/model/BACnetTagApplicationDate.go | 173 ++++++++++++++++++++-
.../model/BACnetTagApplicationOctetString.go | 8 +-
.../model/BACnetTagApplicationSignedInteger.go | 16 +-
.../readwrite/model/BACnetTagApplicationTime.go | 125 ++++++++++++++-
.../model/BACnetTagApplicationUnsignedInteger.go | 16 +-
...UnconfirmedServiceRequestTimeSynchronization.go | 69 +++++++-
.../resources/protocols/bacnetip/bacnetip.mspec | 49 ++++++
20 files changed, 797 insertions(+), 75 deletions(-)
diff --git a/code-generation/language-go/src/main/java/org/apache/plc4x/language/go/GoLanguageTemplateHelper.java b/code-generation/language-go/src/main/java/org/apache/plc4x/language/go/GoLanguageTemplateHelper.java
index 9a294ad..492fb35 100644
--- a/code-generation/language-go/src/main/java/org/apache/plc4x/language/go/GoLanguageTemplateHelper.java
+++ b/code-generation/language-go/src/main/java/org/apache/plc4x/language/go/GoLanguageTemplateHelper.java
@@ -360,16 +360,16 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp
}
public String getWriteBufferWriteMethodCall(String logicalName, SimpleTypeReference simpleTypeReference, Term valueTerm, TypedField field, String... writerArgs) {
- if(valueTerm instanceof BooleanLiteral) {
+ if (valueTerm instanceof BooleanLiteral) {
return getWriteBufferWriteMethodCall(logicalName, simpleTypeReference, Boolean.toString(((BooleanLiteral) valueTerm).getValue()), field, writerArgs);
}
- if(valueTerm instanceof NumericLiteral) {
+ if (valueTerm instanceof NumericLiteral) {
return getWriteBufferWriteMethodCall(logicalName, simpleTypeReference, ((NumericLiteral) valueTerm).getNumber().toString(), field, writerArgs);
}
- if(valueTerm instanceof HexadecimalLiteral) {
+ if (valueTerm instanceof HexadecimalLiteral) {
return getWriteBufferWriteMethodCall(logicalName, simpleTypeReference, ((HexadecimalLiteral) valueTerm).getHexString(), field, writerArgs);
}
- if(valueTerm instanceof StringLiteral) {
+ if (valueTerm instanceof StringLiteral) {
return getWriteBufferWriteMethodCall(logicalName, simpleTypeReference, "\"" + ((StringLiteral) valueTerm).getValue() + "\"", field, writerArgs);
}
throw new RuntimeException("Outputting " + valueTerm.toString() + " not implemented yet. Please continue defining other types in the GoLanguageHelper.getWriteBufferWriteMethodCall.");
@@ -558,13 +558,14 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp
Term a = binaryTerm.getA();
Term b = binaryTerm.getB();
String operation = binaryTerm.getOperation();
+ String castExpressionForTypeReference = getCastExpressionForTypeReference(fieldType);
switch (operation) {
case "^":
tracer = tracer.dive("^");
emitRequiredImport("math");
return tracer + "Math.pow(" +
- getCastExpressionForTypeReference(fieldType) + "(" + toExpression(field, fieldType, a, parserArguments, serializerArguments, serialize, false) + "), " +
- getCastExpressionForTypeReference(fieldType) + "(" + toExpression(field, fieldType, b, parserArguments, serializerArguments, serialize, false) + "))";
+ castExpressionForTypeReference + "(" + toExpression(field, fieldType, a, parserArguments, serializerArguments, serialize, false) + "), " +
+ castExpressionForTypeReference + "(" + toExpression(field, fieldType, b, parserArguments, serializerArguments, serialize, false) + "))";
// If we start casting for comparisons, equals or non equals, really messy things happen.
case "==":
case "!=":
@@ -577,9 +578,9 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp
// Except for doing a nil or not-nil check :-(
// So in case of such a check, we need to suppress the pointer-access.
boolean suppressPointerAccessOverride = (operation.equals("==") || operation.equals("!=")) && ((a instanceof NullLiteral) || (b instanceof NullLiteral));
- return tracer + "bool((" + toExpression(field, null, a, parserArguments, serializerArguments, serialize, suppressPointerAccessOverride) + ") " +
- operation +
- " (" + toExpression(field, null, b, parserArguments, serializerArguments, serialize, suppressPointerAccessOverride) + "))";
+ String aExpression = toExpression(field, null, a, parserArguments, serializerArguments, serialize, suppressPointerAccessOverride);
+ String bExpression = toExpression(field, null, b, parserArguments, serializerArguments, serialize, suppressPointerAccessOverride);
+ return tracer + "bool((" + aExpression + ") " + operation + " (" + bExpression + "))";
default:
tracer = tracer.dive("default");
if (fieldType instanceof StringTypeReference) {
@@ -588,9 +589,10 @@ public class GoLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelp
operation + " " +
toExpression(field, fieldType, b, parserArguments, serializerArguments, serialize, false);
}
- return tracer + getCastExpressionForTypeReference(fieldType) + "(" + toExpression(field, fieldType, a, parserArguments, serializerArguments, serialize, false) + ") " +
+ return tracer +
+ castExpressionForTypeReference + "(" + toExpression(field, fieldType, a, parserArguments, serializerArguments, serialize, false) + ") " +
operation + " " +
- getCastExpressionForTypeReference(fieldType) + "(" + toExpression(field, fieldType, b, parserArguments, serializerArguments, serialize, false) + ")";
+ castExpressionForTypeReference + "(" + toExpression(field, fieldType, b, parserArguments, serializerArguments, serialize, false) + ")";
}
}
diff --git a/code-generation/language-go/src/main/resources/templates/go/model-template.go.ftlh b/code-generation/language-go/src/main/resources/templates/go/model-template.go.ftlh
index a5981b2..356592b 100644
--- a/code-generation/language-go/src/main/resources/templates/go/model-template.go.ftlh
+++ b/code-generation/language-go/src/main/resources/templates/go/model-template.go.ftlh
@@ -1085,7 +1085,8 @@ func ${type.name}Parse(readBuffer utils.ReadBuffer<#if hasParserArguments>, ${pa
<#assign virtualField = field.asVirtualField().orElseThrow()>
// Virtual field
- ${virtualField.name} := ${helper.toParseExpression(virtualField, virtualField.type, virtualField.valueExpression, parserArguments)}
+ _${virtualField.name} := ${helper.toParseExpression(virtualField, virtualField.type, virtualField.valueExpression, parserArguments)}
+ ${virtualField.name} := ${helper.getLanguageTypeNameForTypeReference(virtualField.type)}(_${virtualField.name})
<#break>
</#switch>
</#list>
@@ -1104,6 +1105,9 @@ func ${type.name}Parse(readBuffer utils.ReadBuffer<#if hasParserArguments>, ${pa
<#list type.propertyFields as field>
${field.name?cap_first}: <#if helper.isComplex(field) && !helper.isEnumField(field) && !field.isArrayField()>Cast${helper.getLanguageTypeNameForField(field)}(</#if>${field.name}<#if helper.isComplex(field) && !helper.isEnumField(field) && !field.isArrayField()>)</#if>,
</#list>
+ <#list type.virtualFields as field>
+ ${field.name?cap_first}: <#if helper.isComplex(field) && !helper.isEnumField(field) && !field.isArrayField()>Cast${helper.getLanguageTypeNameForField(field)}(</#if>${field.name}<#if helper.isComplex(field) && !helper.isEnumField(field) && !field.isArrayField()>)</#if>,
+ </#list>
Parent: &${type.parentType.name}{},
}
_child.Parent.Child = _child
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTag.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTag.go
index 112b8b9..6068e88 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTag.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTag.go
@@ -169,10 +169,12 @@ func BACnetComplexTagParse(readBuffer utils.ReadBuffer, tagNumberArgument uint8,
}
// Virtual field
- actualTagNumber := utils.InlineIf(bool((tagNumber) < (15)), func() interface{} { return uint8(tagNumber) }, func() interface{} { return uint8((*extTagNumber)) }).(uint8)
+ _actualTagNumber := utils.InlineIf(bool((tagNumber) < (15)), func() interface{} { return uint8(tagNumber) }, func() interface{} { return uint8((*extTagNumber)) }).(uint8)
+ actualTagNumber := uint8(_actualTagNumber)
// Virtual field
- isPrimitiveAndNotBoolean := bool(!(bool(bool((lengthValueType) == (6))))) && bool(bool((tagNumber) != (1)))
+ _isPrimitiveAndNotBoolean := bool(!(bool(bool((lengthValueType) == (6))))) && bool(bool((tagNumber) != (1)))
+ isPrimitiveAndNotBoolean := bool(_isPrimitiveAndNotBoolean)
// Optional Field (extLength) (Can be skipped, if a given expression evaluates to false)
var extLength *uint8 = nil
@@ -205,13 +207,14 @@ func BACnetComplexTagParse(readBuffer utils.ReadBuffer, tagNumberArgument uint8,
}
// Virtual field
- actualLength := utils.InlineIf(bool(bool((lengthValueType) == (5))) && bool(bool((*extLength) == (255))), func() interface{} { return uint32((*extExtExtLength)) }, func() interface{} {
+ _actualLength := utils.InlineIf(bool(bool((lengthValueType) == (5))) && bool(bool((*extLength) == (255))), func() interface{} { return uint32((*extExtExtLength)) }, func() interface{} {
return uint32(uint32(utils.InlineIf(bool(bool((lengthValueType) == (5))) && bool(bool((*extLength) == (254))), func() interface{} { return uint32((*extExtLength)) }, func() interface{} {
return uint32(uint32(utils.InlineIf(bool((lengthValueType) == (5)), func() interface{} { return uint32((*extLength)) }, func() interface{} {
return uint32(uint32(utils.InlineIf(isPrimitiveAndNotBoolean, func() interface{} { return uint32(lengthValueType) }, func() interface{} { return uint32(uint32(0)) }).(uint32)))
}).(uint32)))
}).(uint32)))
}).(uint32)
+ actualLength := uint32(_actualLength)
// Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
var _parent *BACnetComplexTag
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagBitString.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagBitString.go
index fb68445..7922d9a 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagBitString.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagBitString.go
@@ -121,7 +121,8 @@ func BACnetComplexTagBitStringParse(readBuffer utils.ReadBuffer, tagNumberArgume
}
// Virtual field
- actualLengthInBit := uint16(actualLength) * uint16(uint16(8))
+ _actualLengthInBit := uint16(actualLength) * uint16(uint16(8))
+ actualLengthInBit := uint16(_actualLengthInBit)
// Simple Field (unusedBits)
unusedBits, _unusedBitsErr := readBuffer.ReadUint8("unusedBits", 8)
@@ -154,9 +155,10 @@ func BACnetComplexTagBitStringParse(readBuffer utils.ReadBuffer, tagNumberArgume
// Create a partially initialized instance
_child := &BACnetComplexTagBitString{
- UnusedBits: unusedBits,
- Data: data,
- Parent: &BACnetComplexTag{},
+ UnusedBits: unusedBits,
+ Data: data,
+ ActualLengthInBit: actualLengthInBit,
+ Parent: &BACnetComplexTag{},
}
_child.Parent.Child = _child
return _child.Parent, nil
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagCharacterString.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagCharacterString.go
index c074ead..e727618 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagCharacterString.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagCharacterString.go
@@ -131,7 +131,8 @@ func BACnetComplexTagCharacterStringParse(readBuffer utils.ReadBuffer, tagNumber
}
// Virtual field
- actualLengthInBit := uint16(uint16(actualLength)*uint16(uint16(8))) - uint16(uint16(8))
+ _actualLengthInBit := uint16(uint16(actualLength)*uint16(uint16(8))) - uint16(uint16(8))
+ actualLengthInBit := uint16(_actualLengthInBit)
// Simple Field (value)
value, _valueErr := readBuffer.ReadString("value", uint32(actualLengthInBit))
@@ -145,9 +146,10 @@ func BACnetComplexTagCharacterStringParse(readBuffer utils.ReadBuffer, tagNumber
// Create a partially initialized instance
_child := &BACnetComplexTagCharacterString{
- Encoding: encoding,
- Value: value,
- Parent: &BACnetComplexTag{},
+ Encoding: encoding,
+ Value: value,
+ ActualLengthInBit: actualLengthInBit,
+ Parent: &BACnetComplexTag{},
}
_child.Parent.Child = _child
return _child.Parent, nil
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagDate.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagDate.go
index a586d3f..9153b9d 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagDate.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagDate.go
@@ -21,13 +21,28 @@ package model
import (
"github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+ "github.com/pkg/errors"
)
// Code generated by code-generation. DO NOT EDIT.
// The data-structure of this message
type BACnetComplexTagDate struct {
- Parent *BACnetComplexTag
+ YearMinus1900 int8
+ Month int8
+ DayOfMonth int8
+ DayOfWeek int8
+ Wildcard int8
+ YearIsWildcard bool
+ MonthIsWildcard bool
+ OddMonthWildcard bool
+ EvenMonthWildcard bool
+ DayOfMonthIsWildcard bool
+ LastDayOfMonthWildcard bool
+ OddDayOfMonthWildcard bool
+ EvenDayOfMonthWildcard bool
+ DayOfWeekIsWildcard bool
+ Parent *BACnetComplexTag
}
// The corresponding interface
@@ -54,9 +69,13 @@ func (m *BACnetComplexTagDate) InitializeParent(parent *BACnetComplexTag, tagNum
m.Parent.ExtExtExtLength = extExtExtLength
}
-func NewBACnetComplexTagDate(tagNumber uint8, tagClass TagClass, lengthValueType uint8, extTagNumber *uint8, extLength *uint8, extExtLength *uint16, extExtExtLength *uint32) *BACnetComplexTag {
+func NewBACnetComplexTagDate(yearMinus1900 int8, month int8, dayOfMonth int8, dayOfWeek int8, tagNumber uint8, tagClass TagClass, lengthValueType uint8, extTagNumber *uint8, extLength *uint8, extExtLength *uint16, extExtExtLength *uint32) *BACnetComplexTag {
child := &BACnetComplexTagDate{
- Parent: NewBACnetComplexTag(tagNumber, tagClass, lengthValueType, extTagNumber, extLength, extExtLength, extExtExtLength),
+ YearMinus1900: yearMinus1900,
+ Month: month,
+ DayOfMonth: dayOfMonth,
+ DayOfWeek: dayOfWeek,
+ Parent: NewBACnetComplexTag(tagNumber, tagClass, lengthValueType, extTagNumber, extLength, extExtLength, extExtExtLength),
}
child.Parent.Child = child
return child.Parent
@@ -92,6 +111,38 @@ func (m *BACnetComplexTagDate) LengthInBits() uint16 {
func (m *BACnetComplexTagDate) LengthInBitsConditional(lastItem bool) uint16 {
lengthInBits := uint16(m.Parent.ParentLengthInBits())
+ // A virtual field doesn't have any in- or output.
+
+ // Simple field (yearMinus1900)
+ lengthInBits += 8
+
+ // A virtual field doesn't have any in- or output.
+
+ // Simple field (month)
+ lengthInBits += 8
+
+ // A virtual field doesn't have any in- or output.
+
+ // A virtual field doesn't have any in- or output.
+
+ // A virtual field doesn't have any in- or output.
+
+ // Simple field (dayOfMonth)
+ lengthInBits += 8
+
+ // A virtual field doesn't have any in- or output.
+
+ // A virtual field doesn't have any in- or output.
+
+ // A virtual field doesn't have any in- or output.
+
+ // A virtual field doesn't have any in- or output.
+
+ // Simple field (dayOfWeek)
+ lengthInBits += 8
+
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -104,13 +155,91 @@ func BACnetComplexTagDateParse(readBuffer utils.ReadBuffer, tagNumberArgument ui
return nil, pullErr
}
+ // Virtual field
+ _wildcard := 0xFF
+ wildcard := int8(_wildcard)
+
+ // Simple Field (yearMinus1900)
+ yearMinus1900, _yearMinus1900Err := readBuffer.ReadInt8("yearMinus1900", 8)
+ if _yearMinus1900Err != nil {
+ return nil, errors.Wrap(_yearMinus1900Err, "Error parsing 'yearMinus1900' field")
+ }
+
+ // Virtual field
+ _yearIsWildcard := bool((yearMinus1900) == (wildcard))
+ yearIsWildcard := bool(_yearIsWildcard)
+
+ // Simple Field (month)
+ month, _monthErr := readBuffer.ReadInt8("month", 8)
+ if _monthErr != nil {
+ return nil, errors.Wrap(_monthErr, "Error parsing 'month' field")
+ }
+
+ // Virtual field
+ _monthIsWildcard := bool((month) == (wildcard))
+ monthIsWildcard := bool(_monthIsWildcard)
+
+ // Virtual field
+ _oddMonthWildcard := bool((month) == (13))
+ oddMonthWildcard := bool(_oddMonthWildcard)
+
+ // Virtual field
+ _evenMonthWildcard := bool((month) == (14))
+ evenMonthWildcard := bool(_evenMonthWildcard)
+
+ // Simple Field (dayOfMonth)
+ dayOfMonth, _dayOfMonthErr := readBuffer.ReadInt8("dayOfMonth", 8)
+ if _dayOfMonthErr != nil {
+ return nil, errors.Wrap(_dayOfMonthErr, "Error parsing 'dayOfMonth' field")
+ }
+
+ // Virtual field
+ _dayOfMonthIsWildcard := bool((dayOfMonth) == (wildcard))
+ dayOfMonthIsWildcard := bool(_dayOfMonthIsWildcard)
+
+ // Virtual field
+ _lastDayOfMonthWildcard := bool((dayOfMonth) == (32))
+ lastDayOfMonthWildcard := bool(_lastDayOfMonthWildcard)
+
+ // Virtual field
+ _oddDayOfMonthWildcard := bool((dayOfMonth) == (33))
+ oddDayOfMonthWildcard := bool(_oddDayOfMonthWildcard)
+
+ // Virtual field
+ _evenDayOfMonthWildcard := bool((dayOfMonth) == (34))
+ evenDayOfMonthWildcard := bool(_evenDayOfMonthWildcard)
+
+ // Simple Field (dayOfWeek)
+ dayOfWeek, _dayOfWeekErr := readBuffer.ReadInt8("dayOfWeek", 8)
+ if _dayOfWeekErr != nil {
+ return nil, errors.Wrap(_dayOfWeekErr, "Error parsing 'dayOfWeek' field")
+ }
+
+ // Virtual field
+ _dayOfWeekIsWildcard := bool((dayOfWeek) == (wildcard))
+ dayOfWeekIsWildcard := bool(_dayOfWeekIsWildcard)
+
if closeErr := readBuffer.CloseContext("BACnetComplexTagDate"); closeErr != nil {
return nil, closeErr
}
// Create a partially initialized instance
_child := &BACnetComplexTagDate{
- Parent: &BACnetComplexTag{},
+ YearMinus1900: yearMinus1900,
+ Month: month,
+ DayOfMonth: dayOfMonth,
+ DayOfWeek: dayOfWeek,
+ Wildcard: wildcard,
+ YearIsWildcard: yearIsWildcard,
+ MonthIsWildcard: monthIsWildcard,
+ OddMonthWildcard: oddMonthWildcard,
+ EvenMonthWildcard: evenMonthWildcard,
+ DayOfMonthIsWildcard: dayOfMonthIsWildcard,
+ LastDayOfMonthWildcard: lastDayOfMonthWildcard,
+ OddDayOfMonthWildcard: oddDayOfMonthWildcard,
+ EvenDayOfMonthWildcard: evenDayOfMonthWildcard,
+ DayOfWeekIsWildcard: dayOfWeekIsWildcard,
+ Parent: &BACnetComplexTag{},
}
_child.Parent.Child = _child
return _child.Parent, nil
@@ -122,6 +251,34 @@ func (m *BACnetComplexTagDate) Serialize(writeBuffer utils.WriteBuffer) error {
return pushErr
}
+ // Simple Field (yearMinus1900)
+ yearMinus1900 := int8(m.YearMinus1900)
+ _yearMinus1900Err := writeBuffer.WriteInt8("yearMinus1900", 8, (yearMinus1900))
+ if _yearMinus1900Err != nil {
+ return errors.Wrap(_yearMinus1900Err, "Error serializing 'yearMinus1900' field")
+ }
+
+ // Simple Field (month)
+ month := int8(m.Month)
+ _monthErr := writeBuffer.WriteInt8("month", 8, (month))
+ if _monthErr != nil {
+ return errors.Wrap(_monthErr, "Error serializing 'month' field")
+ }
+
+ // Simple Field (dayOfMonth)
+ dayOfMonth := int8(m.DayOfMonth)
+ _dayOfMonthErr := writeBuffer.WriteInt8("dayOfMonth", 8, (dayOfMonth))
+ if _dayOfMonthErr != nil {
+ return errors.Wrap(_dayOfMonthErr, "Error serializing 'dayOfMonth' field")
+ }
+
+ // Simple Field (dayOfWeek)
+ dayOfWeek := int8(m.DayOfWeek)
+ _dayOfWeekErr := writeBuffer.WriteInt8("dayOfWeek", 8, (dayOfWeek))
+ if _dayOfWeekErr != nil {
+ return errors.Wrap(_dayOfWeekErr, "Error serializing 'dayOfWeek' field")
+ }
+
if popErr := writeBuffer.PopContext("BACnetComplexTagDate"); popErr != nil {
return popErr
}
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagEnumerated.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagEnumerated.go
index 856de93..f76b168 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagEnumerated.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagEnumerated.go
@@ -116,7 +116,8 @@ func BACnetComplexTagEnumeratedParse(readBuffer utils.ReadBuffer, tagNumberArgum
}
// Virtual field
- actualLengthInBit := uint16(actualLength) * uint16(uint16(8))
+ _actualLengthInBit := uint16(actualLength) * uint16(uint16(8))
+ actualLengthInBit := uint16(_actualLengthInBit)
// Array field (data)
if pullErr := readBuffer.PullContext("data", utils.WithRenderAsList(true)); pullErr != nil {
@@ -143,8 +144,9 @@ func BACnetComplexTagEnumeratedParse(readBuffer utils.ReadBuffer, tagNumberArgum
// Create a partially initialized instance
_child := &BACnetComplexTagEnumerated{
- Data: data,
- Parent: &BACnetComplexTag{},
+ Data: data,
+ ActualLengthInBit: actualLengthInBit,
+ Parent: &BACnetComplexTag{},
}
_child.Parent.Child = _child
return _child.Parent, nil
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagOctetString.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagOctetString.go
index 418936f..3ba1409 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagOctetString.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagOctetString.go
@@ -114,7 +114,8 @@ func BACnetComplexTagOctetStringParse(readBuffer utils.ReadBuffer, tagNumberArgu
}
// Virtual field
- actualLengthInBit := uint16(actualLength) * uint16(uint16(8))
+ _actualLengthInBit := uint16(actualLength) * uint16(uint16(8))
+ actualLengthInBit := uint16(_actualLengthInBit)
// Simple Field (value)
value, _valueErr := readBuffer.ReadString("value", uint32(actualLengthInBit))
@@ -128,8 +129,9 @@ func BACnetComplexTagOctetStringParse(readBuffer utils.ReadBuffer, tagNumberArgu
// Create a partially initialized instance
_child := &BACnetComplexTagOctetString{
- Value: value,
- Parent: &BACnetComplexTag{},
+ Value: value,
+ ActualLengthInBit: actualLengthInBit,
+ Parent: &BACnetComplexTag{},
}
_child.Parent.Child = _child
return _child.Parent, nil
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagSignedInteger.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagSignedInteger.go
index 42f51c3..db7cc8d 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagSignedInteger.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagSignedInteger.go
@@ -146,7 +146,8 @@ func BACnetComplexTagSignedIntegerParse(readBuffer utils.ReadBuffer, tagNumberAr
}
// Virtual field
- isInt8 := bool((actualLength) == (1))
+ _isInt8 := bool((actualLength) == (1))
+ isInt8 := bool(_isInt8)
// Optional Field (valueInt8) (Can be skipped, if a given expression evaluates to false)
var valueInt8 *int8 = nil
@@ -159,7 +160,8 @@ func BACnetComplexTagSignedIntegerParse(readBuffer utils.ReadBuffer, tagNumberAr
}
// Virtual field
- isInt16 := bool((actualLength) == (2))
+ _isInt16 := bool((actualLength) == (2))
+ isInt16 := bool(_isInt16)
// Optional Field (valueInt16) (Can be skipped, if a given expression evaluates to false)
var valueInt16 *int16 = nil
@@ -172,7 +174,8 @@ func BACnetComplexTagSignedIntegerParse(readBuffer utils.ReadBuffer, tagNumberAr
}
// Virtual field
- isInt32 := bool((actualLength) == (3))
+ _isInt32 := bool((actualLength) == (3))
+ isInt32 := bool(_isInt32)
// Optional Field (valueInt32) (Can be skipped, if a given expression evaluates to false)
var valueInt32 *int32 = nil
@@ -185,7 +188,8 @@ func BACnetComplexTagSignedIntegerParse(readBuffer utils.ReadBuffer, tagNumberAr
}
// Virtual field
- isInt64 := bool((actualLength) == (4))
+ _isInt64 := bool((actualLength) == (4))
+ isInt64 := bool(_isInt64)
// Optional Field (valueInt64) (Can be skipped, if a given expression evaluates to false)
var valueInt64 *int64 = nil
@@ -207,6 +211,10 @@ func BACnetComplexTagSignedIntegerParse(readBuffer utils.ReadBuffer, tagNumberAr
ValueInt16: valueInt16,
ValueInt32: valueInt32,
ValueInt64: valueInt64,
+ IsInt8: isInt8,
+ IsInt16: isInt16,
+ IsInt32: isInt32,
+ IsInt64: isInt64,
Parent: &BACnetComplexTag{},
}
_child.Parent.Child = _child
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagTime.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagTime.go
index b6ba3b2..e8dcc69 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagTime.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagTime.go
@@ -21,13 +21,23 @@ package model
import (
"github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+ "github.com/pkg/errors"
)
// Code generated by code-generation. DO NOT EDIT.
// The data-structure of this message
type BACnetComplexTagTime struct {
- Parent *BACnetComplexTag
+ Hour int8
+ Minute int8
+ Second int8
+ Fractional int8
+ Wildcard int8
+ HourIsWildcard bool
+ MinuteIsWildcard bool
+ SecondIsWildcard bool
+ FractionalIsWildcard bool
+ Parent *BACnetComplexTag
}
// The corresponding interface
@@ -54,9 +64,13 @@ func (m *BACnetComplexTagTime) InitializeParent(parent *BACnetComplexTag, tagNum
m.Parent.ExtExtExtLength = extExtExtLength
}
-func NewBACnetComplexTagTime(tagNumber uint8, tagClass TagClass, lengthValueType uint8, extTagNumber *uint8, extLength *uint8, extExtLength *uint16, extExtExtLength *uint32) *BACnetComplexTag {
+func NewBACnetComplexTagTime(hour int8, minute int8, second int8, fractional int8, tagNumber uint8, tagClass TagClass, lengthValueType uint8, extTagNumber *uint8, extLength *uint8, extExtLength *uint16, extExtExtLength *uint32) *BACnetComplexTag {
child := &BACnetComplexTagTime{
- Parent: NewBACnetComplexTag(tagNumber, tagClass, lengthValueType, extTagNumber, extLength, extExtLength, extExtExtLength),
+ Hour: hour,
+ Minute: minute,
+ Second: second,
+ Fractional: fractional,
+ Parent: NewBACnetComplexTag(tagNumber, tagClass, lengthValueType, extTagNumber, extLength, extExtLength, extExtExtLength),
}
child.Parent.Child = child
return child.Parent
@@ -92,6 +106,28 @@ func (m *BACnetComplexTagTime) LengthInBits() uint16 {
func (m *BACnetComplexTagTime) LengthInBitsConditional(lastItem bool) uint16 {
lengthInBits := uint16(m.Parent.ParentLengthInBits())
+ // A virtual field doesn't have any in- or output.
+
+ // Simple field (hour)
+ lengthInBits += 8
+
+ // A virtual field doesn't have any in- or output.
+
+ // Simple field (minute)
+ lengthInBits += 8
+
+ // A virtual field doesn't have any in- or output.
+
+ // Simple field (second)
+ lengthInBits += 8
+
+ // A virtual field doesn't have any in- or output.
+
+ // Simple field (fractional)
+ lengthInBits += 8
+
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -104,13 +140,66 @@ func BACnetComplexTagTimeParse(readBuffer utils.ReadBuffer, tagNumberArgument ui
return nil, pullErr
}
+ // Virtual field
+ _wildcard := 0xFF
+ wildcard := int8(_wildcard)
+
+ // Simple Field (hour)
+ hour, _hourErr := readBuffer.ReadInt8("hour", 8)
+ if _hourErr != nil {
+ return nil, errors.Wrap(_hourErr, "Error parsing 'hour' field")
+ }
+
+ // Virtual field
+ _hourIsWildcard := bool((hour) == (wildcard))
+ hourIsWildcard := bool(_hourIsWildcard)
+
+ // Simple Field (minute)
+ minute, _minuteErr := readBuffer.ReadInt8("minute", 8)
+ if _minuteErr != nil {
+ return nil, errors.Wrap(_minuteErr, "Error parsing 'minute' field")
+ }
+
+ // Virtual field
+ _minuteIsWildcard := bool((minute) == (wildcard))
+ minuteIsWildcard := bool(_minuteIsWildcard)
+
+ // Simple Field (second)
+ second, _secondErr := readBuffer.ReadInt8("second", 8)
+ if _secondErr != nil {
+ return nil, errors.Wrap(_secondErr, "Error parsing 'second' field")
+ }
+
+ // Virtual field
+ _secondIsWildcard := bool((second) == (wildcard))
+ secondIsWildcard := bool(_secondIsWildcard)
+
+ // Simple Field (fractional)
+ fractional, _fractionalErr := readBuffer.ReadInt8("fractional", 8)
+ if _fractionalErr != nil {
+ return nil, errors.Wrap(_fractionalErr, "Error parsing 'fractional' field")
+ }
+
+ // Virtual field
+ _fractionalIsWildcard := bool((fractional) == (wildcard))
+ fractionalIsWildcard := bool(_fractionalIsWildcard)
+
if closeErr := readBuffer.CloseContext("BACnetComplexTagTime"); closeErr != nil {
return nil, closeErr
}
// Create a partially initialized instance
_child := &BACnetComplexTagTime{
- Parent: &BACnetComplexTag{},
+ Hour: hour,
+ Minute: minute,
+ Second: second,
+ Fractional: fractional,
+ Wildcard: wildcard,
+ HourIsWildcard: hourIsWildcard,
+ MinuteIsWildcard: minuteIsWildcard,
+ SecondIsWildcard: secondIsWildcard,
+ FractionalIsWildcard: fractionalIsWildcard,
+ Parent: &BACnetComplexTag{},
}
_child.Parent.Child = _child
return _child.Parent, nil
@@ -122,6 +211,34 @@ func (m *BACnetComplexTagTime) Serialize(writeBuffer utils.WriteBuffer) error {
return pushErr
}
+ // Simple Field (hour)
+ hour := int8(m.Hour)
+ _hourErr := writeBuffer.WriteInt8("hour", 8, (hour))
+ if _hourErr != nil {
+ return errors.Wrap(_hourErr, "Error serializing 'hour' field")
+ }
+
+ // Simple Field (minute)
+ minute := int8(m.Minute)
+ _minuteErr := writeBuffer.WriteInt8("minute", 8, (minute))
+ if _minuteErr != nil {
+ return errors.Wrap(_minuteErr, "Error serializing 'minute' field")
+ }
+
+ // Simple Field (second)
+ second := int8(m.Second)
+ _secondErr := writeBuffer.WriteInt8("second", 8, (second))
+ if _secondErr != nil {
+ return errors.Wrap(_secondErr, "Error serializing 'second' field")
+ }
+
+ // Simple Field (fractional)
+ fractional := int8(m.Fractional)
+ _fractionalErr := writeBuffer.WriteInt8("fractional", 8, (fractional))
+ if _fractionalErr != nil {
+ return errors.Wrap(_fractionalErr, "Error serializing 'fractional' field")
+ }
+
if popErr := writeBuffer.PopContext("BACnetComplexTagTime"); popErr != nil {
return popErr
}
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagUnsignedInteger.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagUnsignedInteger.go
index 1151d9b..bd2bab1 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagUnsignedInteger.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetComplexTagUnsignedInteger.go
@@ -146,7 +146,8 @@ func BACnetComplexTagUnsignedIntegerParse(readBuffer utils.ReadBuffer, tagNumber
}
// Virtual field
- isUint8 := bool((actualLength) == (1))
+ _isUint8 := bool((actualLength) == (1))
+ isUint8 := bool(_isUint8)
// Optional Field (valueUint8) (Can be skipped, if a given expression evaluates to false)
var valueUint8 *uint8 = nil
@@ -159,7 +160,8 @@ func BACnetComplexTagUnsignedIntegerParse(readBuffer utils.ReadBuffer, tagNumber
}
// Virtual field
- isUint16 := bool((actualLength) == (2))
+ _isUint16 := bool((actualLength) == (2))
+ isUint16 := bool(_isUint16)
// Optional Field (valueUint16) (Can be skipped, if a given expression evaluates to false)
var valueUint16 *uint16 = nil
@@ -172,7 +174,8 @@ func BACnetComplexTagUnsignedIntegerParse(readBuffer utils.ReadBuffer, tagNumber
}
// Virtual field
- isUint32 := bool((actualLength) == (3))
+ _isUint32 := bool((actualLength) == (3))
+ isUint32 := bool(_isUint32)
// Optional Field (valueUint32) (Can be skipped, if a given expression evaluates to false)
var valueUint32 *uint32 = nil
@@ -185,7 +188,8 @@ func BACnetComplexTagUnsignedIntegerParse(readBuffer utils.ReadBuffer, tagNumber
}
// Virtual field
- isUint64 := bool((actualLength) == (4))
+ _isUint64 := bool((actualLength) == (4))
+ isUint64 := bool(_isUint64)
// Optional Field (valueUint64) (Can be skipped, if a given expression evaluates to false)
var valueUint64 *uint64 = nil
@@ -207,6 +211,10 @@ func BACnetComplexTagUnsignedIntegerParse(readBuffer utils.ReadBuffer, tagNumber
ValueUint16: valueUint16,
ValueUint32: valueUint32,
ValueUint64: valueUint64,
+ IsUint8: isUint8,
+ IsUint16: isUint16,
+ IsUint32: isUint32,
+ IsUint64: isUint64,
Parent: &BACnetComplexTag{},
}
_child.Parent.Child = _child
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTag.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTag.go
index 89a1e3b..db4529b 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTag.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTag.go
@@ -168,10 +168,12 @@ func BACnetTagParse(readBuffer utils.ReadBuffer) (*BACnetTag, error) {
}
// Virtual field
- actualTagNumber := utils.InlineIf(bool((tagNumber) < (15)), func() interface{} { return uint8(tagNumber) }, func() interface{} { return uint8((*extTagNumber)) }).(uint8)
+ _actualTagNumber := utils.InlineIf(bool((tagNumber) < (15)), func() interface{} { return uint8(tagNumber) }, func() interface{} { return uint8((*extTagNumber)) }).(uint8)
+ actualTagNumber := uint8(_actualTagNumber)
// Virtual field
- isPrimitiveAndNotBoolean := bool(!(bool(bool(bool((tagClass) == (TagClass_CONTEXT_SPECIFIC_TAGS))) && bool(bool((lengthValueType) == (6)))))) && bool(bool((tagNumber) != (1)))
+ _isPrimitiveAndNotBoolean := bool(!(bool(bool(bool((tagClass) == (TagClass_CONTEXT_SPECIFIC_TAGS))) && bool(bool((lengthValueType) == (6)))))) && bool(bool((tagNumber) != (1)))
+ isPrimitiveAndNotBoolean := bool(_isPrimitiveAndNotBoolean)
// Optional Field (extLength) (Can be skipped, if a given expression evaluates to false)
var extLength *uint8 = nil
@@ -204,13 +206,14 @@ func BACnetTagParse(readBuffer utils.ReadBuffer) (*BACnetTag, error) {
}
// Virtual field
- actualLength := utils.InlineIf(bool(bool((lengthValueType) == (5))) && bool(bool((*extLength) == (255))), func() interface{} { return uint32((*extExtExtLength)) }, func() interface{} {
+ _actualLength := utils.InlineIf(bool(bool((lengthValueType) == (5))) && bool(bool((*extLength) == (255))), func() interface{} { return uint32((*extExtExtLength)) }, func() interface{} {
return uint32(uint32(utils.InlineIf(bool(bool((lengthValueType) == (5))) && bool(bool((*extLength) == (254))), func() interface{} { return uint32((*extExtLength)) }, func() interface{} {
return uint32(uint32(utils.InlineIf(bool((lengthValueType) == (5)), func() interface{} { return uint32((*extLength)) }, func() interface{} {
return uint32(uint32(utils.InlineIf(isPrimitiveAndNotBoolean, func() interface{} { return uint32(lengthValueType) }, func() interface{} { return uint32(uint32(0)) }).(uint32)))
}).(uint32)))
}).(uint32)))
}).(uint32)
+ actualLength := uint32(_actualLength)
// Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
var _parent *BACnetTag
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationCharacterString.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationCharacterString.go
index bbd4c9b..6ca4d8f 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationCharacterString.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationCharacterString.go
@@ -130,7 +130,8 @@ func BACnetTagApplicationCharacterStringParse(readBuffer utils.ReadBuffer, actua
}
// Virtual field
- actualLengthInBit := uint16(uint16(actualLength)*uint16(uint16(8))) - uint16(uint16(8))
+ _actualLengthInBit := uint16(uint16(actualLength)*uint16(uint16(8))) - uint16(uint16(8))
+ actualLengthInBit := uint16(_actualLengthInBit)
// Simple Field (value)
value, _valueErr := readBuffer.ReadString("value", uint32(actualLengthInBit))
@@ -144,9 +145,10 @@ func BACnetTagApplicationCharacterStringParse(readBuffer utils.ReadBuffer, actua
// Create a partially initialized instance
_child := &BACnetTagApplicationCharacterString{
- Encoding: encoding,
- Value: value,
- Parent: &BACnetTag{},
+ Encoding: encoding,
+ Value: value,
+ ActualLengthInBit: actualLengthInBit,
+ Parent: &BACnetTag{},
}
_child.Parent.Child = _child
return _child.Parent, nil
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationDate.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationDate.go
index e8a0406..366bf95 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationDate.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationDate.go
@@ -21,13 +21,29 @@ package model
import (
"github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+ "github.com/pkg/errors"
)
// Code generated by code-generation. DO NOT EDIT.
// The data-structure of this message
type BACnetTagApplicationDate struct {
- Parent *BACnetTag
+ YearMinus1900 int8
+ Month int8
+ DayOfMonth int8
+ DayOfWeek int8
+ Wildcard int8
+ YearIsWildcard bool
+ Year int16
+ MonthIsWildcard bool
+ OddMonthWildcard bool
+ EvenMonthWildcard bool
+ DayOfMonthIsWildcard bool
+ LastDayOfMonthWildcard bool
+ OddDayOfMonthWildcard bool
+ EvenDayOfMonthWildcard bool
+ DayOfWeekIsWildcard bool
+ Parent *BACnetTag
}
// The corresponding interface
@@ -53,9 +69,13 @@ func (m *BACnetTagApplicationDate) InitializeParent(parent *BACnetTag, tagNumber
m.Parent.ExtExtExtLength = extExtExtLength
}
-func NewBACnetTagApplicationDate(tagNumber uint8, lengthValueType uint8, extTagNumber *uint8, extLength *uint8, extExtLength *uint16, extExtExtLength *uint32) *BACnetTag {
+func NewBACnetTagApplicationDate(yearMinus1900 int8, month int8, dayOfMonth int8, dayOfWeek int8, tagNumber uint8, lengthValueType uint8, extTagNumber *uint8, extLength *uint8, extExtLength *uint16, extExtExtLength *uint32) *BACnetTag {
child := &BACnetTagApplicationDate{
- Parent: NewBACnetTag(tagNumber, lengthValueType, extTagNumber, extLength, extExtLength, extExtExtLength),
+ YearMinus1900: yearMinus1900,
+ Month: month,
+ DayOfMonth: dayOfMonth,
+ DayOfWeek: dayOfWeek,
+ Parent: NewBACnetTag(tagNumber, lengthValueType, extTagNumber, extLength, extExtLength, extExtExtLength),
}
child.Parent.Child = child
return child.Parent
@@ -91,6 +111,40 @@ func (m *BACnetTagApplicationDate) LengthInBits() uint16 {
func (m *BACnetTagApplicationDate) LengthInBitsConditional(lastItem bool) uint16 {
lengthInBits := uint16(m.Parent.ParentLengthInBits())
+ // A virtual field doesn't have any in- or output.
+
+ // Simple field (yearMinus1900)
+ lengthInBits += 8
+
+ // A virtual field doesn't have any in- or output.
+
+ // A virtual field doesn't have any in- or output.
+
+ // Simple field (month)
+ lengthInBits += 8
+
+ // A virtual field doesn't have any in- or output.
+
+ // A virtual field doesn't have any in- or output.
+
+ // A virtual field doesn't have any in- or output.
+
+ // Simple field (dayOfMonth)
+ lengthInBits += 8
+
+ // A virtual field doesn't have any in- or output.
+
+ // A virtual field doesn't have any in- or output.
+
+ // A virtual field doesn't have any in- or output.
+
+ // A virtual field doesn't have any in- or output.
+
+ // Simple field (dayOfWeek)
+ lengthInBits += 8
+
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -103,13 +157,96 @@ func BACnetTagApplicationDateParse(readBuffer utils.ReadBuffer) (*BACnetTag, err
return nil, pullErr
}
+ // Virtual field
+ _wildcard := 0xFF
+ wildcard := int8(_wildcard)
+
+ // Simple Field (yearMinus1900)
+ yearMinus1900, _yearMinus1900Err := readBuffer.ReadInt8("yearMinus1900", 8)
+ if _yearMinus1900Err != nil {
+ return nil, errors.Wrap(_yearMinus1900Err, "Error parsing 'yearMinus1900' field")
+ }
+
+ // Virtual field
+ _yearIsWildcard := bool((yearMinus1900) == (wildcard))
+ yearIsWildcard := bool(_yearIsWildcard)
+
+ // Virtual field
+ _year := int16(yearMinus1900) + int16(int16(1900))
+ year := int16(_year)
+
+ // Simple Field (month)
+ month, _monthErr := readBuffer.ReadInt8("month", 8)
+ if _monthErr != nil {
+ return nil, errors.Wrap(_monthErr, "Error parsing 'month' field")
+ }
+
+ // Virtual field
+ _monthIsWildcard := bool((month) == (wildcard))
+ monthIsWildcard := bool(_monthIsWildcard)
+
+ // Virtual field
+ _oddMonthWildcard := bool((month) == (13))
+ oddMonthWildcard := bool(_oddMonthWildcard)
+
+ // Virtual field
+ _evenMonthWildcard := bool((month) == (14))
+ evenMonthWildcard := bool(_evenMonthWildcard)
+
+ // Simple Field (dayOfMonth)
+ dayOfMonth, _dayOfMonthErr := readBuffer.ReadInt8("dayOfMonth", 8)
+ if _dayOfMonthErr != nil {
+ return nil, errors.Wrap(_dayOfMonthErr, "Error parsing 'dayOfMonth' field")
+ }
+
+ // Virtual field
+ _dayOfMonthIsWildcard := bool((dayOfMonth) == (wildcard))
+ dayOfMonthIsWildcard := bool(_dayOfMonthIsWildcard)
+
+ // Virtual field
+ _lastDayOfMonthWildcard := bool((dayOfMonth) == (32))
+ lastDayOfMonthWildcard := bool(_lastDayOfMonthWildcard)
+
+ // Virtual field
+ _oddDayOfMonthWildcard := bool((dayOfMonth) == (33))
+ oddDayOfMonthWildcard := bool(_oddDayOfMonthWildcard)
+
+ // Virtual field
+ _evenDayOfMonthWildcard := bool((dayOfMonth) == (34))
+ evenDayOfMonthWildcard := bool(_evenDayOfMonthWildcard)
+
+ // Simple Field (dayOfWeek)
+ dayOfWeek, _dayOfWeekErr := readBuffer.ReadInt8("dayOfWeek", 8)
+ if _dayOfWeekErr != nil {
+ return nil, errors.Wrap(_dayOfWeekErr, "Error parsing 'dayOfWeek' field")
+ }
+
+ // Virtual field
+ _dayOfWeekIsWildcard := bool((dayOfWeek) == (wildcard))
+ dayOfWeekIsWildcard := bool(_dayOfWeekIsWildcard)
+
if closeErr := readBuffer.CloseContext("BACnetTagApplicationDate"); closeErr != nil {
return nil, closeErr
}
// Create a partially initialized instance
_child := &BACnetTagApplicationDate{
- Parent: &BACnetTag{},
+ YearMinus1900: yearMinus1900,
+ Month: month,
+ DayOfMonth: dayOfMonth,
+ DayOfWeek: dayOfWeek,
+ Wildcard: wildcard,
+ YearIsWildcard: yearIsWildcard,
+ Year: year,
+ MonthIsWildcard: monthIsWildcard,
+ OddMonthWildcard: oddMonthWildcard,
+ EvenMonthWildcard: evenMonthWildcard,
+ DayOfMonthIsWildcard: dayOfMonthIsWildcard,
+ LastDayOfMonthWildcard: lastDayOfMonthWildcard,
+ OddDayOfMonthWildcard: oddDayOfMonthWildcard,
+ EvenDayOfMonthWildcard: evenDayOfMonthWildcard,
+ DayOfWeekIsWildcard: dayOfWeekIsWildcard,
+ Parent: &BACnetTag{},
}
_child.Parent.Child = _child
return _child.Parent, nil
@@ -121,6 +258,34 @@ func (m *BACnetTagApplicationDate) Serialize(writeBuffer utils.WriteBuffer) erro
return pushErr
}
+ // Simple Field (yearMinus1900)
+ yearMinus1900 := int8(m.YearMinus1900)
+ _yearMinus1900Err := writeBuffer.WriteInt8("yearMinus1900", 8, (yearMinus1900))
+ if _yearMinus1900Err != nil {
+ return errors.Wrap(_yearMinus1900Err, "Error serializing 'yearMinus1900' field")
+ }
+
+ // Simple Field (month)
+ month := int8(m.Month)
+ _monthErr := writeBuffer.WriteInt8("month", 8, (month))
+ if _monthErr != nil {
+ return errors.Wrap(_monthErr, "Error serializing 'month' field")
+ }
+
+ // Simple Field (dayOfMonth)
+ dayOfMonth := int8(m.DayOfMonth)
+ _dayOfMonthErr := writeBuffer.WriteInt8("dayOfMonth", 8, (dayOfMonth))
+ if _dayOfMonthErr != nil {
+ return errors.Wrap(_dayOfMonthErr, "Error serializing 'dayOfMonth' field")
+ }
+
+ // Simple Field (dayOfWeek)
+ dayOfWeek := int8(m.DayOfWeek)
+ _dayOfWeekErr := writeBuffer.WriteInt8("dayOfWeek", 8, (dayOfWeek))
+ if _dayOfWeekErr != nil {
+ return errors.Wrap(_dayOfWeekErr, "Error serializing 'dayOfWeek' field")
+ }
+
if popErr := writeBuffer.PopContext("BACnetTagApplicationDate"); popErr != nil {
return popErr
}
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationOctetString.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationOctetString.go
index a2195a3..7a83010 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationOctetString.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationOctetString.go
@@ -113,7 +113,8 @@ func BACnetTagApplicationOctetStringParse(readBuffer utils.ReadBuffer, actualLen
}
// Virtual field
- actualLengthInBit := uint16(actualLength) * uint16(uint16(8))
+ _actualLengthInBit := uint16(actualLength) * uint16(uint16(8))
+ actualLengthInBit := uint16(_actualLengthInBit)
// Simple Field (value)
value, _valueErr := readBuffer.ReadString("value", uint32(actualLengthInBit))
@@ -127,8 +128,9 @@ func BACnetTagApplicationOctetStringParse(readBuffer utils.ReadBuffer, actualLen
// Create a partially initialized instance
_child := &BACnetTagApplicationOctetString{
- Value: value,
- Parent: &BACnetTag{},
+ Value: value,
+ ActualLengthInBit: actualLengthInBit,
+ Parent: &BACnetTag{},
}
_child.Parent.Child = _child
return _child.Parent, nil
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationSignedInteger.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationSignedInteger.go
index 29dcf69..1c49cf0 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationSignedInteger.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationSignedInteger.go
@@ -145,7 +145,8 @@ func BACnetTagApplicationSignedIntegerParse(readBuffer utils.ReadBuffer, actualL
}
// Virtual field
- isInt8 := bool((actualLength) == (1))
+ _isInt8 := bool((actualLength) == (1))
+ isInt8 := bool(_isInt8)
// Optional Field (valueInt8) (Can be skipped, if a given expression evaluates to false)
var valueInt8 *int8 = nil
@@ -158,7 +159,8 @@ func BACnetTagApplicationSignedIntegerParse(readBuffer utils.ReadBuffer, actualL
}
// Virtual field
- isInt16 := bool((actualLength) == (2))
+ _isInt16 := bool((actualLength) == (2))
+ isInt16 := bool(_isInt16)
// Optional Field (valueInt16) (Can be skipped, if a given expression evaluates to false)
var valueInt16 *int16 = nil
@@ -171,7 +173,8 @@ func BACnetTagApplicationSignedIntegerParse(readBuffer utils.ReadBuffer, actualL
}
// Virtual field
- isInt32 := bool((actualLength) == (3))
+ _isInt32 := bool((actualLength) == (3))
+ isInt32 := bool(_isInt32)
// Optional Field (valueInt32) (Can be skipped, if a given expression evaluates to false)
var valueInt32 *int32 = nil
@@ -184,7 +187,8 @@ func BACnetTagApplicationSignedIntegerParse(readBuffer utils.ReadBuffer, actualL
}
// Virtual field
- isInt64 := bool((actualLength) == (4))
+ _isInt64 := bool((actualLength) == (4))
+ isInt64 := bool(_isInt64)
// Optional Field (valueInt64) (Can be skipped, if a given expression evaluates to false)
var valueInt64 *int64 = nil
@@ -206,6 +210,10 @@ func BACnetTagApplicationSignedIntegerParse(readBuffer utils.ReadBuffer, actualL
ValueInt16: valueInt16,
ValueInt32: valueInt32,
ValueInt64: valueInt64,
+ IsInt8: isInt8,
+ IsInt16: isInt16,
+ IsInt32: isInt32,
+ IsInt64: isInt64,
Parent: &BACnetTag{},
}
_child.Parent.Child = _child
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationTime.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationTime.go
index b515287..77b14ab 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationTime.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationTime.go
@@ -21,13 +21,23 @@ package model
import (
"github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+ "github.com/pkg/errors"
)
// Code generated by code-generation. DO NOT EDIT.
// The data-structure of this message
type BACnetTagApplicationTime struct {
- Parent *BACnetTag
+ Hour int8
+ Minute int8
+ Second int8
+ Fractional int8
+ Wildcard int8
+ HourIsWildcard bool
+ MinuteIsWildcard bool
+ SecondIsWildcard bool
+ FractionalIsWildcard bool
+ Parent *BACnetTag
}
// The corresponding interface
@@ -53,9 +63,13 @@ func (m *BACnetTagApplicationTime) InitializeParent(parent *BACnetTag, tagNumber
m.Parent.ExtExtExtLength = extExtExtLength
}
-func NewBACnetTagApplicationTime(tagNumber uint8, lengthValueType uint8, extTagNumber *uint8, extLength *uint8, extExtLength *uint16, extExtExtLength *uint32) *BACnetTag {
+func NewBACnetTagApplicationTime(hour int8, minute int8, second int8, fractional int8, tagNumber uint8, lengthValueType uint8, extTagNumber *uint8, extLength *uint8, extExtLength *uint16, extExtExtLength *uint32) *BACnetTag {
child := &BACnetTagApplicationTime{
- Parent: NewBACnetTag(tagNumber, lengthValueType, extTagNumber, extLength, extExtLength, extExtExtLength),
+ Hour: hour,
+ Minute: minute,
+ Second: second,
+ Fractional: fractional,
+ Parent: NewBACnetTag(tagNumber, lengthValueType, extTagNumber, extLength, extExtLength, extExtExtLength),
}
child.Parent.Child = child
return child.Parent
@@ -91,6 +105,28 @@ func (m *BACnetTagApplicationTime) LengthInBits() uint16 {
func (m *BACnetTagApplicationTime) LengthInBitsConditional(lastItem bool) uint16 {
lengthInBits := uint16(m.Parent.ParentLengthInBits())
+ // A virtual field doesn't have any in- or output.
+
+ // Simple field (hour)
+ lengthInBits += 8
+
+ // A virtual field doesn't have any in- or output.
+
+ // Simple field (minute)
+ lengthInBits += 8
+
+ // A virtual field doesn't have any in- or output.
+
+ // Simple field (second)
+ lengthInBits += 8
+
+ // A virtual field doesn't have any in- or output.
+
+ // Simple field (fractional)
+ lengthInBits += 8
+
+ // A virtual field doesn't have any in- or output.
+
return lengthInBits
}
@@ -103,13 +139,66 @@ func BACnetTagApplicationTimeParse(readBuffer utils.ReadBuffer) (*BACnetTag, err
return nil, pullErr
}
+ // Virtual field
+ _wildcard := 0xFF
+ wildcard := int8(_wildcard)
+
+ // Simple Field (hour)
+ hour, _hourErr := readBuffer.ReadInt8("hour", 8)
+ if _hourErr != nil {
+ return nil, errors.Wrap(_hourErr, "Error parsing 'hour' field")
+ }
+
+ // Virtual field
+ _hourIsWildcard := bool((hour) == (wildcard))
+ hourIsWildcard := bool(_hourIsWildcard)
+
+ // Simple Field (minute)
+ minute, _minuteErr := readBuffer.ReadInt8("minute", 8)
+ if _minuteErr != nil {
+ return nil, errors.Wrap(_minuteErr, "Error parsing 'minute' field")
+ }
+
+ // Virtual field
+ _minuteIsWildcard := bool((minute) == (wildcard))
+ minuteIsWildcard := bool(_minuteIsWildcard)
+
+ // Simple Field (second)
+ second, _secondErr := readBuffer.ReadInt8("second", 8)
+ if _secondErr != nil {
+ return nil, errors.Wrap(_secondErr, "Error parsing 'second' field")
+ }
+
+ // Virtual field
+ _secondIsWildcard := bool((second) == (wildcard))
+ secondIsWildcard := bool(_secondIsWildcard)
+
+ // Simple Field (fractional)
+ fractional, _fractionalErr := readBuffer.ReadInt8("fractional", 8)
+ if _fractionalErr != nil {
+ return nil, errors.Wrap(_fractionalErr, "Error parsing 'fractional' field")
+ }
+
+ // Virtual field
+ _fractionalIsWildcard := bool((fractional) == (wildcard))
+ fractionalIsWildcard := bool(_fractionalIsWildcard)
+
if closeErr := readBuffer.CloseContext("BACnetTagApplicationTime"); closeErr != nil {
return nil, closeErr
}
// Create a partially initialized instance
_child := &BACnetTagApplicationTime{
- Parent: &BACnetTag{},
+ Hour: hour,
+ Minute: minute,
+ Second: second,
+ Fractional: fractional,
+ Wildcard: wildcard,
+ HourIsWildcard: hourIsWildcard,
+ MinuteIsWildcard: minuteIsWildcard,
+ SecondIsWildcard: secondIsWildcard,
+ FractionalIsWildcard: fractionalIsWildcard,
+ Parent: &BACnetTag{},
}
_child.Parent.Child = _child
return _child.Parent, nil
@@ -121,6 +210,34 @@ func (m *BACnetTagApplicationTime) Serialize(writeBuffer utils.WriteBuffer) erro
return pushErr
}
+ // Simple Field (hour)
+ hour := int8(m.Hour)
+ _hourErr := writeBuffer.WriteInt8("hour", 8, (hour))
+ if _hourErr != nil {
+ return errors.Wrap(_hourErr, "Error serializing 'hour' field")
+ }
+
+ // Simple Field (minute)
+ minute := int8(m.Minute)
+ _minuteErr := writeBuffer.WriteInt8("minute", 8, (minute))
+ if _minuteErr != nil {
+ return errors.Wrap(_minuteErr, "Error serializing 'minute' field")
+ }
+
+ // Simple Field (second)
+ second := int8(m.Second)
+ _secondErr := writeBuffer.WriteInt8("second", 8, (second))
+ if _secondErr != nil {
+ return errors.Wrap(_secondErr, "Error serializing 'second' field")
+ }
+
+ // Simple Field (fractional)
+ fractional := int8(m.Fractional)
+ _fractionalErr := writeBuffer.WriteInt8("fractional", 8, (fractional))
+ if _fractionalErr != nil {
+ return errors.Wrap(_fractionalErr, "Error serializing 'fractional' field")
+ }
+
if popErr := writeBuffer.PopContext("BACnetTagApplicationTime"); popErr != nil {
return popErr
}
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationUnsignedInteger.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationUnsignedInteger.go
index 47c8fe4..4099231 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationUnsignedInteger.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagApplicationUnsignedInteger.go
@@ -145,7 +145,8 @@ func BACnetTagApplicationUnsignedIntegerParse(readBuffer utils.ReadBuffer, actua
}
// Virtual field
- isUint8 := bool((actualLength) == (1))
+ _isUint8 := bool((actualLength) == (1))
+ isUint8 := bool(_isUint8)
// Optional Field (valueUint8) (Can be skipped, if a given expression evaluates to false)
var valueUint8 *uint8 = nil
@@ -158,7 +159,8 @@ func BACnetTagApplicationUnsignedIntegerParse(readBuffer utils.ReadBuffer, actua
}
// Virtual field
- isUint16 := bool((actualLength) == (2))
+ _isUint16 := bool((actualLength) == (2))
+ isUint16 := bool(_isUint16)
// Optional Field (valueUint16) (Can be skipped, if a given expression evaluates to false)
var valueUint16 *uint16 = nil
@@ -171,7 +173,8 @@ func BACnetTagApplicationUnsignedIntegerParse(readBuffer utils.ReadBuffer, actua
}
// Virtual field
- isUint32 := bool((actualLength) == (3))
+ _isUint32 := bool((actualLength) == (3))
+ isUint32 := bool(_isUint32)
// Optional Field (valueUint32) (Can be skipped, if a given expression evaluates to false)
var valueUint32 *uint32 = nil
@@ -184,7 +187,8 @@ func BACnetTagApplicationUnsignedIntegerParse(readBuffer utils.ReadBuffer, actua
}
// Virtual field
- isUint64 := bool((actualLength) == (4))
+ _isUint64 := bool((actualLength) == (4))
+ isUint64 := bool(_isUint64)
// Optional Field (valueUint64) (Can be skipped, if a given expression evaluates to false)
var valueUint64 *uint64 = nil
@@ -206,6 +210,10 @@ func BACnetTagApplicationUnsignedIntegerParse(readBuffer utils.ReadBuffer, actua
ValueUint16: valueUint16,
ValueUint32: valueUint32,
ValueUint64: valueUint64,
+ IsUint8: isUint8,
+ IsUint16: isUint16,
+ IsUint32: isUint32,
+ IsUint64: isUint64,
Parent: &BACnetTag{},
}
_child.Parent.Child = _child
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestTimeSynchronization.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestTimeSynchronization.go
index 21c6508..cbe5031 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestTimeSynchronization.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestTimeSynchronization.go
@@ -21,13 +21,16 @@ package model
import (
"github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+ "github.com/pkg/errors"
)
// Code generated by code-generation. DO NOT EDIT.
// The data-structure of this message
type BACnetUnconfirmedServiceRequestTimeSynchronization struct {
- Parent *BACnetUnconfirmedServiceRequest
+ SynchronizedDate *BACnetTagApplicationDate
+ SynchronizedTime *BACnetTagApplicationTime
+ Parent *BACnetUnconfirmedServiceRequest
}
// The corresponding interface
@@ -47,9 +50,11 @@ func (m *BACnetUnconfirmedServiceRequestTimeSynchronization) ServiceChoice() uin
func (m *BACnetUnconfirmedServiceRequestTimeSynchronization) InitializeParent(parent *BACnetUnconfirmedServiceRequest) {
}
-func NewBACnetUnconfirmedServiceRequestTimeSynchronization() *BACnetUnconfirmedServiceRequest {
+func NewBACnetUnconfirmedServiceRequestTimeSynchronization(synchronizedDate *BACnetTagApplicationDate, synchronizedTime *BACnetTagApplicationTime) *BACnetUnconfirmedServiceRequest {
child := &BACnetUnconfirmedServiceRequestTimeSynchronization{
- Parent: NewBACnetUnconfirmedServiceRequest(),
+ SynchronizedDate: synchronizedDate,
+ SynchronizedTime: synchronizedTime,
+ Parent: NewBACnetUnconfirmedServiceRequest(),
}
child.Parent.Child = child
return child.Parent
@@ -85,6 +90,12 @@ func (m *BACnetUnconfirmedServiceRequestTimeSynchronization) LengthInBits() uint
func (m *BACnetUnconfirmedServiceRequestTimeSynchronization) LengthInBitsConditional(lastItem bool) uint16 {
lengthInBits := uint16(m.Parent.ParentLengthInBits())
+ // Simple field (synchronizedDate)
+ lengthInBits += m.SynchronizedDate.LengthInBits()
+
+ // Simple field (synchronizedTime)
+ lengthInBits += m.SynchronizedTime.LengthInBits()
+
return lengthInBits
}
@@ -97,13 +108,39 @@ func BACnetUnconfirmedServiceRequestTimeSynchronizationParse(readBuffer utils.Re
return nil, pullErr
}
+ // Simple Field (synchronizedDate)
+ if pullErr := readBuffer.PullContext("synchronizedDate"); pullErr != nil {
+ return nil, pullErr
+ }
+ synchronizedDate, _synchronizedDateErr := BACnetTagParse(readBuffer)
+ if _synchronizedDateErr != nil {
+ return nil, errors.Wrap(_synchronizedDateErr, "Error parsing 'synchronizedDate' field")
+ }
+ if closeErr := readBuffer.CloseContext("synchronizedDate"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (synchronizedTime)
+ if pullErr := readBuffer.PullContext("synchronizedTime"); pullErr != nil {
+ return nil, pullErr
+ }
+ synchronizedTime, _synchronizedTimeErr := BACnetTagParse(readBuffer)
+ if _synchronizedTimeErr != nil {
+ return nil, errors.Wrap(_synchronizedTimeErr, "Error parsing 'synchronizedTime' field")
+ }
+ if closeErr := readBuffer.CloseContext("synchronizedTime"); closeErr != nil {
+ return nil, closeErr
+ }
+
if closeErr := readBuffer.CloseContext("BACnetUnconfirmedServiceRequestTimeSynchronization"); closeErr != nil {
return nil, closeErr
}
// Create a partially initialized instance
_child := &BACnetUnconfirmedServiceRequestTimeSynchronization{
- Parent: &BACnetUnconfirmedServiceRequest{},
+ SynchronizedDate: CastBACnetTagApplicationDate(synchronizedDate),
+ SynchronizedTime: CastBACnetTagApplicationTime(synchronizedTime),
+ Parent: &BACnetUnconfirmedServiceRequest{},
}
_child.Parent.Child = _child
return _child.Parent, nil
@@ -115,6 +152,30 @@ func (m *BACnetUnconfirmedServiceRequestTimeSynchronization) Serialize(writeBuff
return pushErr
}
+ // Simple Field (synchronizedDate)
+ if pushErr := writeBuffer.PushContext("synchronizedDate"); pushErr != nil {
+ return pushErr
+ }
+ _synchronizedDateErr := m.SynchronizedDate.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("synchronizedDate"); popErr != nil {
+ return popErr
+ }
+ if _synchronizedDateErr != nil {
+ return errors.Wrap(_synchronizedDateErr, "Error serializing 'synchronizedDate' field")
+ }
+
+ // Simple Field (synchronizedTime)
+ if pushErr := writeBuffer.PushContext("synchronizedTime"); pushErr != nil {
+ return pushErr
+ }
+ _synchronizedTimeErr := m.SynchronizedTime.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("synchronizedTime"); popErr != nil {
+ return popErr
+ }
+ if _synchronizedTimeErr != nil {
+ return errors.Wrap(_synchronizedTimeErr, "Error serializing 'synchronizedTime' field")
+ }
+
if popErr := writeBuffer.PopContext("BACnetUnconfirmedServiceRequestTimeSynchronization"); popErr != nil {
return popErr
}
diff --git a/protocols/bacnetip/src/main/resources/protocols/bacnetip/bacnetip.mspec b/protocols/bacnetip/src/main/resources/protocols/bacnetip/bacnetip.mspec
index 5b11715..2e89881 100644
--- a/protocols/bacnetip/src/main/resources/protocols/bacnetip/bacnetip.mspec
+++ b/protocols/bacnetip/src/main/resources/protocols/bacnetip/bacnetip.mspec
@@ -303,6 +303,8 @@
['0x05' BACnetUnconfirmedServiceRequestUnconfirmedTextMessage
]
['0x06' BACnetUnconfirmedServiceRequestTimeSynchronization
+ [simple BACnetTagApplicationDate synchronizedDate]
+ [simple BACnetTagApplicationTime synchronizedTime]
]
['0x07' BACnetUnconfirmedServiceRequestWhoHas
[optional BACnetComplexTagUnsignedInteger('0', 'BACnetDataType.UNSIGNED_INTEGER') deviceInstanceRangeLowLimit ]
@@ -547,8 +549,32 @@
[array int 8 data length 'actualLength']
]
['APPLICATION_TAGS','0xA' BACnetTagApplicationDate
+ [virtual int 8 wildcard '0xFF']
+ [simple int 8 yearMinus1900]
+ [virtual bit yearIsWildcard 'yearMinus1900 == wildcard']
+ [virtual int 16 year 'yearMinus1900 + 1900']
+ [simple int 8 month]
+ [virtual bit monthIsWildcard 'month == wildcard']
+ [virtual bit oddMonthWildcard 'month == 13']
+ [virtual bit evenMonthWildcard 'month == 14']
+ [simple int 8 dayOfMonth]
+ [virtual bit dayOfMonthIsWildcard 'dayOfMonth == wildcard']
+ [virtual bit lastDayOfMonthWildcard 'dayOfMonth == 32']
+ [virtual bit oddDayOfMonthWildcard 'dayOfMonth == 33']
+ [virtual bit evenDayOfMonthWildcard 'dayOfMonth == 34']
+ [simple int 8 dayOfWeek]
+ [virtual bit dayOfWeekIsWildcard 'dayOfWeek == wildcard']
]
['APPLICATION_TAGS','0xB' BACnetTagApplicationTime
+ [virtual int 8 wildcard '0xFF']
+ [simple int 8 hour]
+ [virtual bit hourIsWildcard 'hour == wildcard']
+ [simple int 8 minute]
+ [virtual bit minuteIsWildcard 'minute == wildcard']
+ [simple int 8 second]
+ [virtual bit secondIsWildcard 'second == wildcard']
+ [simple int 8 fractional]
+ [virtual bit fractionalIsWildcard 'fractional == wildcard']
]
['APPLICATION_TAGS','0xC' BACnetTagApplicationObjectIdentifier
[simple uint 10 objectType]
@@ -626,8 +652,31 @@
[array int 8 data length 'actualLengthInBit']
]
['DATE' BACnetComplexTagDate
+ [virtual int 8 wildcard '0xFF']
+ [simple int 8 yearMinus1900]
+ [virtual bit yearIsWildcard 'yearMinus1900 == wildcard']
+ [simple int 8 month]
+ [virtual bit monthIsWildcard 'month == wildcard']
+ [virtual bit oddMonthWildcard 'month == 13']
+ [virtual bit evenMonthWildcard 'month == 14']
+ [simple int 8 dayOfMonth]
+ [virtual bit dayOfMonthIsWildcard 'dayOfMonth == wildcard']
+ [virtual bit lastDayOfMonthWildcard 'dayOfMonth == 32']
+ [virtual bit oddDayOfMonthWildcard 'dayOfMonth == 33']
+ [virtual bit evenDayOfMonthWildcard 'dayOfMonth == 34']
+ [simple int 8 dayOfWeek]
+ [virtual bit dayOfWeekIsWildcard 'dayOfWeek == wildcard']
]
['TIME' BACnetComplexTagTime
+ [virtual int 8 wildcard '0xFF']
+ [simple int 8 hour]
+ [virtual bit hourIsWildcard 'hour == wildcard']
+ [simple int 8 minute]
+ [virtual bit minuteIsWildcard 'minute == wildcard']
+ [simple int 8 second]
+ [virtual bit secondIsWildcard 'second == wildcard']
+ [simple int 8 fractional]
+ [virtual bit fractionalIsWildcard 'fractional == wildcard']
]
['BACNET_OBJECT_IDENTIFIER' BACnetComplexTagObjectIdentifier
[simple uint 10 objectType]