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 2022/06/08 10:10:57 UTC
[plc4x] 05/08: feat(bacnet): implemented unique properties for averaging type
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 c4f993b8770646dcf7eb1d60dc6839f52980c3cb
Author: Sebastian Rühl <sr...@apache.org>
AuthorDate: Wed Jun 8 11:35:45 2022 +0200
feat(bacnet): implemented unique properties for averaging type
- ATTEMPTED_SAMPLES
- AVERAGE_VALUE
- MAXIMUM_VALUE
- MAXIMUM_VALUE_TIMESTAMP
- MINIMUM_VALUE_TIMESTAMP
- VALID_SAMPLES
- VARIANCE_VALUE
- WINDOW_INTERVAL
- WINDOW_SAMPLES
- WINDOW_SAMPLES
---
.../readwrite/model/BACnetConstructedData.go | 18 ++
.../model/BACnetConstructedDataAttemptedSamples.go | 211 +++++++++++++++++++++
.../model/BACnetConstructedDataAverageValue.go | 211 +++++++++++++++++++++
.../model/BACnetConstructedDataMaximumValue.go | 211 +++++++++++++++++++++
.../BACnetConstructedDataMaximumValueTimestamp.go | 211 +++++++++++++++++++++
.../BACnetConstructedDataMinimumValueTimestamp.go | 211 +++++++++++++++++++++
.../model/BACnetConstructedDataValidSamples.go | 211 +++++++++++++++++++++
.../model/BACnetConstructedDataVarianceValue.go | 211 +++++++++++++++++++++
.../model/BACnetConstructedDataWindowInterval.go | 211 +++++++++++++++++++++
.../model/BACnetConstructedDataWindowSamples.go | 211 +++++++++++++++++++++
.../resources/protocols/bacnetip/bacnetip.mspec | 36 +++-
11 files changed, 1944 insertions(+), 9 deletions(-)
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedData.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedData.go
index 9e5c700af7..5c6501a538 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedData.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedData.go
@@ -348,6 +348,8 @@ func BACnetConstructedDataParse(readBuffer utils.ReadBuffer, tagNumber uint8, ob
_child, typeSwitchError = BACnetConstructedDataAssignedAccessRightsParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_ASSIGNED_LANDING_CALLS: // BACnetConstructedDataAssignedLandingCalls
_child, typeSwitchError = BACnetConstructedDataAssignedLandingCallsParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
+ case true && propertyIdentifierArgument == BACnetPropertyIdentifier_ATTEMPTED_SAMPLES: // BACnetConstructedDataAttemptedSamples
+ _child, typeSwitchError = BACnetConstructedDataAttemptedSamplesParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_AUTHENTICATION_FACTORS: // BACnetConstructedDataAuthenticationFactors
_child, typeSwitchError = BACnetConstructedDataAuthenticationFactorsParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_AUTHENTICATION_POLICY_LIST: // BACnetConstructedDataAuthenticationPolicyList
@@ -362,6 +364,8 @@ func BACnetConstructedDataParse(readBuffer utils.ReadBuffer, tagNumber uint8, ob
_child, typeSwitchError = BACnetConstructedDataAuthorizationModeParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_AUTO_SLAVE_DISCOVERY: // BACnetConstructedDataAutoSlaveDiscovery
_child, typeSwitchError = BACnetConstructedDataAutoSlaveDiscoveryParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
+ case true && propertyIdentifierArgument == BACnetPropertyIdentifier_AVERAGE_VALUE: // BACnetConstructedDataAverageValue
+ _child, typeSwitchError = BACnetConstructedDataAverageValueParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_BACKUP_AND_RESTORE_STATE: // BACnetConstructedDataBackupAndRestoreState
_child, typeSwitchError = BACnetConstructedDataBackupAndRestoreStateParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_BACKUP_FAILURE_TIMEOUT: // BACnetConstructedDataBackupFailureTimeout
@@ -732,6 +736,10 @@ func BACnetConstructedDataParse(readBuffer utils.ReadBuffer, tagNumber uint8, ob
_child, typeSwitchError = BACnetConstructedDataMaxSegmentsAcceptedParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_MAXIMUM_OUTPUT: // BACnetConstructedDataMaximumOutput
_child, typeSwitchError = BACnetConstructedDataMaximumOutputParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
+ case true && propertyIdentifierArgument == BACnetPropertyIdentifier_MAXIMUM_VALUE: // BACnetConstructedDataMaximumValue
+ _child, typeSwitchError = BACnetConstructedDataMaximumValueParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
+ case true && propertyIdentifierArgument == BACnetPropertyIdentifier_MAXIMUM_VALUE_TIMESTAMP: // BACnetConstructedDataMaximumValueTimestamp
+ _child, typeSwitchError = BACnetConstructedDataMaximumValueTimestampParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_MEMBER_OF: // BACnetConstructedDataMemberOf
_child, typeSwitchError = BACnetConstructedDataMemberOfParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_MEMBER_STATUS_FLAGS: // BACnetConstructedDataMemberStatusFlags
@@ -748,6 +756,8 @@ func BACnetConstructedDataParse(readBuffer utils.ReadBuffer, tagNumber uint8, ob
_child, typeSwitchError = BACnetConstructedDataMinimumOutputParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_MINIMUM_VALUE: // BACnetConstructedDataMinimumValue
_child, typeSwitchError = BACnetConstructedDataMinimumValueParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
+ case true && propertyIdentifierArgument == BACnetPropertyIdentifier_MINIMUM_VALUE_TIMESTAMP: // BACnetConstructedDataMinimumValueTimestamp
+ _child, typeSwitchError = BACnetConstructedDataMinimumValueTimestampParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_MODEL_NAME: // BACnetConstructedDataModelName
_child, typeSwitchError = BACnetConstructedDataModelNameParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_MODIFICATION_DATE: // BACnetConstructedDataModificationDate
@@ -980,6 +990,10 @@ func BACnetConstructedDataParse(readBuffer utils.ReadBuffer, tagNumber uint8, ob
_child, typeSwitchError = BACnetConstructedDataUTCOffsetParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_UTC_TIME_SYNCHRONIZATION_RECIPIENTS: // BACnetConstructedDataUTCTimeSynchronizationRecipients
_child, typeSwitchError = BACnetConstructedDataUTCTimeSynchronizationRecipientsParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
+ case true && propertyIdentifierArgument == BACnetPropertyIdentifier_VALID_SAMPLES: // BACnetConstructedDataValidSamples
+ _child, typeSwitchError = BACnetConstructedDataValidSamplesParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
+ case true && propertyIdentifierArgument == BACnetPropertyIdentifier_VARIANCE_VALUE: // BACnetConstructedDataVarianceValue
+ _child, typeSwitchError = BACnetConstructedDataVarianceValueParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_VENDOR_IDENTIFIER: // BACnetConstructedDataVendorIdentifier
_child, typeSwitchError = BACnetConstructedDataVendorIdentifierParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_VENDOR_NAME: // BACnetConstructedDataVendorName
@@ -992,6 +1006,10 @@ func BACnetConstructedDataParse(readBuffer utils.ReadBuffer, tagNumber uint8, ob
_child, typeSwitchError = BACnetConstructedDataVTClassesSupportedParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_WEEKLY_SCHEDULE: // BACnetConstructedDataWeeklySchedule
_child, typeSwitchError = BACnetConstructedDataWeeklyScheduleParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
+ case true && propertyIdentifierArgument == BACnetPropertyIdentifier_WINDOW_INTERVAL: // BACnetConstructedDataWindowInterval
+ _child, typeSwitchError = BACnetConstructedDataWindowIntervalParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
+ case true && propertyIdentifierArgument == BACnetPropertyIdentifier_WINDOW_SAMPLES: // BACnetConstructedDataWindowSamples
+ _child, typeSwitchError = BACnetConstructedDataWindowSamplesParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_WRITE_STATUS: // BACnetConstructedDataWriteStatus
_child, typeSwitchError = BACnetConstructedDataWriteStatusParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_ZONE_FROM: // BACnetConstructedDataZoneFrom
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAttemptedSamples.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAttemptedSamples.go
new file mode 100644
index 0000000000..f73dc26cac
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAttemptedSamples.go
@@ -0,0 +1,211 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/spi/utils"
+ "github.com/pkg/errors"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// BACnetConstructedDataAttemptedSamples is the data-structure of this message
+type BACnetConstructedDataAttemptedSamples struct {
+ *BACnetConstructedData
+ AttemptedSamples *BACnetApplicationTagUnsignedInteger
+
+ // Arguments.
+ TagNumber uint8
+}
+
+// IBACnetConstructedDataAttemptedSamples is the corresponding interface of BACnetConstructedDataAttemptedSamples
+type IBACnetConstructedDataAttemptedSamples interface {
+ IBACnetConstructedData
+ // GetAttemptedSamples returns AttemptedSamples (property field)
+ GetAttemptedSamples() *BACnetApplicationTagUnsignedInteger
+ // GetLengthInBytes returns the length in bytes
+ GetLengthInBytes() uint16
+ // GetLengthInBits returns the length in bits
+ GetLengthInBits() uint16
+ // Serialize serializes this type
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for discriminator values.
+///////////////////////
+
+func (m *BACnetConstructedDataAttemptedSamples) GetObjectTypeArgument() BACnetObjectType {
+ return 0
+}
+
+func (m *BACnetConstructedDataAttemptedSamples) GetPropertyIdentifierArgument() BACnetPropertyIdentifier {
+ return BACnetPropertyIdentifier_ATTEMPTED_SAMPLES
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+func (m *BACnetConstructedDataAttemptedSamples) InitializeParent(parent *BACnetConstructedData, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag) {
+ m.BACnetConstructedData.OpeningTag = openingTag
+ m.BACnetConstructedData.ClosingTag = closingTag
+}
+
+func (m *BACnetConstructedDataAttemptedSamples) GetParent() *BACnetConstructedData {
+ return m.BACnetConstructedData
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAttemptedSamples) GetAttemptedSamples() *BACnetApplicationTagUnsignedInteger {
+ return m.AttemptedSamples
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetConstructedDataAttemptedSamples factory function for BACnetConstructedDataAttemptedSamples
+func NewBACnetConstructedDataAttemptedSamples(attemptedSamples *BACnetApplicationTagUnsignedInteger, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag, tagNumber uint8) *BACnetConstructedDataAttemptedSamples {
+ _result := &BACnetConstructedDataAttemptedSamples{
+ AttemptedSamples: attemptedSamples,
+ BACnetConstructedData: NewBACnetConstructedData(openingTag, closingTag, tagNumber),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetConstructedDataAttemptedSamples(structType interface{}) *BACnetConstructedDataAttemptedSamples {
+ if casted, ok := structType.(BACnetConstructedDataAttemptedSamples); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConstructedDataAttemptedSamples); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConstructedData); ok {
+ return CastBACnetConstructedDataAttemptedSamples(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConstructedData); ok {
+ return CastBACnetConstructedDataAttemptedSamples(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetConstructedDataAttemptedSamples) GetTypeName() string {
+ return "BACnetConstructedDataAttemptedSamples"
+}
+
+func (m *BACnetConstructedDataAttemptedSamples) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetConstructedDataAttemptedSamples) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (attemptedSamples)
+ lengthInBits += m.AttemptedSamples.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetConstructedDataAttemptedSamples) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetConstructedDataAttemptedSamplesParse(readBuffer utils.ReadBuffer, tagNumber uint8, objectTypeArgument BACnetObjectType, propertyIdentifierArgument BACnetPropertyIdentifier) (*BACnetConstructedDataAttemptedSamples, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetConstructedDataAttemptedSamples"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (attemptedSamples)
+ if pullErr := readBuffer.PullContext("attemptedSamples"); pullErr != nil {
+ return nil, pullErr
+ }
+ _attemptedSamples, _attemptedSamplesErr := BACnetApplicationTagParse(readBuffer)
+ if _attemptedSamplesErr != nil {
+ return nil, errors.Wrap(_attemptedSamplesErr, "Error parsing 'attemptedSamples' field")
+ }
+ attemptedSamples := CastBACnetApplicationTagUnsignedInteger(_attemptedSamples)
+ if closeErr := readBuffer.CloseContext("attemptedSamples"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetConstructedDataAttemptedSamples"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetConstructedDataAttemptedSamples{
+ AttemptedSamples: CastBACnetApplicationTagUnsignedInteger(attemptedSamples),
+ BACnetConstructedData: &BACnetConstructedData{},
+ }
+ _child.BACnetConstructedData.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetConstructedDataAttemptedSamples) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetConstructedDataAttemptedSamples"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (attemptedSamples)
+ if pushErr := writeBuffer.PushContext("attemptedSamples"); pushErr != nil {
+ return pushErr
+ }
+ _attemptedSamplesErr := m.AttemptedSamples.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("attemptedSamples"); popErr != nil {
+ return popErr
+ }
+ if _attemptedSamplesErr != nil {
+ return errors.Wrap(_attemptedSamplesErr, "Error serializing 'attemptedSamples' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetConstructedDataAttemptedSamples"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetConstructedDataAttemptedSamples) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ buffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ if err := m.Serialize(buffer); err != nil {
+ return err.Error()
+ }
+ return buffer.GetBox().String()
+}
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAverageValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAverageValue.go
new file mode 100644
index 0000000000..d9f2d8324c
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataAverageValue.go
@@ -0,0 +1,211 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/spi/utils"
+ "github.com/pkg/errors"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// BACnetConstructedDataAverageValue is the data-structure of this message
+type BACnetConstructedDataAverageValue struct {
+ *BACnetConstructedData
+ AverageValue *BACnetApplicationTagReal
+
+ // Arguments.
+ TagNumber uint8
+}
+
+// IBACnetConstructedDataAverageValue is the corresponding interface of BACnetConstructedDataAverageValue
+type IBACnetConstructedDataAverageValue interface {
+ IBACnetConstructedData
+ // GetAverageValue returns AverageValue (property field)
+ GetAverageValue() *BACnetApplicationTagReal
+ // GetLengthInBytes returns the length in bytes
+ GetLengthInBytes() uint16
+ // GetLengthInBits returns the length in bits
+ GetLengthInBits() uint16
+ // Serialize serializes this type
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for discriminator values.
+///////////////////////
+
+func (m *BACnetConstructedDataAverageValue) GetObjectTypeArgument() BACnetObjectType {
+ return 0
+}
+
+func (m *BACnetConstructedDataAverageValue) GetPropertyIdentifierArgument() BACnetPropertyIdentifier {
+ return BACnetPropertyIdentifier_AVERAGE_VALUE
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+func (m *BACnetConstructedDataAverageValue) InitializeParent(parent *BACnetConstructedData, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag) {
+ m.BACnetConstructedData.OpeningTag = openingTag
+ m.BACnetConstructedData.ClosingTag = closingTag
+}
+
+func (m *BACnetConstructedDataAverageValue) GetParent() *BACnetConstructedData {
+ return m.BACnetConstructedData
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetConstructedDataAverageValue) GetAverageValue() *BACnetApplicationTagReal {
+ return m.AverageValue
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetConstructedDataAverageValue factory function for BACnetConstructedDataAverageValue
+func NewBACnetConstructedDataAverageValue(averageValue *BACnetApplicationTagReal, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag, tagNumber uint8) *BACnetConstructedDataAverageValue {
+ _result := &BACnetConstructedDataAverageValue{
+ AverageValue: averageValue,
+ BACnetConstructedData: NewBACnetConstructedData(openingTag, closingTag, tagNumber),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetConstructedDataAverageValue(structType interface{}) *BACnetConstructedDataAverageValue {
+ if casted, ok := structType.(BACnetConstructedDataAverageValue); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConstructedDataAverageValue); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConstructedData); ok {
+ return CastBACnetConstructedDataAverageValue(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConstructedData); ok {
+ return CastBACnetConstructedDataAverageValue(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetConstructedDataAverageValue) GetTypeName() string {
+ return "BACnetConstructedDataAverageValue"
+}
+
+func (m *BACnetConstructedDataAverageValue) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetConstructedDataAverageValue) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (averageValue)
+ lengthInBits += m.AverageValue.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetConstructedDataAverageValue) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetConstructedDataAverageValueParse(readBuffer utils.ReadBuffer, tagNumber uint8, objectTypeArgument BACnetObjectType, propertyIdentifierArgument BACnetPropertyIdentifier) (*BACnetConstructedDataAverageValue, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetConstructedDataAverageValue"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (averageValue)
+ if pullErr := readBuffer.PullContext("averageValue"); pullErr != nil {
+ return nil, pullErr
+ }
+ _averageValue, _averageValueErr := BACnetApplicationTagParse(readBuffer)
+ if _averageValueErr != nil {
+ return nil, errors.Wrap(_averageValueErr, "Error parsing 'averageValue' field")
+ }
+ averageValue := CastBACnetApplicationTagReal(_averageValue)
+ if closeErr := readBuffer.CloseContext("averageValue"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetConstructedDataAverageValue"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetConstructedDataAverageValue{
+ AverageValue: CastBACnetApplicationTagReal(averageValue),
+ BACnetConstructedData: &BACnetConstructedData{},
+ }
+ _child.BACnetConstructedData.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetConstructedDataAverageValue) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetConstructedDataAverageValue"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (averageValue)
+ if pushErr := writeBuffer.PushContext("averageValue"); pushErr != nil {
+ return pushErr
+ }
+ _averageValueErr := m.AverageValue.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("averageValue"); popErr != nil {
+ return popErr
+ }
+ if _averageValueErr != nil {
+ return errors.Wrap(_averageValueErr, "Error serializing 'averageValue' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetConstructedDataAverageValue"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetConstructedDataAverageValue) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ buffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ if err := m.Serialize(buffer); err != nil {
+ return err.Error()
+ }
+ return buffer.GetBox().String()
+}
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataMaximumValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataMaximumValue.go
new file mode 100644
index 0000000000..cb21107038
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataMaximumValue.go
@@ -0,0 +1,211 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/spi/utils"
+ "github.com/pkg/errors"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// BACnetConstructedDataMaximumValue is the data-structure of this message
+type BACnetConstructedDataMaximumValue struct {
+ *BACnetConstructedData
+ MaximumValue *BACnetApplicationTagReal
+
+ // Arguments.
+ TagNumber uint8
+}
+
+// IBACnetConstructedDataMaximumValue is the corresponding interface of BACnetConstructedDataMaximumValue
+type IBACnetConstructedDataMaximumValue interface {
+ IBACnetConstructedData
+ // GetMaximumValue returns MaximumValue (property field)
+ GetMaximumValue() *BACnetApplicationTagReal
+ // GetLengthInBytes returns the length in bytes
+ GetLengthInBytes() uint16
+ // GetLengthInBits returns the length in bits
+ GetLengthInBits() uint16
+ // Serialize serializes this type
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for discriminator values.
+///////////////////////
+
+func (m *BACnetConstructedDataMaximumValue) GetObjectTypeArgument() BACnetObjectType {
+ return 0
+}
+
+func (m *BACnetConstructedDataMaximumValue) GetPropertyIdentifierArgument() BACnetPropertyIdentifier {
+ return BACnetPropertyIdentifier_MAXIMUM_VALUE
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+func (m *BACnetConstructedDataMaximumValue) InitializeParent(parent *BACnetConstructedData, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag) {
+ m.BACnetConstructedData.OpeningTag = openingTag
+ m.BACnetConstructedData.ClosingTag = closingTag
+}
+
+func (m *BACnetConstructedDataMaximumValue) GetParent() *BACnetConstructedData {
+ return m.BACnetConstructedData
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetConstructedDataMaximumValue) GetMaximumValue() *BACnetApplicationTagReal {
+ return m.MaximumValue
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetConstructedDataMaximumValue factory function for BACnetConstructedDataMaximumValue
+func NewBACnetConstructedDataMaximumValue(maximumValue *BACnetApplicationTagReal, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag, tagNumber uint8) *BACnetConstructedDataMaximumValue {
+ _result := &BACnetConstructedDataMaximumValue{
+ MaximumValue: maximumValue,
+ BACnetConstructedData: NewBACnetConstructedData(openingTag, closingTag, tagNumber),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetConstructedDataMaximumValue(structType interface{}) *BACnetConstructedDataMaximumValue {
+ if casted, ok := structType.(BACnetConstructedDataMaximumValue); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConstructedDataMaximumValue); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConstructedData); ok {
+ return CastBACnetConstructedDataMaximumValue(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConstructedData); ok {
+ return CastBACnetConstructedDataMaximumValue(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetConstructedDataMaximumValue) GetTypeName() string {
+ return "BACnetConstructedDataMaximumValue"
+}
+
+func (m *BACnetConstructedDataMaximumValue) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetConstructedDataMaximumValue) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (maximumValue)
+ lengthInBits += m.MaximumValue.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetConstructedDataMaximumValue) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetConstructedDataMaximumValueParse(readBuffer utils.ReadBuffer, tagNumber uint8, objectTypeArgument BACnetObjectType, propertyIdentifierArgument BACnetPropertyIdentifier) (*BACnetConstructedDataMaximumValue, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetConstructedDataMaximumValue"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (maximumValue)
+ if pullErr := readBuffer.PullContext("maximumValue"); pullErr != nil {
+ return nil, pullErr
+ }
+ _maximumValue, _maximumValueErr := BACnetApplicationTagParse(readBuffer)
+ if _maximumValueErr != nil {
+ return nil, errors.Wrap(_maximumValueErr, "Error parsing 'maximumValue' field")
+ }
+ maximumValue := CastBACnetApplicationTagReal(_maximumValue)
+ if closeErr := readBuffer.CloseContext("maximumValue"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetConstructedDataMaximumValue"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetConstructedDataMaximumValue{
+ MaximumValue: CastBACnetApplicationTagReal(maximumValue),
+ BACnetConstructedData: &BACnetConstructedData{},
+ }
+ _child.BACnetConstructedData.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetConstructedDataMaximumValue) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetConstructedDataMaximumValue"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (maximumValue)
+ if pushErr := writeBuffer.PushContext("maximumValue"); pushErr != nil {
+ return pushErr
+ }
+ _maximumValueErr := m.MaximumValue.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("maximumValue"); popErr != nil {
+ return popErr
+ }
+ if _maximumValueErr != nil {
+ return errors.Wrap(_maximumValueErr, "Error serializing 'maximumValue' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetConstructedDataMaximumValue"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetConstructedDataMaximumValue) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ buffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ if err := m.Serialize(buffer); err != nil {
+ return err.Error()
+ }
+ return buffer.GetBox().String()
+}
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataMaximumValueTimestamp.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataMaximumValueTimestamp.go
new file mode 100644
index 0000000000..ad9fbedc1d
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataMaximumValueTimestamp.go
@@ -0,0 +1,211 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/spi/utils"
+ "github.com/pkg/errors"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// BACnetConstructedDataMaximumValueTimestamp is the data-structure of this message
+type BACnetConstructedDataMaximumValueTimestamp struct {
+ *BACnetConstructedData
+ MaximumValueTimestamp *BACnetDateTime
+
+ // Arguments.
+ TagNumber uint8
+}
+
+// IBACnetConstructedDataMaximumValueTimestamp is the corresponding interface of BACnetConstructedDataMaximumValueTimestamp
+type IBACnetConstructedDataMaximumValueTimestamp interface {
+ IBACnetConstructedData
+ // GetMaximumValueTimestamp returns MaximumValueTimestamp (property field)
+ GetMaximumValueTimestamp() *BACnetDateTime
+ // GetLengthInBytes returns the length in bytes
+ GetLengthInBytes() uint16
+ // GetLengthInBits returns the length in bits
+ GetLengthInBits() uint16
+ // Serialize serializes this type
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for discriminator values.
+///////////////////////
+
+func (m *BACnetConstructedDataMaximumValueTimestamp) GetObjectTypeArgument() BACnetObjectType {
+ return 0
+}
+
+func (m *BACnetConstructedDataMaximumValueTimestamp) GetPropertyIdentifierArgument() BACnetPropertyIdentifier {
+ return BACnetPropertyIdentifier_MAXIMUM_VALUE_TIMESTAMP
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+func (m *BACnetConstructedDataMaximumValueTimestamp) InitializeParent(parent *BACnetConstructedData, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag) {
+ m.BACnetConstructedData.OpeningTag = openingTag
+ m.BACnetConstructedData.ClosingTag = closingTag
+}
+
+func (m *BACnetConstructedDataMaximumValueTimestamp) GetParent() *BACnetConstructedData {
+ return m.BACnetConstructedData
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetConstructedDataMaximumValueTimestamp) GetMaximumValueTimestamp() *BACnetDateTime {
+ return m.MaximumValueTimestamp
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetConstructedDataMaximumValueTimestamp factory function for BACnetConstructedDataMaximumValueTimestamp
+func NewBACnetConstructedDataMaximumValueTimestamp(maximumValueTimestamp *BACnetDateTime, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag, tagNumber uint8) *BACnetConstructedDataMaximumValueTimestamp {
+ _result := &BACnetConstructedDataMaximumValueTimestamp{
+ MaximumValueTimestamp: maximumValueTimestamp,
+ BACnetConstructedData: NewBACnetConstructedData(openingTag, closingTag, tagNumber),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetConstructedDataMaximumValueTimestamp(structType interface{}) *BACnetConstructedDataMaximumValueTimestamp {
+ if casted, ok := structType.(BACnetConstructedDataMaximumValueTimestamp); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConstructedDataMaximumValueTimestamp); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConstructedData); ok {
+ return CastBACnetConstructedDataMaximumValueTimestamp(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConstructedData); ok {
+ return CastBACnetConstructedDataMaximumValueTimestamp(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetConstructedDataMaximumValueTimestamp) GetTypeName() string {
+ return "BACnetConstructedDataMaximumValueTimestamp"
+}
+
+func (m *BACnetConstructedDataMaximumValueTimestamp) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetConstructedDataMaximumValueTimestamp) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (maximumValueTimestamp)
+ lengthInBits += m.MaximumValueTimestamp.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetConstructedDataMaximumValueTimestamp) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetConstructedDataMaximumValueTimestampParse(readBuffer utils.ReadBuffer, tagNumber uint8, objectTypeArgument BACnetObjectType, propertyIdentifierArgument BACnetPropertyIdentifier) (*BACnetConstructedDataMaximumValueTimestamp, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetConstructedDataMaximumValueTimestamp"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (maximumValueTimestamp)
+ if pullErr := readBuffer.PullContext("maximumValueTimestamp"); pullErr != nil {
+ return nil, pullErr
+ }
+ _maximumValueTimestamp, _maximumValueTimestampErr := BACnetDateTimeParse(readBuffer)
+ if _maximumValueTimestampErr != nil {
+ return nil, errors.Wrap(_maximumValueTimestampErr, "Error parsing 'maximumValueTimestamp' field")
+ }
+ maximumValueTimestamp := CastBACnetDateTime(_maximumValueTimestamp)
+ if closeErr := readBuffer.CloseContext("maximumValueTimestamp"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetConstructedDataMaximumValueTimestamp"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetConstructedDataMaximumValueTimestamp{
+ MaximumValueTimestamp: CastBACnetDateTime(maximumValueTimestamp),
+ BACnetConstructedData: &BACnetConstructedData{},
+ }
+ _child.BACnetConstructedData.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetConstructedDataMaximumValueTimestamp) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetConstructedDataMaximumValueTimestamp"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (maximumValueTimestamp)
+ if pushErr := writeBuffer.PushContext("maximumValueTimestamp"); pushErr != nil {
+ return pushErr
+ }
+ _maximumValueTimestampErr := m.MaximumValueTimestamp.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("maximumValueTimestamp"); popErr != nil {
+ return popErr
+ }
+ if _maximumValueTimestampErr != nil {
+ return errors.Wrap(_maximumValueTimestampErr, "Error serializing 'maximumValueTimestamp' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetConstructedDataMaximumValueTimestamp"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetConstructedDataMaximumValueTimestamp) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ buffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ if err := m.Serialize(buffer); err != nil {
+ return err.Error()
+ }
+ return buffer.GetBox().String()
+}
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataMinimumValueTimestamp.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataMinimumValueTimestamp.go
new file mode 100644
index 0000000000..3c0090d7d7
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataMinimumValueTimestamp.go
@@ -0,0 +1,211 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/spi/utils"
+ "github.com/pkg/errors"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// BACnetConstructedDataMinimumValueTimestamp is the data-structure of this message
+type BACnetConstructedDataMinimumValueTimestamp struct {
+ *BACnetConstructedData
+ MinimumValueTimestamp *BACnetDateTime
+
+ // Arguments.
+ TagNumber uint8
+}
+
+// IBACnetConstructedDataMinimumValueTimestamp is the corresponding interface of BACnetConstructedDataMinimumValueTimestamp
+type IBACnetConstructedDataMinimumValueTimestamp interface {
+ IBACnetConstructedData
+ // GetMinimumValueTimestamp returns MinimumValueTimestamp (property field)
+ GetMinimumValueTimestamp() *BACnetDateTime
+ // GetLengthInBytes returns the length in bytes
+ GetLengthInBytes() uint16
+ // GetLengthInBits returns the length in bits
+ GetLengthInBits() uint16
+ // Serialize serializes this type
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for discriminator values.
+///////////////////////
+
+func (m *BACnetConstructedDataMinimumValueTimestamp) GetObjectTypeArgument() BACnetObjectType {
+ return 0
+}
+
+func (m *BACnetConstructedDataMinimumValueTimestamp) GetPropertyIdentifierArgument() BACnetPropertyIdentifier {
+ return BACnetPropertyIdentifier_MINIMUM_VALUE_TIMESTAMP
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+func (m *BACnetConstructedDataMinimumValueTimestamp) InitializeParent(parent *BACnetConstructedData, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag) {
+ m.BACnetConstructedData.OpeningTag = openingTag
+ m.BACnetConstructedData.ClosingTag = closingTag
+}
+
+func (m *BACnetConstructedDataMinimumValueTimestamp) GetParent() *BACnetConstructedData {
+ return m.BACnetConstructedData
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetConstructedDataMinimumValueTimestamp) GetMinimumValueTimestamp() *BACnetDateTime {
+ return m.MinimumValueTimestamp
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetConstructedDataMinimumValueTimestamp factory function for BACnetConstructedDataMinimumValueTimestamp
+func NewBACnetConstructedDataMinimumValueTimestamp(minimumValueTimestamp *BACnetDateTime, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag, tagNumber uint8) *BACnetConstructedDataMinimumValueTimestamp {
+ _result := &BACnetConstructedDataMinimumValueTimestamp{
+ MinimumValueTimestamp: minimumValueTimestamp,
+ BACnetConstructedData: NewBACnetConstructedData(openingTag, closingTag, tagNumber),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetConstructedDataMinimumValueTimestamp(structType interface{}) *BACnetConstructedDataMinimumValueTimestamp {
+ if casted, ok := structType.(BACnetConstructedDataMinimumValueTimestamp); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConstructedDataMinimumValueTimestamp); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConstructedData); ok {
+ return CastBACnetConstructedDataMinimumValueTimestamp(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConstructedData); ok {
+ return CastBACnetConstructedDataMinimumValueTimestamp(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetConstructedDataMinimumValueTimestamp) GetTypeName() string {
+ return "BACnetConstructedDataMinimumValueTimestamp"
+}
+
+func (m *BACnetConstructedDataMinimumValueTimestamp) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetConstructedDataMinimumValueTimestamp) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (minimumValueTimestamp)
+ lengthInBits += m.MinimumValueTimestamp.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetConstructedDataMinimumValueTimestamp) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetConstructedDataMinimumValueTimestampParse(readBuffer utils.ReadBuffer, tagNumber uint8, objectTypeArgument BACnetObjectType, propertyIdentifierArgument BACnetPropertyIdentifier) (*BACnetConstructedDataMinimumValueTimestamp, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetConstructedDataMinimumValueTimestamp"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (minimumValueTimestamp)
+ if pullErr := readBuffer.PullContext("minimumValueTimestamp"); pullErr != nil {
+ return nil, pullErr
+ }
+ _minimumValueTimestamp, _minimumValueTimestampErr := BACnetDateTimeParse(readBuffer)
+ if _minimumValueTimestampErr != nil {
+ return nil, errors.Wrap(_minimumValueTimestampErr, "Error parsing 'minimumValueTimestamp' field")
+ }
+ minimumValueTimestamp := CastBACnetDateTime(_minimumValueTimestamp)
+ if closeErr := readBuffer.CloseContext("minimumValueTimestamp"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetConstructedDataMinimumValueTimestamp"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetConstructedDataMinimumValueTimestamp{
+ MinimumValueTimestamp: CastBACnetDateTime(minimumValueTimestamp),
+ BACnetConstructedData: &BACnetConstructedData{},
+ }
+ _child.BACnetConstructedData.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetConstructedDataMinimumValueTimestamp) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetConstructedDataMinimumValueTimestamp"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (minimumValueTimestamp)
+ if pushErr := writeBuffer.PushContext("minimumValueTimestamp"); pushErr != nil {
+ return pushErr
+ }
+ _minimumValueTimestampErr := m.MinimumValueTimestamp.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("minimumValueTimestamp"); popErr != nil {
+ return popErr
+ }
+ if _minimumValueTimestampErr != nil {
+ return errors.Wrap(_minimumValueTimestampErr, "Error serializing 'minimumValueTimestamp' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetConstructedDataMinimumValueTimestamp"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetConstructedDataMinimumValueTimestamp) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ buffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ if err := m.Serialize(buffer); err != nil {
+ return err.Error()
+ }
+ return buffer.GetBox().String()
+}
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataValidSamples.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataValidSamples.go
new file mode 100644
index 0000000000..7ef4b2d7e2
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataValidSamples.go
@@ -0,0 +1,211 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/spi/utils"
+ "github.com/pkg/errors"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// BACnetConstructedDataValidSamples is the data-structure of this message
+type BACnetConstructedDataValidSamples struct {
+ *BACnetConstructedData
+ ValidSamples *BACnetApplicationTagUnsignedInteger
+
+ // Arguments.
+ TagNumber uint8
+}
+
+// IBACnetConstructedDataValidSamples is the corresponding interface of BACnetConstructedDataValidSamples
+type IBACnetConstructedDataValidSamples interface {
+ IBACnetConstructedData
+ // GetValidSamples returns ValidSamples (property field)
+ GetValidSamples() *BACnetApplicationTagUnsignedInteger
+ // GetLengthInBytes returns the length in bytes
+ GetLengthInBytes() uint16
+ // GetLengthInBits returns the length in bits
+ GetLengthInBits() uint16
+ // Serialize serializes this type
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for discriminator values.
+///////////////////////
+
+func (m *BACnetConstructedDataValidSamples) GetObjectTypeArgument() BACnetObjectType {
+ return 0
+}
+
+func (m *BACnetConstructedDataValidSamples) GetPropertyIdentifierArgument() BACnetPropertyIdentifier {
+ return BACnetPropertyIdentifier_VALID_SAMPLES
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+func (m *BACnetConstructedDataValidSamples) InitializeParent(parent *BACnetConstructedData, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag) {
+ m.BACnetConstructedData.OpeningTag = openingTag
+ m.BACnetConstructedData.ClosingTag = closingTag
+}
+
+func (m *BACnetConstructedDataValidSamples) GetParent() *BACnetConstructedData {
+ return m.BACnetConstructedData
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetConstructedDataValidSamples) GetValidSamples() *BACnetApplicationTagUnsignedInteger {
+ return m.ValidSamples
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetConstructedDataValidSamples factory function for BACnetConstructedDataValidSamples
+func NewBACnetConstructedDataValidSamples(validSamples *BACnetApplicationTagUnsignedInteger, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag, tagNumber uint8) *BACnetConstructedDataValidSamples {
+ _result := &BACnetConstructedDataValidSamples{
+ ValidSamples: validSamples,
+ BACnetConstructedData: NewBACnetConstructedData(openingTag, closingTag, tagNumber),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetConstructedDataValidSamples(structType interface{}) *BACnetConstructedDataValidSamples {
+ if casted, ok := structType.(BACnetConstructedDataValidSamples); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConstructedDataValidSamples); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConstructedData); ok {
+ return CastBACnetConstructedDataValidSamples(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConstructedData); ok {
+ return CastBACnetConstructedDataValidSamples(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetConstructedDataValidSamples) GetTypeName() string {
+ return "BACnetConstructedDataValidSamples"
+}
+
+func (m *BACnetConstructedDataValidSamples) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetConstructedDataValidSamples) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (validSamples)
+ lengthInBits += m.ValidSamples.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetConstructedDataValidSamples) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetConstructedDataValidSamplesParse(readBuffer utils.ReadBuffer, tagNumber uint8, objectTypeArgument BACnetObjectType, propertyIdentifierArgument BACnetPropertyIdentifier) (*BACnetConstructedDataValidSamples, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetConstructedDataValidSamples"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (validSamples)
+ if pullErr := readBuffer.PullContext("validSamples"); pullErr != nil {
+ return nil, pullErr
+ }
+ _validSamples, _validSamplesErr := BACnetApplicationTagParse(readBuffer)
+ if _validSamplesErr != nil {
+ return nil, errors.Wrap(_validSamplesErr, "Error parsing 'validSamples' field")
+ }
+ validSamples := CastBACnetApplicationTagUnsignedInteger(_validSamples)
+ if closeErr := readBuffer.CloseContext("validSamples"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetConstructedDataValidSamples"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetConstructedDataValidSamples{
+ ValidSamples: CastBACnetApplicationTagUnsignedInteger(validSamples),
+ BACnetConstructedData: &BACnetConstructedData{},
+ }
+ _child.BACnetConstructedData.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetConstructedDataValidSamples) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetConstructedDataValidSamples"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (validSamples)
+ if pushErr := writeBuffer.PushContext("validSamples"); pushErr != nil {
+ return pushErr
+ }
+ _validSamplesErr := m.ValidSamples.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("validSamples"); popErr != nil {
+ return popErr
+ }
+ if _validSamplesErr != nil {
+ return errors.Wrap(_validSamplesErr, "Error serializing 'validSamples' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetConstructedDataValidSamples"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetConstructedDataValidSamples) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ buffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ if err := m.Serialize(buffer); err != nil {
+ return err.Error()
+ }
+ return buffer.GetBox().String()
+}
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataVarianceValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataVarianceValue.go
new file mode 100644
index 0000000000..5a08ec9743
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataVarianceValue.go
@@ -0,0 +1,211 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/spi/utils"
+ "github.com/pkg/errors"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// BACnetConstructedDataVarianceValue is the data-structure of this message
+type BACnetConstructedDataVarianceValue struct {
+ *BACnetConstructedData
+ VarianceValue *BACnetApplicationTagReal
+
+ // Arguments.
+ TagNumber uint8
+}
+
+// IBACnetConstructedDataVarianceValue is the corresponding interface of BACnetConstructedDataVarianceValue
+type IBACnetConstructedDataVarianceValue interface {
+ IBACnetConstructedData
+ // GetVarianceValue returns VarianceValue (property field)
+ GetVarianceValue() *BACnetApplicationTagReal
+ // GetLengthInBytes returns the length in bytes
+ GetLengthInBytes() uint16
+ // GetLengthInBits returns the length in bits
+ GetLengthInBits() uint16
+ // Serialize serializes this type
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for discriminator values.
+///////////////////////
+
+func (m *BACnetConstructedDataVarianceValue) GetObjectTypeArgument() BACnetObjectType {
+ return 0
+}
+
+func (m *BACnetConstructedDataVarianceValue) GetPropertyIdentifierArgument() BACnetPropertyIdentifier {
+ return BACnetPropertyIdentifier_VARIANCE_VALUE
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+func (m *BACnetConstructedDataVarianceValue) InitializeParent(parent *BACnetConstructedData, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag) {
+ m.BACnetConstructedData.OpeningTag = openingTag
+ m.BACnetConstructedData.ClosingTag = closingTag
+}
+
+func (m *BACnetConstructedDataVarianceValue) GetParent() *BACnetConstructedData {
+ return m.BACnetConstructedData
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetConstructedDataVarianceValue) GetVarianceValue() *BACnetApplicationTagReal {
+ return m.VarianceValue
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetConstructedDataVarianceValue factory function for BACnetConstructedDataVarianceValue
+func NewBACnetConstructedDataVarianceValue(varianceValue *BACnetApplicationTagReal, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag, tagNumber uint8) *BACnetConstructedDataVarianceValue {
+ _result := &BACnetConstructedDataVarianceValue{
+ VarianceValue: varianceValue,
+ BACnetConstructedData: NewBACnetConstructedData(openingTag, closingTag, tagNumber),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetConstructedDataVarianceValue(structType interface{}) *BACnetConstructedDataVarianceValue {
+ if casted, ok := structType.(BACnetConstructedDataVarianceValue); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConstructedDataVarianceValue); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConstructedData); ok {
+ return CastBACnetConstructedDataVarianceValue(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConstructedData); ok {
+ return CastBACnetConstructedDataVarianceValue(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetConstructedDataVarianceValue) GetTypeName() string {
+ return "BACnetConstructedDataVarianceValue"
+}
+
+func (m *BACnetConstructedDataVarianceValue) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetConstructedDataVarianceValue) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (varianceValue)
+ lengthInBits += m.VarianceValue.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetConstructedDataVarianceValue) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetConstructedDataVarianceValueParse(readBuffer utils.ReadBuffer, tagNumber uint8, objectTypeArgument BACnetObjectType, propertyIdentifierArgument BACnetPropertyIdentifier) (*BACnetConstructedDataVarianceValue, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetConstructedDataVarianceValue"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (varianceValue)
+ if pullErr := readBuffer.PullContext("varianceValue"); pullErr != nil {
+ return nil, pullErr
+ }
+ _varianceValue, _varianceValueErr := BACnetApplicationTagParse(readBuffer)
+ if _varianceValueErr != nil {
+ return nil, errors.Wrap(_varianceValueErr, "Error parsing 'varianceValue' field")
+ }
+ varianceValue := CastBACnetApplicationTagReal(_varianceValue)
+ if closeErr := readBuffer.CloseContext("varianceValue"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetConstructedDataVarianceValue"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetConstructedDataVarianceValue{
+ VarianceValue: CastBACnetApplicationTagReal(varianceValue),
+ BACnetConstructedData: &BACnetConstructedData{},
+ }
+ _child.BACnetConstructedData.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetConstructedDataVarianceValue) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetConstructedDataVarianceValue"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (varianceValue)
+ if pushErr := writeBuffer.PushContext("varianceValue"); pushErr != nil {
+ return pushErr
+ }
+ _varianceValueErr := m.VarianceValue.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("varianceValue"); popErr != nil {
+ return popErr
+ }
+ if _varianceValueErr != nil {
+ return errors.Wrap(_varianceValueErr, "Error serializing 'varianceValue' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetConstructedDataVarianceValue"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetConstructedDataVarianceValue) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ buffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ if err := m.Serialize(buffer); err != nil {
+ return err.Error()
+ }
+ return buffer.GetBox().String()
+}
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataWindowInterval.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataWindowInterval.go
new file mode 100644
index 0000000000..f9a9154e66
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataWindowInterval.go
@@ -0,0 +1,211 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/spi/utils"
+ "github.com/pkg/errors"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// BACnetConstructedDataWindowInterval is the data-structure of this message
+type BACnetConstructedDataWindowInterval struct {
+ *BACnetConstructedData
+ WindowInterval *BACnetApplicationTagUnsignedInteger
+
+ // Arguments.
+ TagNumber uint8
+}
+
+// IBACnetConstructedDataWindowInterval is the corresponding interface of BACnetConstructedDataWindowInterval
+type IBACnetConstructedDataWindowInterval interface {
+ IBACnetConstructedData
+ // GetWindowInterval returns WindowInterval (property field)
+ GetWindowInterval() *BACnetApplicationTagUnsignedInteger
+ // GetLengthInBytes returns the length in bytes
+ GetLengthInBytes() uint16
+ // GetLengthInBits returns the length in bits
+ GetLengthInBits() uint16
+ // Serialize serializes this type
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for discriminator values.
+///////////////////////
+
+func (m *BACnetConstructedDataWindowInterval) GetObjectTypeArgument() BACnetObjectType {
+ return 0
+}
+
+func (m *BACnetConstructedDataWindowInterval) GetPropertyIdentifierArgument() BACnetPropertyIdentifier {
+ return BACnetPropertyIdentifier_WINDOW_INTERVAL
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+func (m *BACnetConstructedDataWindowInterval) InitializeParent(parent *BACnetConstructedData, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag) {
+ m.BACnetConstructedData.OpeningTag = openingTag
+ m.BACnetConstructedData.ClosingTag = closingTag
+}
+
+func (m *BACnetConstructedDataWindowInterval) GetParent() *BACnetConstructedData {
+ return m.BACnetConstructedData
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetConstructedDataWindowInterval) GetWindowInterval() *BACnetApplicationTagUnsignedInteger {
+ return m.WindowInterval
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetConstructedDataWindowInterval factory function for BACnetConstructedDataWindowInterval
+func NewBACnetConstructedDataWindowInterval(windowInterval *BACnetApplicationTagUnsignedInteger, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag, tagNumber uint8) *BACnetConstructedDataWindowInterval {
+ _result := &BACnetConstructedDataWindowInterval{
+ WindowInterval: windowInterval,
+ BACnetConstructedData: NewBACnetConstructedData(openingTag, closingTag, tagNumber),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetConstructedDataWindowInterval(structType interface{}) *BACnetConstructedDataWindowInterval {
+ if casted, ok := structType.(BACnetConstructedDataWindowInterval); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConstructedDataWindowInterval); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConstructedData); ok {
+ return CastBACnetConstructedDataWindowInterval(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConstructedData); ok {
+ return CastBACnetConstructedDataWindowInterval(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetConstructedDataWindowInterval) GetTypeName() string {
+ return "BACnetConstructedDataWindowInterval"
+}
+
+func (m *BACnetConstructedDataWindowInterval) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetConstructedDataWindowInterval) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (windowInterval)
+ lengthInBits += m.WindowInterval.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetConstructedDataWindowInterval) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetConstructedDataWindowIntervalParse(readBuffer utils.ReadBuffer, tagNumber uint8, objectTypeArgument BACnetObjectType, propertyIdentifierArgument BACnetPropertyIdentifier) (*BACnetConstructedDataWindowInterval, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetConstructedDataWindowInterval"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (windowInterval)
+ if pullErr := readBuffer.PullContext("windowInterval"); pullErr != nil {
+ return nil, pullErr
+ }
+ _windowInterval, _windowIntervalErr := BACnetApplicationTagParse(readBuffer)
+ if _windowIntervalErr != nil {
+ return nil, errors.Wrap(_windowIntervalErr, "Error parsing 'windowInterval' field")
+ }
+ windowInterval := CastBACnetApplicationTagUnsignedInteger(_windowInterval)
+ if closeErr := readBuffer.CloseContext("windowInterval"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetConstructedDataWindowInterval"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetConstructedDataWindowInterval{
+ WindowInterval: CastBACnetApplicationTagUnsignedInteger(windowInterval),
+ BACnetConstructedData: &BACnetConstructedData{},
+ }
+ _child.BACnetConstructedData.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetConstructedDataWindowInterval) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetConstructedDataWindowInterval"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (windowInterval)
+ if pushErr := writeBuffer.PushContext("windowInterval"); pushErr != nil {
+ return pushErr
+ }
+ _windowIntervalErr := m.WindowInterval.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("windowInterval"); popErr != nil {
+ return popErr
+ }
+ if _windowIntervalErr != nil {
+ return errors.Wrap(_windowIntervalErr, "Error serializing 'windowInterval' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetConstructedDataWindowInterval"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetConstructedDataWindowInterval) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ buffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ if err := m.Serialize(buffer); err != nil {
+ return err.Error()
+ }
+ return buffer.GetBox().String()
+}
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataWindowSamples.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataWindowSamples.go
new file mode 100644
index 0000000000..13ca53e156
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataWindowSamples.go
@@ -0,0 +1,211 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package model
+
+import (
+ "github.com/apache/plc4x/plc4go/internal/spi/utils"
+ "github.com/pkg/errors"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// BACnetConstructedDataWindowSamples is the data-structure of this message
+type BACnetConstructedDataWindowSamples struct {
+ *BACnetConstructedData
+ WindowSamples *BACnetApplicationTagUnsignedInteger
+
+ // Arguments.
+ TagNumber uint8
+}
+
+// IBACnetConstructedDataWindowSamples is the corresponding interface of BACnetConstructedDataWindowSamples
+type IBACnetConstructedDataWindowSamples interface {
+ IBACnetConstructedData
+ // GetWindowSamples returns WindowSamples (property field)
+ GetWindowSamples() *BACnetApplicationTagUnsignedInteger
+ // GetLengthInBytes returns the length in bytes
+ GetLengthInBytes() uint16
+ // GetLengthInBits returns the length in bits
+ GetLengthInBits() uint16
+ // Serialize serializes this type
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for discriminator values.
+///////////////////////
+
+func (m *BACnetConstructedDataWindowSamples) GetObjectTypeArgument() BACnetObjectType {
+ return 0
+}
+
+func (m *BACnetConstructedDataWindowSamples) GetPropertyIdentifierArgument() BACnetPropertyIdentifier {
+ return BACnetPropertyIdentifier_WINDOW_SAMPLES
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+func (m *BACnetConstructedDataWindowSamples) InitializeParent(parent *BACnetConstructedData, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag) {
+ m.BACnetConstructedData.OpeningTag = openingTag
+ m.BACnetConstructedData.ClosingTag = closingTag
+}
+
+func (m *BACnetConstructedDataWindowSamples) GetParent() *BACnetConstructedData {
+ return m.BACnetConstructedData
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetConstructedDataWindowSamples) GetWindowSamples() *BACnetApplicationTagUnsignedInteger {
+ return m.WindowSamples
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetConstructedDataWindowSamples factory function for BACnetConstructedDataWindowSamples
+func NewBACnetConstructedDataWindowSamples(windowSamples *BACnetApplicationTagUnsignedInteger, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag, tagNumber uint8) *BACnetConstructedDataWindowSamples {
+ _result := &BACnetConstructedDataWindowSamples{
+ WindowSamples: windowSamples,
+ BACnetConstructedData: NewBACnetConstructedData(openingTag, closingTag, tagNumber),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetConstructedDataWindowSamples(structType interface{}) *BACnetConstructedDataWindowSamples {
+ if casted, ok := structType.(BACnetConstructedDataWindowSamples); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConstructedDataWindowSamples); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConstructedData); ok {
+ return CastBACnetConstructedDataWindowSamples(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConstructedData); ok {
+ return CastBACnetConstructedDataWindowSamples(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetConstructedDataWindowSamples) GetTypeName() string {
+ return "BACnetConstructedDataWindowSamples"
+}
+
+func (m *BACnetConstructedDataWindowSamples) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetConstructedDataWindowSamples) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (windowSamples)
+ lengthInBits += m.WindowSamples.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetConstructedDataWindowSamples) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetConstructedDataWindowSamplesParse(readBuffer utils.ReadBuffer, tagNumber uint8, objectTypeArgument BACnetObjectType, propertyIdentifierArgument BACnetPropertyIdentifier) (*BACnetConstructedDataWindowSamples, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetConstructedDataWindowSamples"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (windowSamples)
+ if pullErr := readBuffer.PullContext("windowSamples"); pullErr != nil {
+ return nil, pullErr
+ }
+ _windowSamples, _windowSamplesErr := BACnetApplicationTagParse(readBuffer)
+ if _windowSamplesErr != nil {
+ return nil, errors.Wrap(_windowSamplesErr, "Error parsing 'windowSamples' field")
+ }
+ windowSamples := CastBACnetApplicationTagUnsignedInteger(_windowSamples)
+ if closeErr := readBuffer.CloseContext("windowSamples"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetConstructedDataWindowSamples"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetConstructedDataWindowSamples{
+ WindowSamples: CastBACnetApplicationTagUnsignedInteger(windowSamples),
+ BACnetConstructedData: &BACnetConstructedData{},
+ }
+ _child.BACnetConstructedData.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetConstructedDataWindowSamples) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetConstructedDataWindowSamples"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (windowSamples)
+ if pushErr := writeBuffer.PushContext("windowSamples"); pushErr != nil {
+ return pushErr
+ }
+ _windowSamplesErr := m.WindowSamples.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("windowSamples"); popErr != nil {
+ return popErr
+ }
+ if _windowSamplesErr != nil {
+ return errors.Wrap(_windowSamplesErr, "Error serializing 'windowSamples' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetConstructedDataWindowSamples"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetConstructedDataWindowSamples) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ buffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ if err := m.Serialize(buffer); err != nil {
+ return err.Error()
+ }
+ return buffer.GetBox().String()
+}
diff --git a/protocols/bacnetip/src/main/resources/protocols/bacnetip/bacnetip.mspec b/protocols/bacnetip/src/main/resources/protocols/bacnetip/bacnetip.mspec
index 41cb1c0ba9..523d49084d 100644
--- a/protocols/bacnetip/src/main/resources/protocols/bacnetip/bacnetip.mspec
+++ b/protocols/bacnetip/src/main/resources/protocols/bacnetip/bacnetip.mspec
@@ -2620,7 +2620,9 @@
terminated
'STATIC_CALL("isBACnetConstructedDataClosingTag", readBuffer, false, tagNumber)' ]
]
- //[*, 'ATTEMPTED_SAMPLES' BACnetConstructedDataAttemptedSamples [validation '1 == 2' "TODO: implement me ATTEMPTED_SAMPLES BACnetConstructedDataAttemptedSamples"]]
+ [*, 'ATTEMPTED_SAMPLES' BACnetConstructedDataAttemptedSamples
+ [simple BACnetApplicationTagUnsignedInteger attemptedSamples ]
+ ]
[*, 'AUTHENTICATION_FACTORS' BACnetConstructedDataAuthenticationFactors
[array BACnetCredentialAuthenticationFactor
authenticationFactors
@@ -2654,7 +2656,9 @@
[*, 'AUTO_SLAVE_DISCOVERY' BACnetConstructedDataAutoSlaveDiscovery
[simple BACnetApplicationTagBoolean autoSlaveDiscovery ]
]
- //[*, 'AVERAGE_VALUE' BACnetConstructedDataAverageValue [validation '1 == 2' "TODO: implement me AVERAGE_VALUE BACnetConstructedDataAverageValue"]]
+ [*, 'AVERAGE_VALUE' BACnetConstructedDataAverageValue
+ [simple BACnetApplicationTagReal averageValue ]
+ ]
[*, 'BACKUP_AND_RESTORE_STATE' BACnetConstructedDataBackupAndRestoreState
[simple BACnetBackupStateTagged('0', 'TagClass.APPLICATION_TAGS') backupAndRestoreState ]
]
@@ -3350,8 +3354,12 @@
[*, 'MAXIMUM_OUTPUT' BACnetConstructedDataMaximumOutput
[simple BACnetApplicationTagReal maximumOutput ]
]
- //[*, 'MAXIMUM_VALUE' BACnetConstructedDataMaximumValue [validation '1 == 2' "TODO: implement me MAXIMUM_VALUE BACnetConstructedDataMaximumValue"]]
- //[*, 'MAXIMUM_VALUE_TIMESTAMP' BACnetConstructedDataMaximumValueTimestamp [validation '1 == 2' "TODO: implement me MAXIMUM_VALUE_TIMESTAMP BACnetConstructedDataMaximumValueTimestamp"]]
+ [*, 'MAXIMUM_VALUE' BACnetConstructedDataMaximumValue
+ [simple BACnetApplicationTagReal maximumValue ]
+ ]
+ [*, 'MAXIMUM_VALUE_TIMESTAMP' BACnetConstructedDataMaximumValueTimestamp
+ [simple BACnetDateTime maximumValueTimestamp ]
+ ]
[*, 'MEMBER_OF' BACnetConstructedDataMemberOf
[array BACnetDeviceObjectReference
zones
@@ -3384,7 +3392,9 @@
[*, 'MINIMUM_VALUE' BACnetConstructedDataMinimumValue
[simple BACnetApplicationTagReal minimumValue ]
]
- //[*, 'MINIMUM_VALUE_TIMESTAMP' BACnetConstructedDataMinimumValueTimestamp [validation '1 == 2' "TODO: implement me MINIMUM_VALUE_TIMESTAMP BACnetConstructedDataMinimumValueTimestamp"]]
+ [*, 'MINIMUM_VALUE_TIMESTAMP' BACnetConstructedDataMinimumValueTimestamp
+ [simple BACnetDateTime minimumValueTimestamp ]
+ ]
//[*, 'MODE' BACnetConstructedDataMode [validation '1 == 2' "TODO: implement me MODE BACnetConstructedDataMode"]]
[*, 'MODEL_NAME' BACnetConstructedDataModelName
[simple BACnetApplicationTagCharacterString modelName ]
@@ -3860,13 +3870,17 @@
terminated
'STATIC_CALL("isBACnetConstructedDataClosingTag", readBuffer, false, tagNumber)']
]
- //[*, 'VALID_SAMPLES' BACnetConstructedDataValidSamples [validation '1 == 2' "TODO: implement me VALID_SAMPLES BACnetConstructedDataValidSamples"]]
+ [*, 'VALID_SAMPLES' BACnetConstructedDataValidSamples
+ [simple BACnetApplicationTagUnsignedInteger validSamples ]
+ ]
//[*, 'VALUE_BEFORE_CHANGE' BACnetConstructedDataValueBeforeChange [validation '1 == 2' "TODO: implement me VALUE_BEFORE_CHANGE BACnetConstructedDataValueBeforeChange"]]
//[*, 'VALUE_CHANGE_TIME' BACnetConstructedDataValueChangeTime [validation '1 == 2' "TODO: implement me VALUE_CHANGE_TIME BACnetConstructedDataValueChangeTime"]]
//[*, 'VALUE_SET' BACnetConstructedDataValueSet [validation '1 == 2' "TODO: implement me VALUE_SET BACnetConstructedDataValueSet"]]
//[*, 'VALUE_SOURCE' BACnetConstructedDataValueSource [validation '1 == 2' "TODO: implement me VALUE_SOURCE BACnetConstructedDataValueSource"]]
//[*, 'VALUE_SOURCE_ARRAY' BACnetConstructedDataValueSourceArray [validation '1 == 2' "TODO: implement me VALUE_SOURCE_ARRAY BACnetConstructedDataValueSourceArray"]]
- //[*, 'VARIANCE_VALUE' BACnetConstructedDataVarianceValue [validation '1 == 2' "TODO: implement me VARIANCE_VALUE BACnetConstructedDataVarianceValue"]]
+ [*, 'VARIANCE_VALUE' BACnetConstructedDataVarianceValue
+ [simple BACnetApplicationTagReal varianceValue ]
+ ]
[*, 'VENDOR_IDENTIFIER' BACnetConstructedDataVendorIdentifier
[simple BACnetVendorIdTagged('0', 'TagClass.APPLICATION_TAGS') vendorIdentifier ]
]
@@ -3896,8 +3910,12 @@
// TODO: check if we have an array index... in this case it can be below 7... till then we deactivate this check
//[validation 'COUNT(weeklySchedule) == 7' "weeklySchedule should have exactly 7 values" ]
]
- //[*, 'WINDOW_INTERVAL' BACnetConstructedDataWindowInterval [validation '1 == 2' "TODO: implement me WINDOW_INTERVAL BACnetConstructedDataWindowInterval"]]
- //[*, 'WINDOW_SAMPLES' BACnetConstructedDataWindowSamples [validation '1 == 2' "TODO: implement me WINDOW_SAMPLES BACnetConstructedDataWindowSamples"]]
+ [*, 'WINDOW_INTERVAL' BACnetConstructedDataWindowInterval
+ [simple BACnetApplicationTagUnsignedInteger windowInterval ]
+ ]
+ [*, 'WINDOW_SAMPLES' BACnetConstructedDataWindowSamples
+ [simple BACnetApplicationTagUnsignedInteger windowSamples ]
+ ]
[*, 'WRITE_STATUS' BACnetConstructedDataWriteStatus
[simple BACnetWriteStatusTagged('0', 'TagClass.APPLICATION_TAGS') writeStatus ]
]