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/05/10 15:44:20 UTC
[plc4x] branch develop updated: feat(bacnet): implemented BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple
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
The following commit(s) were added to refs/heads/develop by this push:
new 1d395694d1 feat(bacnet): implemented BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple
1d395694d1 is described below
commit 1d395694d1bea0ae9836227c811442f78cefa48b
Author: Sebastian Rühl <sr...@apache.org>
AuthorDate: Tue May 10 17:44:13 2022 +0200
feat(bacnet): implemented BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple
---
.../plc4go/bacnetip/readwrite/ParserHelper.go | 9 +
.../plc4go/bacnetip/readwrite/XmlParserHelper.go | 10 +
...rviceRequestConfirmedCOVNotificationMultiple.go | 213 ++++++++++++-
...OVNotificationMultipleListOfCovNotifications.go | 349 +++++++++++++++++++++
...ificationMultipleListOfCovNotificationsValue.go | 293 +++++++++++++++++
.../resources/protocols/bacnetip/bacnetip.mspec | 35 ++-
6 files changed, 907 insertions(+), 2 deletions(-)
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/ParserHelper.go b/plc4go/internal/plc4go/bacnetip/readwrite/ParserHelper.go
index 14a2bfba7a..2380d7c090 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/ParserHelper.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/ParserHelper.go
@@ -82,6 +82,12 @@ func (m BacnetipParserHelper) Parse(typeName string, arguments []string, io util
return nil, errors.Wrap(err, "Error parsing")
}
return model.BACnetTagPayloadEnumeratedParse(io, actualLength)
+ case "BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications":
+ tagNumber, err := utils.StrToUint8(arguments[0])
+ if err != nil {
+ return nil, errors.Wrap(err, "Error parsing")
+ }
+ return model.BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsParse(io, tagNumber)
case "BACnetTagPayloadOctetString":
actualLength, err := utils.StrToUint32(arguments[0])
if err != nil {
@@ -161,6 +167,9 @@ func (m BacnetipParserHelper) Parse(typeName string, arguments []string, io util
return nil, errors.Wrap(err, "Error parsing")
}
return model.APDUParse(io, apduLength)
+ case "BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue":
+ objectType := model.BACnetObjectTypeByName(arguments[0])
+ return model.BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValueParse(io, objectType)
case "BACnetTagPayloadCharacterString":
actualLength, err := utils.StrToUint32(arguments[0])
if err != nil {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/XmlParserHelper.go b/plc4go/internal/plc4go/bacnetip/readwrite/XmlParserHelper.go
index 0a768b7f90..9f7b694c6a 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/XmlParserHelper.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/XmlParserHelper.go
@@ -98,6 +98,13 @@ func (m BacnetipXmlParserHelper) Parse(typeName string, xmlString string, parser
}
actualLength := uint32(parsedUint0)
return model.BACnetTagPayloadEnumeratedParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)), actualLength)
+ case "BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications":
+ parsedUint0, err := strconv.ParseUint(parserArguments[0], 10, 8)
+ if err != nil {
+ return nil, err
+ }
+ tagNumber := uint8(parsedUint0)
+ return model.BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)), tagNumber)
case "BACnetTagPayloadOctetString":
parsedUint0, err := strconv.ParseUint(parserArguments[0], 10, 32)
if err != nil {
@@ -187,6 +194,9 @@ func (m BacnetipXmlParserHelper) Parse(typeName string, xmlString string, parser
}
apduLength := uint16(parsedUint0)
return model.APDUParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)), apduLength)
+ case "BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue":
+ objectType := model.BACnetObjectTypeByName(parserArguments[0])
+ return model.BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValueParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)), objectType)
case "BACnetTagPayloadCharacterString":
parsedUint0, err := strconv.ParseUint(parserArguments[0], 10, 32)
if err != nil {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple.go
index ff78c64a4c..fe5a343b8b 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple.go
@@ -21,6 +21,8 @@ package model
import (
"github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
+ "github.com/pkg/errors"
+ "io"
)
// Code generated by code-generation. DO NOT EDIT.
@@ -28,6 +30,11 @@ import (
// BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple is the data-structure of this message
type BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple struct {
*BACnetConfirmedServiceRequest
+ SubscriberProcessIdentifier *BACnetContextTagUnsignedInteger
+ InitiatingDeviceIdentifier *BACnetContextTagObjectIdentifier
+ TimeRemaining *BACnetContextTagUnsignedInteger
+ Timestamp *BACnetTimeStamp
+ ListOfCovNotifications *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications
// Arguments.
ServiceRequestLength uint16
@@ -36,6 +43,16 @@ type BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple struct {
// IBACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple is the corresponding interface of BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple
type IBACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple interface {
IBACnetConfirmedServiceRequest
+ // GetSubscriberProcessIdentifier returns SubscriberProcessIdentifier (property field)
+ GetSubscriberProcessIdentifier() *BACnetContextTagUnsignedInteger
+ // GetInitiatingDeviceIdentifier returns InitiatingDeviceIdentifier (property field)
+ GetInitiatingDeviceIdentifier() *BACnetContextTagObjectIdentifier
+ // GetTimeRemaining returns TimeRemaining (property field)
+ GetTimeRemaining() *BACnetContextTagUnsignedInteger
+ // GetTimestamp returns Timestamp (property field)
+ GetTimestamp() *BACnetTimeStamp
+ // GetListOfCovNotifications returns ListOfCovNotifications (property field)
+ GetListOfCovNotifications() *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications
// GetLengthInBytes returns the length in bytes
GetLengthInBytes() uint16
// GetLengthInBits returns the length in bits
@@ -65,9 +82,44 @@ func (m *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple) GetParen
return m.BACnetConfirmedServiceRequest
}
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple) GetSubscriberProcessIdentifier() *BACnetContextTagUnsignedInteger {
+ return m.SubscriberProcessIdentifier
+}
+
+func (m *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple) GetInitiatingDeviceIdentifier() *BACnetContextTagObjectIdentifier {
+ return m.InitiatingDeviceIdentifier
+}
+
+func (m *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple) GetTimeRemaining() *BACnetContextTagUnsignedInteger {
+ return m.TimeRemaining
+}
+
+func (m *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple) GetTimestamp() *BACnetTimeStamp {
+ return m.Timestamp
+}
+
+func (m *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple) GetListOfCovNotifications() *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications {
+ return m.ListOfCovNotifications
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
// NewBACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple factory function for BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple
-func NewBACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple(serviceRequestLength uint16) *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple {
+func NewBACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple(subscriberProcessIdentifier *BACnetContextTagUnsignedInteger, initiatingDeviceIdentifier *BACnetContextTagObjectIdentifier, timeRemaining *BACnetContextTagUnsignedInteger, timestamp *BACnetTimeStamp, listOfCovNotifications *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications, serviceRequestLength uint16) *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple {
_result := &BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple{
+ SubscriberProcessIdentifier: subscriberProcessIdentifier,
+ InitiatingDeviceIdentifier: initiatingDeviceIdentifier,
+ TimeRemaining: timeRemaining,
+ Timestamp: timestamp,
+ ListOfCovNotifications: listOfCovNotifications,
BACnetConfirmedServiceRequest: NewBACnetConfirmedServiceRequest(serviceRequestLength),
}
_result.Child = _result
@@ -101,6 +153,23 @@ func (m *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple) GetLengt
func (m *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple) GetLengthInBitsConditional(lastItem bool) uint16 {
lengthInBits := uint16(m.GetParentLengthInBits())
+ // Simple field (subscriberProcessIdentifier)
+ lengthInBits += m.SubscriberProcessIdentifier.GetLengthInBits()
+
+ // Simple field (initiatingDeviceIdentifier)
+ lengthInBits += m.InitiatingDeviceIdentifier.GetLengthInBits()
+
+ // Simple field (timeRemaining)
+ lengthInBits += m.TimeRemaining.GetLengthInBits()
+
+ // Optional Field (timestamp)
+ if m.Timestamp != nil {
+ lengthInBits += (*m.Timestamp).GetLengthInBits()
+ }
+
+ // Simple field (listOfCovNotifications)
+ lengthInBits += m.ListOfCovNotifications.GetLengthInBits()
+
return lengthInBits
}
@@ -115,12 +184,90 @@ func BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleParse(readBuff
currentPos := readBuffer.GetPos()
_ = currentPos
+ // Simple Field (subscriberProcessIdentifier)
+ if pullErr := readBuffer.PullContext("subscriberProcessIdentifier"); pullErr != nil {
+ return nil, pullErr
+ }
+ _subscriberProcessIdentifier, _subscriberProcessIdentifierErr := BACnetContextTagParse(readBuffer, uint8(uint8(0)), BACnetDataType(BACnetDataType_UNSIGNED_INTEGER))
+ if _subscriberProcessIdentifierErr != nil {
+ return nil, errors.Wrap(_subscriberProcessIdentifierErr, "Error parsing 'subscriberProcessIdentifier' field")
+ }
+ subscriberProcessIdentifier := CastBACnetContextTagUnsignedInteger(_subscriberProcessIdentifier)
+ if closeErr := readBuffer.CloseContext("subscriberProcessIdentifier"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (initiatingDeviceIdentifier)
+ if pullErr := readBuffer.PullContext("initiatingDeviceIdentifier"); pullErr != nil {
+ return nil, pullErr
+ }
+ _initiatingDeviceIdentifier, _initiatingDeviceIdentifierErr := BACnetContextTagParse(readBuffer, uint8(uint8(1)), BACnetDataType(BACnetDataType_BACNET_OBJECT_IDENTIFIER))
+ if _initiatingDeviceIdentifierErr != nil {
+ return nil, errors.Wrap(_initiatingDeviceIdentifierErr, "Error parsing 'initiatingDeviceIdentifier' field")
+ }
+ initiatingDeviceIdentifier := CastBACnetContextTagObjectIdentifier(_initiatingDeviceIdentifier)
+ if closeErr := readBuffer.CloseContext("initiatingDeviceIdentifier"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (timeRemaining)
+ if pullErr := readBuffer.PullContext("timeRemaining"); pullErr != nil {
+ return nil, pullErr
+ }
+ _timeRemaining, _timeRemainingErr := BACnetContextTagParse(readBuffer, uint8(uint8(2)), BACnetDataType(BACnetDataType_UNSIGNED_INTEGER))
+ if _timeRemainingErr != nil {
+ return nil, errors.Wrap(_timeRemainingErr, "Error parsing 'timeRemaining' field")
+ }
+ timeRemaining := CastBACnetContextTagUnsignedInteger(_timeRemaining)
+ if closeErr := readBuffer.CloseContext("timeRemaining"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Optional Field (timestamp) (Can be skipped, if a given expression evaluates to false)
+ var timestamp *BACnetTimeStamp = nil
+ {
+ currentPos = readBuffer.GetPos()
+ if pullErr := readBuffer.PullContext("timestamp"); pullErr != nil {
+ return nil, pullErr
+ }
+ _val, _err := BACnetTimeStampParse(readBuffer, uint8(3))
+ switch {
+ case errors.Is(_err, utils.ParseAssertError{}) || errors.Is(_err, io.EOF):
+ readBuffer.Reset(currentPos)
+ case _err != nil:
+ return nil, errors.Wrap(_err, "Error parsing 'timestamp' field")
+ default:
+ timestamp = CastBACnetTimeStamp(_val)
+ if closeErr := readBuffer.CloseContext("timestamp"); closeErr != nil {
+ return nil, closeErr
+ }
+ }
+ }
+
+ // Simple Field (listOfCovNotifications)
+ if pullErr := readBuffer.PullContext("listOfCovNotifications"); pullErr != nil {
+ return nil, pullErr
+ }
+ _listOfCovNotifications, _listOfCovNotificationsErr := BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsParse(readBuffer, uint8(uint8(4)))
+ if _listOfCovNotificationsErr != nil {
+ return nil, errors.Wrap(_listOfCovNotificationsErr, "Error parsing 'listOfCovNotifications' field")
+ }
+ listOfCovNotifications := CastBACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications(_listOfCovNotifications)
+ if closeErr := readBuffer.CloseContext("listOfCovNotifications"); closeErr != nil {
+ return nil, closeErr
+ }
+
if closeErr := readBuffer.CloseContext("BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple"); closeErr != nil {
return nil, closeErr
}
// Create a partially initialized instance
_child := &BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple{
+ SubscriberProcessIdentifier: CastBACnetContextTagUnsignedInteger(subscriberProcessIdentifier),
+ InitiatingDeviceIdentifier: CastBACnetContextTagObjectIdentifier(initiatingDeviceIdentifier),
+ TimeRemaining: CastBACnetContextTagUnsignedInteger(timeRemaining),
+ Timestamp: CastBACnetTimeStamp(timestamp),
+ ListOfCovNotifications: CastBACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications(listOfCovNotifications),
BACnetConfirmedServiceRequest: &BACnetConfirmedServiceRequest{},
}
_child.BACnetConfirmedServiceRequest.Child = _child
@@ -133,6 +280,70 @@ func (m *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple) Serializ
return pushErr
}
+ // Simple Field (subscriberProcessIdentifier)
+ if pushErr := writeBuffer.PushContext("subscriberProcessIdentifier"); pushErr != nil {
+ return pushErr
+ }
+ _subscriberProcessIdentifierErr := m.SubscriberProcessIdentifier.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("subscriberProcessIdentifier"); popErr != nil {
+ return popErr
+ }
+ if _subscriberProcessIdentifierErr != nil {
+ return errors.Wrap(_subscriberProcessIdentifierErr, "Error serializing 'subscriberProcessIdentifier' field")
+ }
+
+ // Simple Field (initiatingDeviceIdentifier)
+ if pushErr := writeBuffer.PushContext("initiatingDeviceIdentifier"); pushErr != nil {
+ return pushErr
+ }
+ _initiatingDeviceIdentifierErr := m.InitiatingDeviceIdentifier.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("initiatingDeviceIdentifier"); popErr != nil {
+ return popErr
+ }
+ if _initiatingDeviceIdentifierErr != nil {
+ return errors.Wrap(_initiatingDeviceIdentifierErr, "Error serializing 'initiatingDeviceIdentifier' field")
+ }
+
+ // Simple Field (timeRemaining)
+ if pushErr := writeBuffer.PushContext("timeRemaining"); pushErr != nil {
+ return pushErr
+ }
+ _timeRemainingErr := m.TimeRemaining.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("timeRemaining"); popErr != nil {
+ return popErr
+ }
+ if _timeRemainingErr != nil {
+ return errors.Wrap(_timeRemainingErr, "Error serializing 'timeRemaining' field")
+ }
+
+ // Optional Field (timestamp) (Can be skipped, if the value is null)
+ var timestamp *BACnetTimeStamp = nil
+ if m.Timestamp != nil {
+ if pushErr := writeBuffer.PushContext("timestamp"); pushErr != nil {
+ return pushErr
+ }
+ timestamp = m.Timestamp
+ _timestampErr := timestamp.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("timestamp"); popErr != nil {
+ return popErr
+ }
+ if _timestampErr != nil {
+ return errors.Wrap(_timestampErr, "Error serializing 'timestamp' field")
+ }
+ }
+
+ // Simple Field (listOfCovNotifications)
+ if pushErr := writeBuffer.PushContext("listOfCovNotifications"); pushErr != nil {
+ return pushErr
+ }
+ _listOfCovNotificationsErr := m.ListOfCovNotifications.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("listOfCovNotifications"); popErr != nil {
+ return popErr
+ }
+ if _listOfCovNotificationsErr != nil {
+ return errors.Wrap(_listOfCovNotificationsErr, "Error serializing 'listOfCovNotifications' field")
+ }
+
if popErr := writeBuffer.PopContext("BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple"); popErr != nil {
return popErr
}
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications.go
new file mode 100644
index 0000000000..1e96175cce
--- /dev/null
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications.go
@@ -0,0 +1,349 @@
+/*
+ * 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/plc4go/spi/utils"
+ "github.com/pkg/errors"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications is the data-structure of this message
+type BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications struct {
+ OpeningTag *BACnetOpeningTag
+ MonitoredObjectIdentifier *BACnetContextTagObjectIdentifier
+ InnerOpeningTag *BACnetOpeningTag
+ ListOfValues []*BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue
+ InnerClosingTag *BACnetClosingTag
+ ClosingTag *BACnetClosingTag
+
+ // Arguments.
+ TagNumber uint8
+}
+
+// IBACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications is the corresponding interface of BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications
+type IBACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications interface {
+ // GetOpeningTag returns OpeningTag (property field)
+ GetOpeningTag() *BACnetOpeningTag
+ // GetMonitoredObjectIdentifier returns MonitoredObjectIdentifier (property field)
+ GetMonitoredObjectIdentifier() *BACnetContextTagObjectIdentifier
+ // GetInnerOpeningTag returns InnerOpeningTag (property field)
+ GetInnerOpeningTag() *BACnetOpeningTag
+ // GetListOfValues returns ListOfValues (property field)
+ GetListOfValues() []*BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue
+ // GetInnerClosingTag returns InnerClosingTag (property field)
+ GetInnerClosingTag() *BACnetClosingTag
+ // GetClosingTag returns ClosingTag (property field)
+ GetClosingTag() *BACnetClosingTag
+ // 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 property fields.
+///////////////////////
+
+func (m *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications) GetOpeningTag() *BACnetOpeningTag {
+ return m.OpeningTag
+}
+
+func (m *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications) GetMonitoredObjectIdentifier() *BACnetContextTagObjectIdentifier {
+ return m.MonitoredObjectIdentifier
+}
+
+func (m *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications) GetInnerOpeningTag() *BACnetOpeningTag {
+ return m.InnerOpeningTag
+}
+
+func (m *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications) GetListOfValues() []*BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue {
+ return m.ListOfValues
+}
+
+func (m *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications) GetInnerClosingTag() *BACnetClosingTag {
+ return m.InnerClosingTag
+}
+
+func (m *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications) GetClosingTag() *BACnetClosingTag {
+ return m.ClosingTag
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications factory function for BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications
+func NewBACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications(openingTag *BACnetOpeningTag, monitoredObjectIdentifier *BACnetContextTagObjectIdentifier, innerOpeningTag *BACnetOpeningTag, listOfValues []*BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue, innerClosingTag *BACnetClosingTag, closingTag *BACnetClosingTag, tagNumber uint8) *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications {
+ return &BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications{OpeningTag: openingTag, MonitoredObjectIdentifier: monitoredObjectIdentifier, InnerOpeningTag: innerOpeningTag, ListOfValues: listOfValues, InnerClosingTag: innerClosingTag, ClosingTag: closingTag, TagNumber: tagNumber}
+}
+
+func CastBACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications(structType interface{}) *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications {
+ if casted, ok := structType.(BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications); ok {
+ return casted
+ }
+ return nil
+}
+
+func (m *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications) GetTypeName() string {
+ return "BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications"
+}
+
+func (m *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(0)
+
+ // Simple field (openingTag)
+ lengthInBits += m.OpeningTag.GetLengthInBits()
+
+ // Simple field (monitoredObjectIdentifier)
+ lengthInBits += m.MonitoredObjectIdentifier.GetLengthInBits()
+
+ // Simple field (innerOpeningTag)
+ lengthInBits += m.InnerOpeningTag.GetLengthInBits()
+
+ // Array field
+ if len(m.ListOfValues) > 0 {
+ for _, element := range m.ListOfValues {
+ lengthInBits += element.GetLengthInBits()
+ }
+ }
+
+ // Simple field (innerClosingTag)
+ lengthInBits += m.InnerClosingTag.GetLengthInBits()
+
+ // Simple field (closingTag)
+ lengthInBits += m.ClosingTag.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsParse(readBuffer utils.ReadBuffer, tagNumber uint8) (*BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications, error) {
+ if pullErr := readBuffer.PullContext("BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := readBuffer.GetPos()
+ _ = currentPos
+
+ // Simple Field (openingTag)
+ if pullErr := readBuffer.PullContext("openingTag"); pullErr != nil {
+ return nil, pullErr
+ }
+ _openingTag, _openingTagErr := BACnetContextTagParse(readBuffer, uint8(tagNumber), BACnetDataType(BACnetDataType_OPENING_TAG))
+ if _openingTagErr != nil {
+ return nil, errors.Wrap(_openingTagErr, "Error parsing 'openingTag' field")
+ }
+ openingTag := CastBACnetOpeningTag(_openingTag)
+ if closeErr := readBuffer.CloseContext("openingTag"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (monitoredObjectIdentifier)
+ if pullErr := readBuffer.PullContext("monitoredObjectIdentifier"); pullErr != nil {
+ return nil, pullErr
+ }
+ _monitoredObjectIdentifier, _monitoredObjectIdentifierErr := BACnetContextTagParse(readBuffer, uint8(uint8(0)), BACnetDataType(BACnetDataType_BACNET_OBJECT_IDENTIFIER))
+ if _monitoredObjectIdentifierErr != nil {
+ return nil, errors.Wrap(_monitoredObjectIdentifierErr, "Error parsing 'monitoredObjectIdentifier' field")
+ }
+ monitoredObjectIdentifier := CastBACnetContextTagObjectIdentifier(_monitoredObjectIdentifier)
+ if closeErr := readBuffer.CloseContext("monitoredObjectIdentifier"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (innerOpeningTag)
+ if pullErr := readBuffer.PullContext("innerOpeningTag"); pullErr != nil {
+ return nil, pullErr
+ }
+ _innerOpeningTag, _innerOpeningTagErr := BACnetContextTagParse(readBuffer, uint8(uint8(1)), BACnetDataType(BACnetDataType_OPENING_TAG))
+ if _innerOpeningTagErr != nil {
+ return nil, errors.Wrap(_innerOpeningTagErr, "Error parsing 'innerOpeningTag' field")
+ }
+ innerOpeningTag := CastBACnetOpeningTag(_innerOpeningTag)
+ if closeErr := readBuffer.CloseContext("innerOpeningTag"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Array field (listOfValues)
+ if pullErr := readBuffer.PullContext("listOfValues", utils.WithRenderAsList(true)); pullErr != nil {
+ return nil, pullErr
+ }
+ // Terminated array
+ listOfValues := make([]*BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue, 0)
+ {
+ for !bool(IsBACnetConstructedDataClosingTag(readBuffer, false, 1)) {
+ _item, _err := BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValueParse(readBuffer, monitoredObjectIdentifier.GetObjectType())
+ if _err != nil {
+ return nil, errors.Wrap(_err, "Error parsing 'listOfValues' field")
+ }
+ listOfValues = append(listOfValues, CastBACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue(_item))
+
+ }
+ }
+ if closeErr := readBuffer.CloseContext("listOfValues", utils.WithRenderAsList(true)); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (innerClosingTag)
+ if pullErr := readBuffer.PullContext("innerClosingTag"); pullErr != nil {
+ return nil, pullErr
+ }
+ _innerClosingTag, _innerClosingTagErr := BACnetContextTagParse(readBuffer, uint8(uint8(1)), BACnetDataType(BACnetDataType_CLOSING_TAG))
+ if _innerClosingTagErr != nil {
+ return nil, errors.Wrap(_innerClosingTagErr, "Error parsing 'innerClosingTag' field")
+ }
+ innerClosingTag := CastBACnetClosingTag(_innerClosingTag)
+ if closeErr := readBuffer.CloseContext("innerClosingTag"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (closingTag)
+ if pullErr := readBuffer.PullContext("closingTag"); pullErr != nil {
+ return nil, pullErr
+ }
+ _closingTag, _closingTagErr := BACnetContextTagParse(readBuffer, uint8(tagNumber), BACnetDataType(BACnetDataType_CLOSING_TAG))
+ if _closingTagErr != nil {
+ return nil, errors.Wrap(_closingTagErr, "Error parsing 'closingTag' field")
+ }
+ closingTag := CastBACnetClosingTag(_closingTag)
+ if closeErr := readBuffer.CloseContext("closingTag"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create the instance
+ return NewBACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications(openingTag, monitoredObjectIdentifier, innerOpeningTag, listOfValues, innerClosingTag, closingTag, tagNumber), nil
+}
+
+func (m *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications) Serialize(writeBuffer utils.WriteBuffer) error {
+ if pushErr := writeBuffer.PushContext("BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (openingTag)
+ if pushErr := writeBuffer.PushContext("openingTag"); pushErr != nil {
+ return pushErr
+ }
+ _openingTagErr := m.OpeningTag.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("openingTag"); popErr != nil {
+ return popErr
+ }
+ if _openingTagErr != nil {
+ return errors.Wrap(_openingTagErr, "Error serializing 'openingTag' field")
+ }
+
+ // Simple Field (monitoredObjectIdentifier)
+ if pushErr := writeBuffer.PushContext("monitoredObjectIdentifier"); pushErr != nil {
+ return pushErr
+ }
+ _monitoredObjectIdentifierErr := m.MonitoredObjectIdentifier.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("monitoredObjectIdentifier"); popErr != nil {
+ return popErr
+ }
+ if _monitoredObjectIdentifierErr != nil {
+ return errors.Wrap(_monitoredObjectIdentifierErr, "Error serializing 'monitoredObjectIdentifier' field")
+ }
+
+ // Simple Field (innerOpeningTag)
+ if pushErr := writeBuffer.PushContext("innerOpeningTag"); pushErr != nil {
+ return pushErr
+ }
+ _innerOpeningTagErr := m.InnerOpeningTag.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("innerOpeningTag"); popErr != nil {
+ return popErr
+ }
+ if _innerOpeningTagErr != nil {
+ return errors.Wrap(_innerOpeningTagErr, "Error serializing 'innerOpeningTag' field")
+ }
+
+ // Array Field (listOfValues)
+ if m.ListOfValues != nil {
+ if pushErr := writeBuffer.PushContext("listOfValues", utils.WithRenderAsList(true)); pushErr != nil {
+ return pushErr
+ }
+ for _, _element := range m.ListOfValues {
+ _elementErr := _element.Serialize(writeBuffer)
+ if _elementErr != nil {
+ return errors.Wrap(_elementErr, "Error serializing 'listOfValues' field")
+ }
+ }
+ if popErr := writeBuffer.PopContext("listOfValues", utils.WithRenderAsList(true)); popErr != nil {
+ return popErr
+ }
+ }
+
+ // Simple Field (innerClosingTag)
+ if pushErr := writeBuffer.PushContext("innerClosingTag"); pushErr != nil {
+ return pushErr
+ }
+ _innerClosingTagErr := m.InnerClosingTag.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("innerClosingTag"); popErr != nil {
+ return popErr
+ }
+ if _innerClosingTagErr != nil {
+ return errors.Wrap(_innerClosingTagErr, "Error serializing 'innerClosingTag' field")
+ }
+
+ // Simple Field (closingTag)
+ if pushErr := writeBuffer.PushContext("closingTag"); pushErr != nil {
+ return pushErr
+ }
+ _closingTagErr := m.ClosingTag.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("closingTag"); popErr != nil {
+ return popErr
+ }
+ if _closingTagErr != nil {
+ return errors.Wrap(_closingTagErr, "Error serializing 'closingTag' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications"); popErr != nil {
+ return popErr
+ }
+ return nil
+}
+
+func (m *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications) 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/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue.go
new file mode 100644
index 0000000000..afa157803d
--- /dev/null
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue.go
@@ -0,0 +1,293 @@
+/*
+ * 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/plc4go/spi/utils"
+ "github.com/pkg/errors"
+ "io"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue is the data-structure of this message
+type BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue struct {
+ PropertyIdentifier *BACnetContextTagPropertyIdentifier
+ ArrayIndex *BACnetContextTagUnsignedInteger
+ PropertyValue *BACnetConstructedData
+ TimeOfChange *BACnetContextTagTime
+
+ // Arguments.
+ ObjectType BACnetObjectType
+}
+
+// IBACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue is the corresponding interface of BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue
+type IBACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue interface {
+ // GetPropertyIdentifier returns PropertyIdentifier (property field)
+ GetPropertyIdentifier() *BACnetContextTagPropertyIdentifier
+ // GetArrayIndex returns ArrayIndex (property field)
+ GetArrayIndex() *BACnetContextTagUnsignedInteger
+ // GetPropertyValue returns PropertyValue (property field)
+ GetPropertyValue() *BACnetConstructedData
+ // GetTimeOfChange returns TimeOfChange (property field)
+ GetTimeOfChange() *BACnetContextTagTime
+ // 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 property fields.
+///////////////////////
+
+func (m *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue) GetPropertyIdentifier() *BACnetContextTagPropertyIdentifier {
+ return m.PropertyIdentifier
+}
+
+func (m *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue) GetArrayIndex() *BACnetContextTagUnsignedInteger {
+ return m.ArrayIndex
+}
+
+func (m *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue) GetPropertyValue() *BACnetConstructedData {
+ return m.PropertyValue
+}
+
+func (m *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue) GetTimeOfChange() *BACnetContextTagTime {
+ return m.TimeOfChange
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue factory function for BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue
+func NewBACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue(propertyIdentifier *BACnetContextTagPropertyIdentifier, arrayIndex *BACnetContextTagUnsignedInteger, propertyValue *BACnetConstructedData, timeOfChange *BACnetContextTagTime, objectType BACnetObjectType) *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue {
+ return &BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue{PropertyIdentifier: propertyIdentifier, ArrayIndex: arrayIndex, PropertyValue: propertyValue, TimeOfChange: timeOfChange, ObjectType: objectType}
+}
+
+func CastBACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue(structType interface{}) *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue {
+ if casted, ok := structType.(BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue); ok {
+ return casted
+ }
+ return nil
+}
+
+func (m *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue) GetTypeName() string {
+ return "BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue"
+}
+
+func (m *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(0)
+
+ // Simple field (propertyIdentifier)
+ lengthInBits += m.PropertyIdentifier.GetLengthInBits()
+
+ // Optional Field (arrayIndex)
+ if m.ArrayIndex != nil {
+ lengthInBits += (*m.ArrayIndex).GetLengthInBits()
+ }
+
+ // Simple field (propertyValue)
+ lengthInBits += m.PropertyValue.GetLengthInBits()
+
+ // Optional Field (timeOfChange)
+ if m.TimeOfChange != nil {
+ lengthInBits += (*m.TimeOfChange).GetLengthInBits()
+ }
+
+ return lengthInBits
+}
+
+func (m *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValueParse(readBuffer utils.ReadBuffer, objectType BACnetObjectType) (*BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue, error) {
+ if pullErr := readBuffer.PullContext("BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := readBuffer.GetPos()
+ _ = currentPos
+
+ // Simple Field (propertyIdentifier)
+ if pullErr := readBuffer.PullContext("propertyIdentifier"); pullErr != nil {
+ return nil, pullErr
+ }
+ _propertyIdentifier, _propertyIdentifierErr := BACnetContextTagParse(readBuffer, uint8(uint8(0)), BACnetDataType(BACnetDataType_BACNET_PROPERTY_IDENTIFIER))
+ if _propertyIdentifierErr != nil {
+ return nil, errors.Wrap(_propertyIdentifierErr, "Error parsing 'propertyIdentifier' field")
+ }
+ propertyIdentifier := CastBACnetContextTagPropertyIdentifier(_propertyIdentifier)
+ if closeErr := readBuffer.CloseContext("propertyIdentifier"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Optional Field (arrayIndex) (Can be skipped, if a given expression evaluates to false)
+ var arrayIndex *BACnetContextTagUnsignedInteger = nil
+ {
+ currentPos = readBuffer.GetPos()
+ if pullErr := readBuffer.PullContext("arrayIndex"); pullErr != nil {
+ return nil, pullErr
+ }
+ _val, _err := BACnetContextTagParse(readBuffer, uint8(1), BACnetDataType_UNSIGNED_INTEGER)
+ switch {
+ case errors.Is(_err, utils.ParseAssertError{}) || errors.Is(_err, io.EOF):
+ readBuffer.Reset(currentPos)
+ case _err != nil:
+ return nil, errors.Wrap(_err, "Error parsing 'arrayIndex' field")
+ default:
+ arrayIndex = CastBACnetContextTagUnsignedInteger(_val)
+ if closeErr := readBuffer.CloseContext("arrayIndex"); closeErr != nil {
+ return nil, closeErr
+ }
+ }
+ }
+
+ // Simple Field (propertyValue)
+ if pullErr := readBuffer.PullContext("propertyValue"); pullErr != nil {
+ return nil, pullErr
+ }
+ _propertyValue, _propertyValueErr := BACnetConstructedDataParse(readBuffer, uint8(uint8(2)), BACnetObjectType(objectType), propertyIdentifier)
+ if _propertyValueErr != nil {
+ return nil, errors.Wrap(_propertyValueErr, "Error parsing 'propertyValue' field")
+ }
+ propertyValue := CastBACnetConstructedData(_propertyValue)
+ if closeErr := readBuffer.CloseContext("propertyValue"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Optional Field (timeOfChange) (Can be skipped, if a given expression evaluates to false)
+ var timeOfChange *BACnetContextTagTime = nil
+ {
+ currentPos = readBuffer.GetPos()
+ if pullErr := readBuffer.PullContext("timeOfChange"); pullErr != nil {
+ return nil, pullErr
+ }
+ _val, _err := BACnetContextTagParse(readBuffer, uint8(3), BACnetDataType_TIME)
+ switch {
+ case errors.Is(_err, utils.ParseAssertError{}) || errors.Is(_err, io.EOF):
+ readBuffer.Reset(currentPos)
+ case _err != nil:
+ return nil, errors.Wrap(_err, "Error parsing 'timeOfChange' field")
+ default:
+ timeOfChange = CastBACnetContextTagTime(_val)
+ if closeErr := readBuffer.CloseContext("timeOfChange"); closeErr != nil {
+ return nil, closeErr
+ }
+ }
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create the instance
+ return NewBACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue(propertyIdentifier, arrayIndex, propertyValue, timeOfChange, objectType), nil
+}
+
+func (m *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue) Serialize(writeBuffer utils.WriteBuffer) error {
+ if pushErr := writeBuffer.PushContext("BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (propertyIdentifier)
+ if pushErr := writeBuffer.PushContext("propertyIdentifier"); pushErr != nil {
+ return pushErr
+ }
+ _propertyIdentifierErr := m.PropertyIdentifier.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("propertyIdentifier"); popErr != nil {
+ return popErr
+ }
+ if _propertyIdentifierErr != nil {
+ return errors.Wrap(_propertyIdentifierErr, "Error serializing 'propertyIdentifier' field")
+ }
+
+ // Optional Field (arrayIndex) (Can be skipped, if the value is null)
+ var arrayIndex *BACnetContextTagUnsignedInteger = nil
+ if m.ArrayIndex != nil {
+ if pushErr := writeBuffer.PushContext("arrayIndex"); pushErr != nil {
+ return pushErr
+ }
+ arrayIndex = m.ArrayIndex
+ _arrayIndexErr := arrayIndex.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("arrayIndex"); popErr != nil {
+ return popErr
+ }
+ if _arrayIndexErr != nil {
+ return errors.Wrap(_arrayIndexErr, "Error serializing 'arrayIndex' field")
+ }
+ }
+
+ // Simple Field (propertyValue)
+ if pushErr := writeBuffer.PushContext("propertyValue"); pushErr != nil {
+ return pushErr
+ }
+ _propertyValueErr := m.PropertyValue.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("propertyValue"); popErr != nil {
+ return popErr
+ }
+ if _propertyValueErr != nil {
+ return errors.Wrap(_propertyValueErr, "Error serializing 'propertyValue' field")
+ }
+
+ // Optional Field (timeOfChange) (Can be skipped, if the value is null)
+ var timeOfChange *BACnetContextTagTime = nil
+ if m.TimeOfChange != nil {
+ if pushErr := writeBuffer.PushContext("timeOfChange"); pushErr != nil {
+ return pushErr
+ }
+ timeOfChange = m.TimeOfChange
+ _timeOfChangeErr := timeOfChange.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("timeOfChange"); popErr != nil {
+ return popErr
+ }
+ if _timeOfChangeErr != nil {
+ return errors.Wrap(_timeOfChangeErr, "Error serializing 'timeOfChange' field")
+ }
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue"); popErr != nil {
+ return popErr
+ }
+ return nil
+}
+
+func (m *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue) 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 81aad98d99..f7adb8e490 100644
--- a/protocols/bacnetip/src/main/resources/protocols/bacnetip/bacnetip.mspec
+++ b/protocols/bacnetip/src/main/resources/protocols/bacnetip/bacnetip.mspec
@@ -322,7 +322,12 @@
[simple BACnetPropertyValues('4', 'monitoredObjectIdentifier.objectType') listOfValues ]
]
['CONFIRMED_COV_NOTIFICATION_MULTIPLE' BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple
- // TODO: implement me
+ [simple BACnetContextTagUnsignedInteger('0', 'BACnetDataType.UNSIGNED_INTEGER') subscriberProcessIdentifier ]
+ [simple BACnetContextTagObjectIdentifier('1', 'BACnetDataType.BACNET_OBJECT_IDENTIFIER') initiatingDeviceIdentifier ]
+ [simple BACnetContextTagUnsignedInteger('2', 'BACnetDataType.UNSIGNED_INTEGER') timeRemaining ]
+ [optional BACnetTimeStamp('3') timestamp ]
+ [simple BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications('4')
+ listOfCovNotifications ]
]
['CONFIRMED_EVENT_NOTIFICATION' BACnetConfirmedServiceRequestConfirmedEventNotification // Spec complete
[simple BACnetContextTagUnsignedInteger('0', 'BACnetDataType.UNSIGNED_INTEGER') processIdentifier ]
@@ -557,6 +562,34 @@
////
]
+[type BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotifications(uint 8 tagNumber)
+ [simple BACnetOpeningTag('tagNumber', 'BACnetDataType.OPENING_TAG')
+ openingTag ]
+ [simple BACnetContextTagObjectIdentifier('0', 'BACnetDataType.BACNET_OBJECT_IDENTIFIER') monitoredObjectIdentifier ]
+ [simple BACnetOpeningTag('1', 'BACnetDataType.OPENING_TAG')
+ innerOpeningTag ]
+ [array BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue('monitoredObjectIdentifier.objectType')
+ listOfValues
+ terminated
+ 'STATIC_CALL("isBACnetConstructedDataClosingTag", readBuffer, false, 1)'
+ ]
+ [simple BACnetClosingTag('1', 'BACnetDataType.CLOSING_TAG')
+ innerClosingTag ]
+ [simple BACnetClosingTag('tagNumber', 'BACnetDataType.CLOSING_TAG')
+ closingTag ]
+]
+
+[type BACnetConfirmedServiceRequestConfirmedCOVNotificationMultipleListOfCovNotificationsValue(BACnetObjectType objectType)
+ [simple BACnetContextTagPropertyIdentifier('0', 'BACnetDataType.BACNET_PROPERTY_IDENTIFIER')
+ propertyIdentifier ]
+ [optional BACnetContextTagUnsignedInteger('1', 'BACnetDataType.UNSIGNED_INTEGER')
+ arrayIndex ]
+ [simple BACnetConstructedData('2', 'objectType', 'propertyIdentifier')
+ propertyValue ]
+ [optional BACnetContextTagTime('3', 'BACnetDataType.TIME')
+ timeOfChange ]
+]
+
[type BACnetReadAccessSpecification
[simple BACnetContextTagObjectIdentifier('0', 'BACnetDataType.BACNET_OBJECT_IDENTIFIER')
objectIdentifier ]