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/31 08:25:12 UTC
[plc4x] branch develop updated: feat(bacnet): implemented BACnetPriorityArray
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 53381f1c90 feat(bacnet): implemented BACnetPriorityArray
53381f1c90 is described below
commit 53381f1c90d9b8a0f4625085590dea4b9fedd9a4
Author: Sebastian Rühl <sr...@apache.org>
AuthorDate: Tue May 31 10:25:05 2022 +0200
feat(bacnet): implemented BACnetPriorityArray
---
.../protocols/bacnetip/readwrite/ParserHelper.go | 6 +
.../bacnetip/readwrite/XmlParserHelper.go | 6 +
.../readwrite/model/BACnetConstructedData.go | 2 +
.../model/BACnetConstructedDataPriorityArray.go | 211 +++++++
.../readwrite/model/BACnetPriorityArray.go | 688 +++++++++++++++++++++
.../readwrite/model/BACnetPriorityValue.go | 264 ++++++++
.../model/BACnetPriorityValueBitString.go | 202 ++++++
.../readwrite/model/BACnetPriorityValueBoolean.go | 202 ++++++
.../model/BACnetPriorityValueCharacterString.go | 202 ++++++
.../model/BACnetPriorityValueConstructedValue.go | 202 ++++++
.../readwrite/model/BACnetPriorityValueDate.go | 202 ++++++
.../readwrite/model/BACnetPriorityValueDateTime.go | 202 ++++++
.../readwrite/model/BACnetPriorityValueDouble.go | 202 ++++++
.../model/BACnetPriorityValueEnumerated.go | 202 ++++++
.../readwrite/model/BACnetPriorityValueInteger.go | 202 ++++++
.../readwrite/model/BACnetPriorityValueNull.go | 202 ++++++
.../model/BACnetPriorityValueObjectidentifier.go | 202 ++++++
.../model/BACnetPriorityValueOctetString.go | 202 ++++++
.../readwrite/model/BACnetPriorityValueReal.go | 202 ++++++
.../readwrite/model/BACnetPriorityValueTime.go | 202 ++++++
.../readwrite/model/BACnetPriorityValueUnsigned.go | 202 ++++++
.../plc4x/java/bacnetip/RandomPackagesTest.java | 21 +-
.../resources/protocols/bacnetip/bacnetip.mspec | 102 ++-
23 files changed, 4320 insertions(+), 10 deletions(-)
diff --git a/plc4go/protocols/bacnetip/readwrite/ParserHelper.go b/plc4go/protocols/bacnetip/readwrite/ParserHelper.go
index 59a62dd4fa..b49829d510 100644
--- a/plc4go/protocols/bacnetip/readwrite/ParserHelper.go
+++ b/plc4go/protocols/bacnetip/readwrite/ParserHelper.go
@@ -59,6 +59,9 @@ func (m BacnetipParserHelper) Parse(typeName string, arguments []string, io util
return nil, errors.Wrap(err, "Error parsing")
}
return model.BACnetOpeningTagParse(io, tagNumberArgument)
+ case "BACnetPriorityArray":
+ objectType := model.BACnetObjectTypeByName(arguments[0])
+ return model.BACnetPriorityArrayParse(io, objectType)
case "BACnetAuthorizationExemptionTagged":
tagNumber, err := utils.StrToUint8(arguments[0])
if err != nil {
@@ -552,6 +555,9 @@ func (m BacnetipParserHelper) Parse(typeName string, arguments []string, io util
return nil, errors.Wrap(err, "Error parsing")
}
return model.BACnetStatusFlagsParse(io, tagNumber)
+ case "BACnetPriorityValue":
+ objectType := model.BACnetObjectTypeByName(arguments[0])
+ return model.BACnetPriorityValueParse(io, objectType)
case "BACnetMaintenanceTagged":
tagNumber, err := utils.StrToUint8(arguments[0])
if err != nil {
diff --git a/plc4go/protocols/bacnetip/readwrite/XmlParserHelper.go b/plc4go/protocols/bacnetip/readwrite/XmlParserHelper.go
index e4303572ce..b79c15a4a0 100644
--- a/plc4go/protocols/bacnetip/readwrite/XmlParserHelper.go
+++ b/plc4go/protocols/bacnetip/readwrite/XmlParserHelper.go
@@ -73,6 +73,9 @@ func (m BacnetipXmlParserHelper) Parse(typeName string, xmlString string, parser
}
tagNumberArgument := uint8(parsedUint0)
return model.BACnetOpeningTagParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)), tagNumberArgument)
+ case "BACnetPriorityArray":
+ objectType := model.BACnetObjectTypeByName(parserArguments[0])
+ return model.BACnetPriorityArrayParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)), objectType)
case "BACnetAuthorizationExemptionTagged":
parsedUint0, err := strconv.ParseUint(parserArguments[0], 10, 8)
if err != nil {
@@ -635,6 +638,9 @@ func (m BacnetipXmlParserHelper) Parse(typeName string, xmlString string, parser
}
tagNumber := uint8(parsedUint0)
return model.BACnetStatusFlagsParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)), tagNumber)
+ case "BACnetPriorityValue":
+ objectType := model.BACnetObjectTypeByName(parserArguments[0])
+ return model.BACnetPriorityValueParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)), objectType)
case "BACnetMaintenanceTagged":
parsedUint0, err := strconv.ParseUint(parserArguments[0], 10, 8)
if err != nil {
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedData.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedData.go
index 9f00d7b53f..3a213c728a 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedData.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedData.go
@@ -314,6 +314,8 @@ func BACnetConstructedDataParse(readBuffer utils.ReadBuffer, tagNumber uint8, ob
_child, typeSwitchError = BACnetConstructedDataOutOfServiceParse(readBuffer, tagNumber, objectType, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_OUTPUT_UNITS: // BACnetConstructedDataOutputUnits
_child, typeSwitchError = BACnetConstructedDataOutputUnitsParse(readBuffer, tagNumber, objectType, propertyIdentifierArgument)
+ case true && propertyIdentifierArgument == BACnetPropertyIdentifier_PRIORITY_ARRAY: // BACnetConstructedDataPriorityArray
+ _child, typeSwitchError = BACnetConstructedDataPriorityArrayParse(readBuffer, tagNumber, objectType, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_PROPORTIONAL_CONSTANT_UNITS: // BACnetConstructedDataProportionalConstantUnits
_child, typeSwitchError = BACnetConstructedDataProportionalConstantUnitsParse(readBuffer, tagNumber, objectType, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_RELIABILITY: // BACnetConstructedDataReliability
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataPriorityArray.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataPriorityArray.go
new file mode 100644
index 0000000000..eb06dce6e9
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataPriorityArray.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.
+
+// BACnetConstructedDataPriorityArray is the data-structure of this message
+type BACnetConstructedDataPriorityArray struct {
+ *BACnetConstructedData
+ PriorityArray *BACnetPriorityArray
+
+ // Arguments.
+ TagNumber uint8
+}
+
+// IBACnetConstructedDataPriorityArray is the corresponding interface of BACnetConstructedDataPriorityArray
+type IBACnetConstructedDataPriorityArray interface {
+ IBACnetConstructedData
+ // GetPriorityArray returns PriorityArray (property field)
+ GetPriorityArray() *BACnetPriorityArray
+ // 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 *BACnetConstructedDataPriorityArray) GetObjectType() BACnetObjectType {
+ return 0
+}
+
+func (m *BACnetConstructedDataPriorityArray) GetPropertyIdentifierArgument() BACnetPropertyIdentifier {
+ return BACnetPropertyIdentifier_PRIORITY_ARRAY
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+func (m *BACnetConstructedDataPriorityArray) InitializeParent(parent *BACnetConstructedData, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag) {
+ m.BACnetConstructedData.OpeningTag = openingTag
+ m.BACnetConstructedData.ClosingTag = closingTag
+}
+
+func (m *BACnetConstructedDataPriorityArray) GetParent() *BACnetConstructedData {
+ return m.BACnetConstructedData
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetConstructedDataPriorityArray) GetPriorityArray() *BACnetPriorityArray {
+ return m.PriorityArray
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetConstructedDataPriorityArray factory function for BACnetConstructedDataPriorityArray
+func NewBACnetConstructedDataPriorityArray(priorityArray *BACnetPriorityArray, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag, tagNumber uint8) *BACnetConstructedDataPriorityArray {
+ _result := &BACnetConstructedDataPriorityArray{
+ PriorityArray: priorityArray,
+ BACnetConstructedData: NewBACnetConstructedData(openingTag, closingTag, tagNumber),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetConstructedDataPriorityArray(structType interface{}) *BACnetConstructedDataPriorityArray {
+ if casted, ok := structType.(BACnetConstructedDataPriorityArray); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConstructedDataPriorityArray); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConstructedData); ok {
+ return CastBACnetConstructedDataPriorityArray(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConstructedData); ok {
+ return CastBACnetConstructedDataPriorityArray(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetConstructedDataPriorityArray) GetTypeName() string {
+ return "BACnetConstructedDataPriorityArray"
+}
+
+func (m *BACnetConstructedDataPriorityArray) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetConstructedDataPriorityArray) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (priorityArray)
+ lengthInBits += m.PriorityArray.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetConstructedDataPriorityArray) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetConstructedDataPriorityArrayParse(readBuffer utils.ReadBuffer, tagNumber uint8, objectType BACnetObjectType, propertyIdentifierArgument BACnetPropertyIdentifier) (*BACnetConstructedDataPriorityArray, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetConstructedDataPriorityArray"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (priorityArray)
+ if pullErr := readBuffer.PullContext("priorityArray"); pullErr != nil {
+ return nil, pullErr
+ }
+ _priorityArray, _priorityArrayErr := BACnetPriorityArrayParse(readBuffer, BACnetObjectType(objectType))
+ if _priorityArrayErr != nil {
+ return nil, errors.Wrap(_priorityArrayErr, "Error parsing 'priorityArray' field")
+ }
+ priorityArray := CastBACnetPriorityArray(_priorityArray)
+ if closeErr := readBuffer.CloseContext("priorityArray"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetConstructedDataPriorityArray"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetConstructedDataPriorityArray{
+ PriorityArray: CastBACnetPriorityArray(priorityArray),
+ BACnetConstructedData: &BACnetConstructedData{},
+ }
+ _child.BACnetConstructedData.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetConstructedDataPriorityArray) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetConstructedDataPriorityArray"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (priorityArray)
+ if pushErr := writeBuffer.PushContext("priorityArray"); pushErr != nil {
+ return pushErr
+ }
+ _priorityArrayErr := m.PriorityArray.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("priorityArray"); popErr != nil {
+ return popErr
+ }
+ if _priorityArrayErr != nil {
+ return errors.Wrap(_priorityArrayErr, "Error serializing 'priorityArray' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetConstructedDataPriorityArray"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetConstructedDataPriorityArray) 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/BACnetPriorityArray.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityArray.go
new file mode 100644
index 0000000000..17e5410200
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityArray.go
@@ -0,0 +1,688 @@
+/*
+ * 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.
+
+// BACnetPriorityArray is the data-structure of this message
+type BACnetPriorityArray struct {
+ PriorityValue01 *BACnetPriorityValue
+ PriorityValue02 *BACnetPriorityValue
+ PriorityValue03 *BACnetPriorityValue
+ PriorityValue04 *BACnetPriorityValue
+ PriorityValue05 *BACnetPriorityValue
+ PriorityValue06 *BACnetPriorityValue
+ PriorityValue07 *BACnetPriorityValue
+ PriorityValue08 *BACnetPriorityValue
+ PriorityValue09 *BACnetPriorityValue
+ PriorityValue10 *BACnetPriorityValue
+ PriorityValue11 *BACnetPriorityValue
+ PriorityValue12 *BACnetPriorityValue
+ PriorityValue13 *BACnetPriorityValue
+ PriorityValue14 *BACnetPriorityValue
+ PriorityValue15 *BACnetPriorityValue
+ PriorityValue16 *BACnetPriorityValue
+
+ // Arguments.
+ ObjectType BACnetObjectType
+}
+
+// IBACnetPriorityArray is the corresponding interface of BACnetPriorityArray
+type IBACnetPriorityArray interface {
+ // GetPriorityValue01 returns PriorityValue01 (property field)
+ GetPriorityValue01() *BACnetPriorityValue
+ // GetPriorityValue02 returns PriorityValue02 (property field)
+ GetPriorityValue02() *BACnetPriorityValue
+ // GetPriorityValue03 returns PriorityValue03 (property field)
+ GetPriorityValue03() *BACnetPriorityValue
+ // GetPriorityValue04 returns PriorityValue04 (property field)
+ GetPriorityValue04() *BACnetPriorityValue
+ // GetPriorityValue05 returns PriorityValue05 (property field)
+ GetPriorityValue05() *BACnetPriorityValue
+ // GetPriorityValue06 returns PriorityValue06 (property field)
+ GetPriorityValue06() *BACnetPriorityValue
+ // GetPriorityValue07 returns PriorityValue07 (property field)
+ GetPriorityValue07() *BACnetPriorityValue
+ // GetPriorityValue08 returns PriorityValue08 (property field)
+ GetPriorityValue08() *BACnetPriorityValue
+ // GetPriorityValue09 returns PriorityValue09 (property field)
+ GetPriorityValue09() *BACnetPriorityValue
+ // GetPriorityValue10 returns PriorityValue10 (property field)
+ GetPriorityValue10() *BACnetPriorityValue
+ // GetPriorityValue11 returns PriorityValue11 (property field)
+ GetPriorityValue11() *BACnetPriorityValue
+ // GetPriorityValue12 returns PriorityValue12 (property field)
+ GetPriorityValue12() *BACnetPriorityValue
+ // GetPriorityValue13 returns PriorityValue13 (property field)
+ GetPriorityValue13() *BACnetPriorityValue
+ // GetPriorityValue14 returns PriorityValue14 (property field)
+ GetPriorityValue14() *BACnetPriorityValue
+ // GetPriorityValue15 returns PriorityValue15 (property field)
+ GetPriorityValue15() *BACnetPriorityValue
+ // GetPriorityValue16 returns PriorityValue16 (property field)
+ GetPriorityValue16() *BACnetPriorityValue
+ // 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 *BACnetPriorityArray) GetPriorityValue01() *BACnetPriorityValue {
+ return m.PriorityValue01
+}
+
+func (m *BACnetPriorityArray) GetPriorityValue02() *BACnetPriorityValue {
+ return m.PriorityValue02
+}
+
+func (m *BACnetPriorityArray) GetPriorityValue03() *BACnetPriorityValue {
+ return m.PriorityValue03
+}
+
+func (m *BACnetPriorityArray) GetPriorityValue04() *BACnetPriorityValue {
+ return m.PriorityValue04
+}
+
+func (m *BACnetPriorityArray) GetPriorityValue05() *BACnetPriorityValue {
+ return m.PriorityValue05
+}
+
+func (m *BACnetPriorityArray) GetPriorityValue06() *BACnetPriorityValue {
+ return m.PriorityValue06
+}
+
+func (m *BACnetPriorityArray) GetPriorityValue07() *BACnetPriorityValue {
+ return m.PriorityValue07
+}
+
+func (m *BACnetPriorityArray) GetPriorityValue08() *BACnetPriorityValue {
+ return m.PriorityValue08
+}
+
+func (m *BACnetPriorityArray) GetPriorityValue09() *BACnetPriorityValue {
+ return m.PriorityValue09
+}
+
+func (m *BACnetPriorityArray) GetPriorityValue10() *BACnetPriorityValue {
+ return m.PriorityValue10
+}
+
+func (m *BACnetPriorityArray) GetPriorityValue11() *BACnetPriorityValue {
+ return m.PriorityValue11
+}
+
+func (m *BACnetPriorityArray) GetPriorityValue12() *BACnetPriorityValue {
+ return m.PriorityValue12
+}
+
+func (m *BACnetPriorityArray) GetPriorityValue13() *BACnetPriorityValue {
+ return m.PriorityValue13
+}
+
+func (m *BACnetPriorityArray) GetPriorityValue14() *BACnetPriorityValue {
+ return m.PriorityValue14
+}
+
+func (m *BACnetPriorityArray) GetPriorityValue15() *BACnetPriorityValue {
+ return m.PriorityValue15
+}
+
+func (m *BACnetPriorityArray) GetPriorityValue16() *BACnetPriorityValue {
+ return m.PriorityValue16
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetPriorityArray factory function for BACnetPriorityArray
+func NewBACnetPriorityArray(priorityValue01 *BACnetPriorityValue, priorityValue02 *BACnetPriorityValue, priorityValue03 *BACnetPriorityValue, priorityValue04 *BACnetPriorityValue, priorityValue05 *BACnetPriorityValue, priorityValue06 *BACnetPriorityValue, priorityValue07 *BACnetPriorityValue, priorityValue08 *BACnetPriorityValue, priorityValue09 *BACnetPriorityValue, priorityValue10 *BACnetPriorityValue, priorityValue11 *BACnetPriorityValue, priorityValue12 *BACnetPriorityValue, priority [...]
+ return &BACnetPriorityArray{PriorityValue01: priorityValue01, PriorityValue02: priorityValue02, PriorityValue03: priorityValue03, PriorityValue04: priorityValue04, PriorityValue05: priorityValue05, PriorityValue06: priorityValue06, PriorityValue07: priorityValue07, PriorityValue08: priorityValue08, PriorityValue09: priorityValue09, PriorityValue10: priorityValue10, PriorityValue11: priorityValue11, PriorityValue12: priorityValue12, PriorityValue13: priorityValue13, PriorityValue14: prio [...]
+}
+
+func CastBACnetPriorityArray(structType interface{}) *BACnetPriorityArray {
+ if casted, ok := structType.(BACnetPriorityArray); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetPriorityArray); ok {
+ return casted
+ }
+ return nil
+}
+
+func (m *BACnetPriorityArray) GetTypeName() string {
+ return "BACnetPriorityArray"
+}
+
+func (m *BACnetPriorityArray) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetPriorityArray) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(0)
+
+ // Simple field (priorityValue01)
+ lengthInBits += m.PriorityValue01.GetLengthInBits()
+
+ // Simple field (priorityValue02)
+ lengthInBits += m.PriorityValue02.GetLengthInBits()
+
+ // Simple field (priorityValue03)
+ lengthInBits += m.PriorityValue03.GetLengthInBits()
+
+ // Simple field (priorityValue04)
+ lengthInBits += m.PriorityValue04.GetLengthInBits()
+
+ // Simple field (priorityValue05)
+ lengthInBits += m.PriorityValue05.GetLengthInBits()
+
+ // Simple field (priorityValue06)
+ lengthInBits += m.PriorityValue06.GetLengthInBits()
+
+ // Simple field (priorityValue07)
+ lengthInBits += m.PriorityValue07.GetLengthInBits()
+
+ // Simple field (priorityValue08)
+ lengthInBits += m.PriorityValue08.GetLengthInBits()
+
+ // Simple field (priorityValue09)
+ lengthInBits += m.PriorityValue09.GetLengthInBits()
+
+ // Simple field (priorityValue10)
+ lengthInBits += m.PriorityValue10.GetLengthInBits()
+
+ // Simple field (priorityValue11)
+ lengthInBits += m.PriorityValue11.GetLengthInBits()
+
+ // Simple field (priorityValue12)
+ lengthInBits += m.PriorityValue12.GetLengthInBits()
+
+ // Simple field (priorityValue13)
+ lengthInBits += m.PriorityValue13.GetLengthInBits()
+
+ // Simple field (priorityValue14)
+ lengthInBits += m.PriorityValue14.GetLengthInBits()
+
+ // Simple field (priorityValue15)
+ lengthInBits += m.PriorityValue15.GetLengthInBits()
+
+ // Simple field (priorityValue16)
+ lengthInBits += m.PriorityValue16.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetPriorityArray) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetPriorityArrayParse(readBuffer utils.ReadBuffer, objectType BACnetObjectType) (*BACnetPriorityArray, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetPriorityArray"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (priorityValue01)
+ if pullErr := readBuffer.PullContext("priorityValue01"); pullErr != nil {
+ return nil, pullErr
+ }
+ _priorityValue01, _priorityValue01Err := BACnetPriorityValueParse(readBuffer, BACnetObjectType(objectType))
+ if _priorityValue01Err != nil {
+ return nil, errors.Wrap(_priorityValue01Err, "Error parsing 'priorityValue01' field")
+ }
+ priorityValue01 := CastBACnetPriorityValue(_priorityValue01)
+ if closeErr := readBuffer.CloseContext("priorityValue01"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (priorityValue02)
+ if pullErr := readBuffer.PullContext("priorityValue02"); pullErr != nil {
+ return nil, pullErr
+ }
+ _priorityValue02, _priorityValue02Err := BACnetPriorityValueParse(readBuffer, BACnetObjectType(objectType))
+ if _priorityValue02Err != nil {
+ return nil, errors.Wrap(_priorityValue02Err, "Error parsing 'priorityValue02' field")
+ }
+ priorityValue02 := CastBACnetPriorityValue(_priorityValue02)
+ if closeErr := readBuffer.CloseContext("priorityValue02"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (priorityValue03)
+ if pullErr := readBuffer.PullContext("priorityValue03"); pullErr != nil {
+ return nil, pullErr
+ }
+ _priorityValue03, _priorityValue03Err := BACnetPriorityValueParse(readBuffer, BACnetObjectType(objectType))
+ if _priorityValue03Err != nil {
+ return nil, errors.Wrap(_priorityValue03Err, "Error parsing 'priorityValue03' field")
+ }
+ priorityValue03 := CastBACnetPriorityValue(_priorityValue03)
+ if closeErr := readBuffer.CloseContext("priorityValue03"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (priorityValue04)
+ if pullErr := readBuffer.PullContext("priorityValue04"); pullErr != nil {
+ return nil, pullErr
+ }
+ _priorityValue04, _priorityValue04Err := BACnetPriorityValueParse(readBuffer, BACnetObjectType(objectType))
+ if _priorityValue04Err != nil {
+ return nil, errors.Wrap(_priorityValue04Err, "Error parsing 'priorityValue04' field")
+ }
+ priorityValue04 := CastBACnetPriorityValue(_priorityValue04)
+ if closeErr := readBuffer.CloseContext("priorityValue04"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (priorityValue05)
+ if pullErr := readBuffer.PullContext("priorityValue05"); pullErr != nil {
+ return nil, pullErr
+ }
+ _priorityValue05, _priorityValue05Err := BACnetPriorityValueParse(readBuffer, BACnetObjectType(objectType))
+ if _priorityValue05Err != nil {
+ return nil, errors.Wrap(_priorityValue05Err, "Error parsing 'priorityValue05' field")
+ }
+ priorityValue05 := CastBACnetPriorityValue(_priorityValue05)
+ if closeErr := readBuffer.CloseContext("priorityValue05"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (priorityValue06)
+ if pullErr := readBuffer.PullContext("priorityValue06"); pullErr != nil {
+ return nil, pullErr
+ }
+ _priorityValue06, _priorityValue06Err := BACnetPriorityValueParse(readBuffer, BACnetObjectType(objectType))
+ if _priorityValue06Err != nil {
+ return nil, errors.Wrap(_priorityValue06Err, "Error parsing 'priorityValue06' field")
+ }
+ priorityValue06 := CastBACnetPriorityValue(_priorityValue06)
+ if closeErr := readBuffer.CloseContext("priorityValue06"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (priorityValue07)
+ if pullErr := readBuffer.PullContext("priorityValue07"); pullErr != nil {
+ return nil, pullErr
+ }
+ _priorityValue07, _priorityValue07Err := BACnetPriorityValueParse(readBuffer, BACnetObjectType(objectType))
+ if _priorityValue07Err != nil {
+ return nil, errors.Wrap(_priorityValue07Err, "Error parsing 'priorityValue07' field")
+ }
+ priorityValue07 := CastBACnetPriorityValue(_priorityValue07)
+ if closeErr := readBuffer.CloseContext("priorityValue07"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (priorityValue08)
+ if pullErr := readBuffer.PullContext("priorityValue08"); pullErr != nil {
+ return nil, pullErr
+ }
+ _priorityValue08, _priorityValue08Err := BACnetPriorityValueParse(readBuffer, BACnetObjectType(objectType))
+ if _priorityValue08Err != nil {
+ return nil, errors.Wrap(_priorityValue08Err, "Error parsing 'priorityValue08' field")
+ }
+ priorityValue08 := CastBACnetPriorityValue(_priorityValue08)
+ if closeErr := readBuffer.CloseContext("priorityValue08"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (priorityValue09)
+ if pullErr := readBuffer.PullContext("priorityValue09"); pullErr != nil {
+ return nil, pullErr
+ }
+ _priorityValue09, _priorityValue09Err := BACnetPriorityValueParse(readBuffer, BACnetObjectType(objectType))
+ if _priorityValue09Err != nil {
+ return nil, errors.Wrap(_priorityValue09Err, "Error parsing 'priorityValue09' field")
+ }
+ priorityValue09 := CastBACnetPriorityValue(_priorityValue09)
+ if closeErr := readBuffer.CloseContext("priorityValue09"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (priorityValue10)
+ if pullErr := readBuffer.PullContext("priorityValue10"); pullErr != nil {
+ return nil, pullErr
+ }
+ _priorityValue10, _priorityValue10Err := BACnetPriorityValueParse(readBuffer, BACnetObjectType(objectType))
+ if _priorityValue10Err != nil {
+ return nil, errors.Wrap(_priorityValue10Err, "Error parsing 'priorityValue10' field")
+ }
+ priorityValue10 := CastBACnetPriorityValue(_priorityValue10)
+ if closeErr := readBuffer.CloseContext("priorityValue10"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (priorityValue11)
+ if pullErr := readBuffer.PullContext("priorityValue11"); pullErr != nil {
+ return nil, pullErr
+ }
+ _priorityValue11, _priorityValue11Err := BACnetPriorityValueParse(readBuffer, BACnetObjectType(objectType))
+ if _priorityValue11Err != nil {
+ return nil, errors.Wrap(_priorityValue11Err, "Error parsing 'priorityValue11' field")
+ }
+ priorityValue11 := CastBACnetPriorityValue(_priorityValue11)
+ if closeErr := readBuffer.CloseContext("priorityValue11"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (priorityValue12)
+ if pullErr := readBuffer.PullContext("priorityValue12"); pullErr != nil {
+ return nil, pullErr
+ }
+ _priorityValue12, _priorityValue12Err := BACnetPriorityValueParse(readBuffer, BACnetObjectType(objectType))
+ if _priorityValue12Err != nil {
+ return nil, errors.Wrap(_priorityValue12Err, "Error parsing 'priorityValue12' field")
+ }
+ priorityValue12 := CastBACnetPriorityValue(_priorityValue12)
+ if closeErr := readBuffer.CloseContext("priorityValue12"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (priorityValue13)
+ if pullErr := readBuffer.PullContext("priorityValue13"); pullErr != nil {
+ return nil, pullErr
+ }
+ _priorityValue13, _priorityValue13Err := BACnetPriorityValueParse(readBuffer, BACnetObjectType(objectType))
+ if _priorityValue13Err != nil {
+ return nil, errors.Wrap(_priorityValue13Err, "Error parsing 'priorityValue13' field")
+ }
+ priorityValue13 := CastBACnetPriorityValue(_priorityValue13)
+ if closeErr := readBuffer.CloseContext("priorityValue13"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (priorityValue14)
+ if pullErr := readBuffer.PullContext("priorityValue14"); pullErr != nil {
+ return nil, pullErr
+ }
+ _priorityValue14, _priorityValue14Err := BACnetPriorityValueParse(readBuffer, BACnetObjectType(objectType))
+ if _priorityValue14Err != nil {
+ return nil, errors.Wrap(_priorityValue14Err, "Error parsing 'priorityValue14' field")
+ }
+ priorityValue14 := CastBACnetPriorityValue(_priorityValue14)
+ if closeErr := readBuffer.CloseContext("priorityValue14"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (priorityValue15)
+ if pullErr := readBuffer.PullContext("priorityValue15"); pullErr != nil {
+ return nil, pullErr
+ }
+ _priorityValue15, _priorityValue15Err := BACnetPriorityValueParse(readBuffer, BACnetObjectType(objectType))
+ if _priorityValue15Err != nil {
+ return nil, errors.Wrap(_priorityValue15Err, "Error parsing 'priorityValue15' field")
+ }
+ priorityValue15 := CastBACnetPriorityValue(_priorityValue15)
+ if closeErr := readBuffer.CloseContext("priorityValue15"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (priorityValue16)
+ if pullErr := readBuffer.PullContext("priorityValue16"); pullErr != nil {
+ return nil, pullErr
+ }
+ _priorityValue16, _priorityValue16Err := BACnetPriorityValueParse(readBuffer, BACnetObjectType(objectType))
+ if _priorityValue16Err != nil {
+ return nil, errors.Wrap(_priorityValue16Err, "Error parsing 'priorityValue16' field")
+ }
+ priorityValue16 := CastBACnetPriorityValue(_priorityValue16)
+ if closeErr := readBuffer.CloseContext("priorityValue16"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetPriorityArray"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create the instance
+ return NewBACnetPriorityArray(priorityValue01, priorityValue02, priorityValue03, priorityValue04, priorityValue05, priorityValue06, priorityValue07, priorityValue08, priorityValue09, priorityValue10, priorityValue11, priorityValue12, priorityValue13, priorityValue14, priorityValue15, priorityValue16, objectType), nil
+}
+
+func (m *BACnetPriorityArray) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ if pushErr := writeBuffer.PushContext("BACnetPriorityArray"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (priorityValue01)
+ if pushErr := writeBuffer.PushContext("priorityValue01"); pushErr != nil {
+ return pushErr
+ }
+ _priorityValue01Err := m.PriorityValue01.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("priorityValue01"); popErr != nil {
+ return popErr
+ }
+ if _priorityValue01Err != nil {
+ return errors.Wrap(_priorityValue01Err, "Error serializing 'priorityValue01' field")
+ }
+
+ // Simple Field (priorityValue02)
+ if pushErr := writeBuffer.PushContext("priorityValue02"); pushErr != nil {
+ return pushErr
+ }
+ _priorityValue02Err := m.PriorityValue02.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("priorityValue02"); popErr != nil {
+ return popErr
+ }
+ if _priorityValue02Err != nil {
+ return errors.Wrap(_priorityValue02Err, "Error serializing 'priorityValue02' field")
+ }
+
+ // Simple Field (priorityValue03)
+ if pushErr := writeBuffer.PushContext("priorityValue03"); pushErr != nil {
+ return pushErr
+ }
+ _priorityValue03Err := m.PriorityValue03.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("priorityValue03"); popErr != nil {
+ return popErr
+ }
+ if _priorityValue03Err != nil {
+ return errors.Wrap(_priorityValue03Err, "Error serializing 'priorityValue03' field")
+ }
+
+ // Simple Field (priorityValue04)
+ if pushErr := writeBuffer.PushContext("priorityValue04"); pushErr != nil {
+ return pushErr
+ }
+ _priorityValue04Err := m.PriorityValue04.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("priorityValue04"); popErr != nil {
+ return popErr
+ }
+ if _priorityValue04Err != nil {
+ return errors.Wrap(_priorityValue04Err, "Error serializing 'priorityValue04' field")
+ }
+
+ // Simple Field (priorityValue05)
+ if pushErr := writeBuffer.PushContext("priorityValue05"); pushErr != nil {
+ return pushErr
+ }
+ _priorityValue05Err := m.PriorityValue05.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("priorityValue05"); popErr != nil {
+ return popErr
+ }
+ if _priorityValue05Err != nil {
+ return errors.Wrap(_priorityValue05Err, "Error serializing 'priorityValue05' field")
+ }
+
+ // Simple Field (priorityValue06)
+ if pushErr := writeBuffer.PushContext("priorityValue06"); pushErr != nil {
+ return pushErr
+ }
+ _priorityValue06Err := m.PriorityValue06.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("priorityValue06"); popErr != nil {
+ return popErr
+ }
+ if _priorityValue06Err != nil {
+ return errors.Wrap(_priorityValue06Err, "Error serializing 'priorityValue06' field")
+ }
+
+ // Simple Field (priorityValue07)
+ if pushErr := writeBuffer.PushContext("priorityValue07"); pushErr != nil {
+ return pushErr
+ }
+ _priorityValue07Err := m.PriorityValue07.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("priorityValue07"); popErr != nil {
+ return popErr
+ }
+ if _priorityValue07Err != nil {
+ return errors.Wrap(_priorityValue07Err, "Error serializing 'priorityValue07' field")
+ }
+
+ // Simple Field (priorityValue08)
+ if pushErr := writeBuffer.PushContext("priorityValue08"); pushErr != nil {
+ return pushErr
+ }
+ _priorityValue08Err := m.PriorityValue08.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("priorityValue08"); popErr != nil {
+ return popErr
+ }
+ if _priorityValue08Err != nil {
+ return errors.Wrap(_priorityValue08Err, "Error serializing 'priorityValue08' field")
+ }
+
+ // Simple Field (priorityValue09)
+ if pushErr := writeBuffer.PushContext("priorityValue09"); pushErr != nil {
+ return pushErr
+ }
+ _priorityValue09Err := m.PriorityValue09.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("priorityValue09"); popErr != nil {
+ return popErr
+ }
+ if _priorityValue09Err != nil {
+ return errors.Wrap(_priorityValue09Err, "Error serializing 'priorityValue09' field")
+ }
+
+ // Simple Field (priorityValue10)
+ if pushErr := writeBuffer.PushContext("priorityValue10"); pushErr != nil {
+ return pushErr
+ }
+ _priorityValue10Err := m.PriorityValue10.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("priorityValue10"); popErr != nil {
+ return popErr
+ }
+ if _priorityValue10Err != nil {
+ return errors.Wrap(_priorityValue10Err, "Error serializing 'priorityValue10' field")
+ }
+
+ // Simple Field (priorityValue11)
+ if pushErr := writeBuffer.PushContext("priorityValue11"); pushErr != nil {
+ return pushErr
+ }
+ _priorityValue11Err := m.PriorityValue11.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("priorityValue11"); popErr != nil {
+ return popErr
+ }
+ if _priorityValue11Err != nil {
+ return errors.Wrap(_priorityValue11Err, "Error serializing 'priorityValue11' field")
+ }
+
+ // Simple Field (priorityValue12)
+ if pushErr := writeBuffer.PushContext("priorityValue12"); pushErr != nil {
+ return pushErr
+ }
+ _priorityValue12Err := m.PriorityValue12.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("priorityValue12"); popErr != nil {
+ return popErr
+ }
+ if _priorityValue12Err != nil {
+ return errors.Wrap(_priorityValue12Err, "Error serializing 'priorityValue12' field")
+ }
+
+ // Simple Field (priorityValue13)
+ if pushErr := writeBuffer.PushContext("priorityValue13"); pushErr != nil {
+ return pushErr
+ }
+ _priorityValue13Err := m.PriorityValue13.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("priorityValue13"); popErr != nil {
+ return popErr
+ }
+ if _priorityValue13Err != nil {
+ return errors.Wrap(_priorityValue13Err, "Error serializing 'priorityValue13' field")
+ }
+
+ // Simple Field (priorityValue14)
+ if pushErr := writeBuffer.PushContext("priorityValue14"); pushErr != nil {
+ return pushErr
+ }
+ _priorityValue14Err := m.PriorityValue14.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("priorityValue14"); popErr != nil {
+ return popErr
+ }
+ if _priorityValue14Err != nil {
+ return errors.Wrap(_priorityValue14Err, "Error serializing 'priorityValue14' field")
+ }
+
+ // Simple Field (priorityValue15)
+ if pushErr := writeBuffer.PushContext("priorityValue15"); pushErr != nil {
+ return pushErr
+ }
+ _priorityValue15Err := m.PriorityValue15.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("priorityValue15"); popErr != nil {
+ return popErr
+ }
+ if _priorityValue15Err != nil {
+ return errors.Wrap(_priorityValue15Err, "Error serializing 'priorityValue15' field")
+ }
+
+ // Simple Field (priorityValue16)
+ if pushErr := writeBuffer.PushContext("priorityValue16"); pushErr != nil {
+ return pushErr
+ }
+ _priorityValue16Err := m.PriorityValue16.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("priorityValue16"); popErr != nil {
+ return popErr
+ }
+ if _priorityValue16Err != nil {
+ return errors.Wrap(_priorityValue16Err, "Error serializing 'priorityValue16' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetPriorityArray"); popErr != nil {
+ return popErr
+ }
+ return nil
+}
+
+func (m *BACnetPriorityArray) 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/BACnetPriorityValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityValue.go
new file mode 100644
index 0000000000..fb76687436
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityValue.go
@@ -0,0 +1,264 @@
+/*
+ * 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.
+
+// BACnetPriorityValue is the data-structure of this message
+type BACnetPriorityValue struct {
+ PeekedTagHeader *BACnetTagHeader
+
+ // Arguments.
+ ObjectType BACnetObjectType
+ Child IBACnetPriorityValueChild
+}
+
+// IBACnetPriorityValue is the corresponding interface of BACnetPriorityValue
+type IBACnetPriorityValue interface {
+ // GetPeekedTagHeader returns PeekedTagHeader (property field)
+ GetPeekedTagHeader() *BACnetTagHeader
+ // GetPeekedTagNumber returns PeekedTagNumber (virtual field)
+ GetPeekedTagNumber() uint8
+ // GetPeekedIsContextTag returns PeekedIsContextTag (virtual field)
+ GetPeekedIsContextTag() bool
+ // 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
+}
+
+type IBACnetPriorityValueParent interface {
+ SerializeParent(writeBuffer utils.WriteBuffer, child IBACnetPriorityValue, serializeChildFunction func() error) error
+ GetTypeName() string
+}
+
+type IBACnetPriorityValueChild interface {
+ Serialize(writeBuffer utils.WriteBuffer) error
+ InitializeParent(parent *BACnetPriorityValue, peekedTagHeader *BACnetTagHeader)
+ GetParent() *BACnetPriorityValue
+
+ GetTypeName() string
+ IBACnetPriorityValue
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetPriorityValue) GetPeekedTagHeader() *BACnetTagHeader {
+ return m.PeekedTagHeader
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for virtual fields.
+///////////////////////
+
+func (m *BACnetPriorityValue) GetPeekedTagNumber() uint8 {
+ return uint8(m.GetPeekedTagHeader().GetActualTagNumber())
+}
+
+func (m *BACnetPriorityValue) GetPeekedIsContextTag() bool {
+ return bool(bool((m.GetPeekedTagHeader().GetTagClass()) == (TagClass_CONTEXT_SPECIFIC_TAGS)))
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetPriorityValue factory function for BACnetPriorityValue
+func NewBACnetPriorityValue(peekedTagHeader *BACnetTagHeader, objectType BACnetObjectType) *BACnetPriorityValue {
+ return &BACnetPriorityValue{PeekedTagHeader: peekedTagHeader, ObjectType: objectType}
+}
+
+func CastBACnetPriorityValue(structType interface{}) *BACnetPriorityValue {
+ if casted, ok := structType.(BACnetPriorityValue); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetPriorityValue); ok {
+ return casted
+ }
+ if casted, ok := structType.(IBACnetPriorityValueChild); ok {
+ return casted.GetParent()
+ }
+ return nil
+}
+
+func (m *BACnetPriorityValue) GetTypeName() string {
+ return "BACnetPriorityValue"
+}
+
+func (m *BACnetPriorityValue) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetPriorityValue) GetLengthInBitsConditional(lastItem bool) uint16 {
+ return m.Child.GetLengthInBits()
+}
+
+func (m *BACnetPriorityValue) GetParentLengthInBits() uint16 {
+ lengthInBits := uint16(0)
+
+ // A virtual field doesn't have any in- or output.
+
+ // A virtual field doesn't have any in- or output.
+
+ return lengthInBits
+}
+
+func (m *BACnetPriorityValue) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetPriorityValueParse(readBuffer utils.ReadBuffer, objectType BACnetObjectType) (*BACnetPriorityValue, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetPriorityValue"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Peek Field (peekedTagHeader)
+ currentPos = positionAware.GetPos()
+ if pullErr := readBuffer.PullContext("peekedTagHeader"); pullErr != nil {
+ return nil, pullErr
+ }
+ peekedTagHeader, _ := BACnetTagHeaderParse(readBuffer)
+ readBuffer.Reset(currentPos)
+
+ // Virtual field
+ _peekedTagNumber := peekedTagHeader.GetActualTagNumber()
+ peekedTagNumber := uint8(_peekedTagNumber)
+ _ = peekedTagNumber
+
+ // Virtual field
+ _peekedIsContextTag := bool((peekedTagHeader.GetTagClass()) == (TagClass_CONTEXT_SPECIFIC_TAGS))
+ peekedIsContextTag := bool(_peekedIsContextTag)
+ _ = peekedIsContextTag
+
+ // Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
+ type BACnetPriorityValueChild interface {
+ InitializeParent(*BACnetPriorityValue, *BACnetTagHeader)
+ GetParent() *BACnetPriorityValue
+ }
+ var _child BACnetPriorityValueChild
+ var typeSwitchError error
+ switch {
+ case peekedTagNumber == 0x0 && peekedIsContextTag == bool(false): // BACnetPriorityValueNull
+ _child, typeSwitchError = BACnetPriorityValueNullParse(readBuffer, objectType)
+ case peekedTagNumber == 0x4 && peekedIsContextTag == bool(false): // BACnetPriorityValueReal
+ _child, typeSwitchError = BACnetPriorityValueRealParse(readBuffer, objectType)
+ case peekedTagNumber == 0x9 && peekedIsContextTag == bool(false): // BACnetPriorityValueEnumerated
+ _child, typeSwitchError = BACnetPriorityValueEnumeratedParse(readBuffer, objectType)
+ case peekedTagNumber == 0x2 && peekedIsContextTag == bool(false): // BACnetPriorityValueUnsigned
+ _child, typeSwitchError = BACnetPriorityValueUnsignedParse(readBuffer, objectType)
+ case peekedTagNumber == 0x1 && peekedIsContextTag == bool(false): // BACnetPriorityValueBoolean
+ _child, typeSwitchError = BACnetPriorityValueBooleanParse(readBuffer, objectType)
+ case peekedTagNumber == 0x3 && peekedIsContextTag == bool(false): // BACnetPriorityValueInteger
+ _child, typeSwitchError = BACnetPriorityValueIntegerParse(readBuffer, objectType)
+ case peekedTagNumber == 0x5 && peekedIsContextTag == bool(false): // BACnetPriorityValueDouble
+ _child, typeSwitchError = BACnetPriorityValueDoubleParse(readBuffer, objectType)
+ case peekedTagNumber == 0xB && peekedIsContextTag == bool(false): // BACnetPriorityValueTime
+ _child, typeSwitchError = BACnetPriorityValueTimeParse(readBuffer, objectType)
+ case peekedTagNumber == 0x7 && peekedIsContextTag == bool(false): // BACnetPriorityValueCharacterString
+ _child, typeSwitchError = BACnetPriorityValueCharacterStringParse(readBuffer, objectType)
+ case peekedTagNumber == 0x6 && peekedIsContextTag == bool(false): // BACnetPriorityValueOctetString
+ _child, typeSwitchError = BACnetPriorityValueOctetStringParse(readBuffer, objectType)
+ case peekedTagNumber == 0x8 && peekedIsContextTag == bool(false): // BACnetPriorityValueBitString
+ _child, typeSwitchError = BACnetPriorityValueBitStringParse(readBuffer, objectType)
+ case peekedTagNumber == 0xA && peekedIsContextTag == bool(false): // BACnetPriorityValueDate
+ _child, typeSwitchError = BACnetPriorityValueDateParse(readBuffer, objectType)
+ case peekedTagNumber == 0xC && peekedIsContextTag == bool(false): // BACnetPriorityValueObjectidentifier
+ _child, typeSwitchError = BACnetPriorityValueObjectidentifierParse(readBuffer, objectType)
+ case peekedTagNumber == uint8(0) && peekedIsContextTag == bool(true): // BACnetPriorityValueConstructedValue
+ _child, typeSwitchError = BACnetPriorityValueConstructedValueParse(readBuffer, objectType)
+ case peekedTagNumber == uint8(1) && peekedIsContextTag == bool(true): // BACnetPriorityValueDateTime
+ _child, typeSwitchError = BACnetPriorityValueDateTimeParse(readBuffer, objectType)
+ default:
+ // TODO: return actual type
+ typeSwitchError = errors.New("Unmapped type")
+ }
+ if typeSwitchError != nil {
+ return nil, errors.Wrap(typeSwitchError, "Error parsing sub-type for type-switch.")
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetPriorityValue"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Finish initializing
+ _child.InitializeParent(_child.GetParent(), peekedTagHeader)
+ return _child.GetParent(), nil
+}
+
+func (m *BACnetPriorityValue) Serialize(writeBuffer utils.WriteBuffer) error {
+ return m.Child.Serialize(writeBuffer)
+}
+
+func (m *BACnetPriorityValue) SerializeParent(writeBuffer utils.WriteBuffer, child IBACnetPriorityValue, serializeChildFunction func() error) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ if pushErr := writeBuffer.PushContext("BACnetPriorityValue"); pushErr != nil {
+ return pushErr
+ }
+ // Virtual field
+ if _peekedTagNumberErr := writeBuffer.WriteVirtual("peekedTagNumber", m.GetPeekedTagNumber()); _peekedTagNumberErr != nil {
+ return errors.Wrap(_peekedTagNumberErr, "Error serializing 'peekedTagNumber' field")
+ }
+ // Virtual field
+ if _peekedIsContextTagErr := writeBuffer.WriteVirtual("peekedIsContextTag", m.GetPeekedIsContextTag()); _peekedIsContextTagErr != nil {
+ return errors.Wrap(_peekedIsContextTagErr, "Error serializing 'peekedIsContextTag' field")
+ }
+
+ // Switch field (Depending on the discriminator values, passes the serialization to a sub-type)
+ if _typeSwitchErr := serializeChildFunction(); _typeSwitchErr != nil {
+ return errors.Wrap(_typeSwitchErr, "Error serializing sub-type field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetPriorityValue"); popErr != nil {
+ return popErr
+ }
+ return nil
+}
+
+func (m *BACnetPriorityValue) 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/BACnetPriorityValueBitString.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityValueBitString.go
new file mode 100644
index 0000000000..3006279c24
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityValueBitString.go
@@ -0,0 +1,202 @@
+/*
+ * 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.
+
+// BACnetPriorityValueBitString is the data-structure of this message
+type BACnetPriorityValueBitString struct {
+ *BACnetPriorityValue
+ BitStringValue *BACnetApplicationTagBitString
+
+ // Arguments.
+ ObjectType BACnetObjectType
+}
+
+// IBACnetPriorityValueBitString is the corresponding interface of BACnetPriorityValueBitString
+type IBACnetPriorityValueBitString interface {
+ IBACnetPriorityValue
+ // GetBitStringValue returns BitStringValue (property field)
+ GetBitStringValue() *BACnetApplicationTagBitString
+ // 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 *BACnetPriorityValueBitString) InitializeParent(parent *BACnetPriorityValue, peekedTagHeader *BACnetTagHeader) {
+ m.BACnetPriorityValue.PeekedTagHeader = peekedTagHeader
+}
+
+func (m *BACnetPriorityValueBitString) GetParent() *BACnetPriorityValue {
+ return m.BACnetPriorityValue
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetPriorityValueBitString) GetBitStringValue() *BACnetApplicationTagBitString {
+ return m.BitStringValue
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetPriorityValueBitString factory function for BACnetPriorityValueBitString
+func NewBACnetPriorityValueBitString(bitStringValue *BACnetApplicationTagBitString, peekedTagHeader *BACnetTagHeader, objectType BACnetObjectType) *BACnetPriorityValueBitString {
+ _result := &BACnetPriorityValueBitString{
+ BitStringValue: bitStringValue,
+ BACnetPriorityValue: NewBACnetPriorityValue(peekedTagHeader, objectType),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetPriorityValueBitString(structType interface{}) *BACnetPriorityValueBitString {
+ if casted, ok := structType.(BACnetPriorityValueBitString); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetPriorityValueBitString); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetPriorityValue); ok {
+ return CastBACnetPriorityValueBitString(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetPriorityValue); ok {
+ return CastBACnetPriorityValueBitString(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetPriorityValueBitString) GetTypeName() string {
+ return "BACnetPriorityValueBitString"
+}
+
+func (m *BACnetPriorityValueBitString) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetPriorityValueBitString) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (bitStringValue)
+ lengthInBits += m.BitStringValue.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetPriorityValueBitString) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetPriorityValueBitStringParse(readBuffer utils.ReadBuffer, objectType BACnetObjectType) (*BACnetPriorityValueBitString, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetPriorityValueBitString"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (bitStringValue)
+ if pullErr := readBuffer.PullContext("bitStringValue"); pullErr != nil {
+ return nil, pullErr
+ }
+ _bitStringValue, _bitStringValueErr := BACnetApplicationTagParse(readBuffer)
+ if _bitStringValueErr != nil {
+ return nil, errors.Wrap(_bitStringValueErr, "Error parsing 'bitStringValue' field")
+ }
+ bitStringValue := CastBACnetApplicationTagBitString(_bitStringValue)
+ if closeErr := readBuffer.CloseContext("bitStringValue"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetPriorityValueBitString"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetPriorityValueBitString{
+ BitStringValue: CastBACnetApplicationTagBitString(bitStringValue),
+ BACnetPriorityValue: &BACnetPriorityValue{},
+ }
+ _child.BACnetPriorityValue.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetPriorityValueBitString) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetPriorityValueBitString"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (bitStringValue)
+ if pushErr := writeBuffer.PushContext("bitStringValue"); pushErr != nil {
+ return pushErr
+ }
+ _bitStringValueErr := m.BitStringValue.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("bitStringValue"); popErr != nil {
+ return popErr
+ }
+ if _bitStringValueErr != nil {
+ return errors.Wrap(_bitStringValueErr, "Error serializing 'bitStringValue' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetPriorityValueBitString"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetPriorityValueBitString) 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/BACnetPriorityValueBoolean.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityValueBoolean.go
new file mode 100644
index 0000000000..7e8874727c
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityValueBoolean.go
@@ -0,0 +1,202 @@
+/*
+ * 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.
+
+// BACnetPriorityValueBoolean is the data-structure of this message
+type BACnetPriorityValueBoolean struct {
+ *BACnetPriorityValue
+ BooleanValue *BACnetApplicationTagBoolean
+
+ // Arguments.
+ ObjectType BACnetObjectType
+}
+
+// IBACnetPriorityValueBoolean is the corresponding interface of BACnetPriorityValueBoolean
+type IBACnetPriorityValueBoolean interface {
+ IBACnetPriorityValue
+ // GetBooleanValue returns BooleanValue (property field)
+ GetBooleanValue() *BACnetApplicationTagBoolean
+ // 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 *BACnetPriorityValueBoolean) InitializeParent(parent *BACnetPriorityValue, peekedTagHeader *BACnetTagHeader) {
+ m.BACnetPriorityValue.PeekedTagHeader = peekedTagHeader
+}
+
+func (m *BACnetPriorityValueBoolean) GetParent() *BACnetPriorityValue {
+ return m.BACnetPriorityValue
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetPriorityValueBoolean) GetBooleanValue() *BACnetApplicationTagBoolean {
+ return m.BooleanValue
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetPriorityValueBoolean factory function for BACnetPriorityValueBoolean
+func NewBACnetPriorityValueBoolean(booleanValue *BACnetApplicationTagBoolean, peekedTagHeader *BACnetTagHeader, objectType BACnetObjectType) *BACnetPriorityValueBoolean {
+ _result := &BACnetPriorityValueBoolean{
+ BooleanValue: booleanValue,
+ BACnetPriorityValue: NewBACnetPriorityValue(peekedTagHeader, objectType),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetPriorityValueBoolean(structType interface{}) *BACnetPriorityValueBoolean {
+ if casted, ok := structType.(BACnetPriorityValueBoolean); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetPriorityValueBoolean); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetPriorityValue); ok {
+ return CastBACnetPriorityValueBoolean(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetPriorityValue); ok {
+ return CastBACnetPriorityValueBoolean(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetPriorityValueBoolean) GetTypeName() string {
+ return "BACnetPriorityValueBoolean"
+}
+
+func (m *BACnetPriorityValueBoolean) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetPriorityValueBoolean) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (booleanValue)
+ lengthInBits += m.BooleanValue.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetPriorityValueBoolean) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetPriorityValueBooleanParse(readBuffer utils.ReadBuffer, objectType BACnetObjectType) (*BACnetPriorityValueBoolean, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetPriorityValueBoolean"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (booleanValue)
+ if pullErr := readBuffer.PullContext("booleanValue"); pullErr != nil {
+ return nil, pullErr
+ }
+ _booleanValue, _booleanValueErr := BACnetApplicationTagParse(readBuffer)
+ if _booleanValueErr != nil {
+ return nil, errors.Wrap(_booleanValueErr, "Error parsing 'booleanValue' field")
+ }
+ booleanValue := CastBACnetApplicationTagBoolean(_booleanValue)
+ if closeErr := readBuffer.CloseContext("booleanValue"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetPriorityValueBoolean"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetPriorityValueBoolean{
+ BooleanValue: CastBACnetApplicationTagBoolean(booleanValue),
+ BACnetPriorityValue: &BACnetPriorityValue{},
+ }
+ _child.BACnetPriorityValue.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetPriorityValueBoolean) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetPriorityValueBoolean"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (booleanValue)
+ if pushErr := writeBuffer.PushContext("booleanValue"); pushErr != nil {
+ return pushErr
+ }
+ _booleanValueErr := m.BooleanValue.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("booleanValue"); popErr != nil {
+ return popErr
+ }
+ if _booleanValueErr != nil {
+ return errors.Wrap(_booleanValueErr, "Error serializing 'booleanValue' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetPriorityValueBoolean"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetPriorityValueBoolean) 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/BACnetPriorityValueCharacterString.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityValueCharacterString.go
new file mode 100644
index 0000000000..dd9c1b9d57
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityValueCharacterString.go
@@ -0,0 +1,202 @@
+/*
+ * 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.
+
+// BACnetPriorityValueCharacterString is the data-structure of this message
+type BACnetPriorityValueCharacterString struct {
+ *BACnetPriorityValue
+ CharacterStringValue *BACnetApplicationTagCharacterString
+
+ // Arguments.
+ ObjectType BACnetObjectType
+}
+
+// IBACnetPriorityValueCharacterString is the corresponding interface of BACnetPriorityValueCharacterString
+type IBACnetPriorityValueCharacterString interface {
+ IBACnetPriorityValue
+ // GetCharacterStringValue returns CharacterStringValue (property field)
+ GetCharacterStringValue() *BACnetApplicationTagCharacterString
+ // 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 *BACnetPriorityValueCharacterString) InitializeParent(parent *BACnetPriorityValue, peekedTagHeader *BACnetTagHeader) {
+ m.BACnetPriorityValue.PeekedTagHeader = peekedTagHeader
+}
+
+func (m *BACnetPriorityValueCharacterString) GetParent() *BACnetPriorityValue {
+ return m.BACnetPriorityValue
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetPriorityValueCharacterString) GetCharacterStringValue() *BACnetApplicationTagCharacterString {
+ return m.CharacterStringValue
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetPriorityValueCharacterString factory function for BACnetPriorityValueCharacterString
+func NewBACnetPriorityValueCharacterString(characterStringValue *BACnetApplicationTagCharacterString, peekedTagHeader *BACnetTagHeader, objectType BACnetObjectType) *BACnetPriorityValueCharacterString {
+ _result := &BACnetPriorityValueCharacterString{
+ CharacterStringValue: characterStringValue,
+ BACnetPriorityValue: NewBACnetPriorityValue(peekedTagHeader, objectType),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetPriorityValueCharacterString(structType interface{}) *BACnetPriorityValueCharacterString {
+ if casted, ok := structType.(BACnetPriorityValueCharacterString); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetPriorityValueCharacterString); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetPriorityValue); ok {
+ return CastBACnetPriorityValueCharacterString(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetPriorityValue); ok {
+ return CastBACnetPriorityValueCharacterString(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetPriorityValueCharacterString) GetTypeName() string {
+ return "BACnetPriorityValueCharacterString"
+}
+
+func (m *BACnetPriorityValueCharacterString) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetPriorityValueCharacterString) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (characterStringValue)
+ lengthInBits += m.CharacterStringValue.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetPriorityValueCharacterString) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetPriorityValueCharacterStringParse(readBuffer utils.ReadBuffer, objectType BACnetObjectType) (*BACnetPriorityValueCharacterString, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetPriorityValueCharacterString"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (characterStringValue)
+ if pullErr := readBuffer.PullContext("characterStringValue"); pullErr != nil {
+ return nil, pullErr
+ }
+ _characterStringValue, _characterStringValueErr := BACnetApplicationTagParse(readBuffer)
+ if _characterStringValueErr != nil {
+ return nil, errors.Wrap(_characterStringValueErr, "Error parsing 'characterStringValue' field")
+ }
+ characterStringValue := CastBACnetApplicationTagCharacterString(_characterStringValue)
+ if closeErr := readBuffer.CloseContext("characterStringValue"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetPriorityValueCharacterString"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetPriorityValueCharacterString{
+ CharacterStringValue: CastBACnetApplicationTagCharacterString(characterStringValue),
+ BACnetPriorityValue: &BACnetPriorityValue{},
+ }
+ _child.BACnetPriorityValue.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetPriorityValueCharacterString) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetPriorityValueCharacterString"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (characterStringValue)
+ if pushErr := writeBuffer.PushContext("characterStringValue"); pushErr != nil {
+ return pushErr
+ }
+ _characterStringValueErr := m.CharacterStringValue.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("characterStringValue"); popErr != nil {
+ return popErr
+ }
+ if _characterStringValueErr != nil {
+ return errors.Wrap(_characterStringValueErr, "Error serializing 'characterStringValue' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetPriorityValueCharacterString"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetPriorityValueCharacterString) 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/BACnetPriorityValueConstructedValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityValueConstructedValue.go
new file mode 100644
index 0000000000..b4d0cfe8dc
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityValueConstructedValue.go
@@ -0,0 +1,202 @@
+/*
+ * 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.
+
+// BACnetPriorityValueConstructedValue is the data-structure of this message
+type BACnetPriorityValueConstructedValue struct {
+ *BACnetPriorityValue
+ ConstructedValue *BACnetConstructedData
+
+ // Arguments.
+ ObjectType BACnetObjectType
+}
+
+// IBACnetPriorityValueConstructedValue is the corresponding interface of BACnetPriorityValueConstructedValue
+type IBACnetPriorityValueConstructedValue interface {
+ IBACnetPriorityValue
+ // GetConstructedValue returns ConstructedValue (property field)
+ GetConstructedValue() *BACnetConstructedData
+ // 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 *BACnetPriorityValueConstructedValue) InitializeParent(parent *BACnetPriorityValue, peekedTagHeader *BACnetTagHeader) {
+ m.BACnetPriorityValue.PeekedTagHeader = peekedTagHeader
+}
+
+func (m *BACnetPriorityValueConstructedValue) GetParent() *BACnetPriorityValue {
+ return m.BACnetPriorityValue
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetPriorityValueConstructedValue) GetConstructedValue() *BACnetConstructedData {
+ return m.ConstructedValue
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetPriorityValueConstructedValue factory function for BACnetPriorityValueConstructedValue
+func NewBACnetPriorityValueConstructedValue(constructedValue *BACnetConstructedData, peekedTagHeader *BACnetTagHeader, objectType BACnetObjectType) *BACnetPriorityValueConstructedValue {
+ _result := &BACnetPriorityValueConstructedValue{
+ ConstructedValue: constructedValue,
+ BACnetPriorityValue: NewBACnetPriorityValue(peekedTagHeader, objectType),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetPriorityValueConstructedValue(structType interface{}) *BACnetPriorityValueConstructedValue {
+ if casted, ok := structType.(BACnetPriorityValueConstructedValue); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetPriorityValueConstructedValue); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetPriorityValue); ok {
+ return CastBACnetPriorityValueConstructedValue(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetPriorityValue); ok {
+ return CastBACnetPriorityValueConstructedValue(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetPriorityValueConstructedValue) GetTypeName() string {
+ return "BACnetPriorityValueConstructedValue"
+}
+
+func (m *BACnetPriorityValueConstructedValue) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetPriorityValueConstructedValue) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (constructedValue)
+ lengthInBits += m.ConstructedValue.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetPriorityValueConstructedValue) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetPriorityValueConstructedValueParse(readBuffer utils.ReadBuffer, objectType BACnetObjectType) (*BACnetPriorityValueConstructedValue, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetPriorityValueConstructedValue"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (constructedValue)
+ if pullErr := readBuffer.PullContext("constructedValue"); pullErr != nil {
+ return nil, pullErr
+ }
+ _constructedValue, _constructedValueErr := BACnetConstructedDataParse(readBuffer, uint8(uint8(0)), BACnetObjectType(objectType), BACnetPropertyIdentifier(BACnetPropertyIdentifier_VENDOR_PROPRIETARY_VALUE))
+ if _constructedValueErr != nil {
+ return nil, errors.Wrap(_constructedValueErr, "Error parsing 'constructedValue' field")
+ }
+ constructedValue := CastBACnetConstructedData(_constructedValue)
+ if closeErr := readBuffer.CloseContext("constructedValue"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetPriorityValueConstructedValue"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetPriorityValueConstructedValue{
+ ConstructedValue: CastBACnetConstructedData(constructedValue),
+ BACnetPriorityValue: &BACnetPriorityValue{},
+ }
+ _child.BACnetPriorityValue.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetPriorityValueConstructedValue) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetPriorityValueConstructedValue"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (constructedValue)
+ if pushErr := writeBuffer.PushContext("constructedValue"); pushErr != nil {
+ return pushErr
+ }
+ _constructedValueErr := m.ConstructedValue.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("constructedValue"); popErr != nil {
+ return popErr
+ }
+ if _constructedValueErr != nil {
+ return errors.Wrap(_constructedValueErr, "Error serializing 'constructedValue' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetPriorityValueConstructedValue"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetPriorityValueConstructedValue) 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/BACnetPriorityValueDate.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityValueDate.go
new file mode 100644
index 0000000000..dbeb52b3ba
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityValueDate.go
@@ -0,0 +1,202 @@
+/*
+ * 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.
+
+// BACnetPriorityValueDate is the data-structure of this message
+type BACnetPriorityValueDate struct {
+ *BACnetPriorityValue
+ DateValue *BACnetApplicationTagDate
+
+ // Arguments.
+ ObjectType BACnetObjectType
+}
+
+// IBACnetPriorityValueDate is the corresponding interface of BACnetPriorityValueDate
+type IBACnetPriorityValueDate interface {
+ IBACnetPriorityValue
+ // GetDateValue returns DateValue (property field)
+ GetDateValue() *BACnetApplicationTagDate
+ // 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 *BACnetPriorityValueDate) InitializeParent(parent *BACnetPriorityValue, peekedTagHeader *BACnetTagHeader) {
+ m.BACnetPriorityValue.PeekedTagHeader = peekedTagHeader
+}
+
+func (m *BACnetPriorityValueDate) GetParent() *BACnetPriorityValue {
+ return m.BACnetPriorityValue
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetPriorityValueDate) GetDateValue() *BACnetApplicationTagDate {
+ return m.DateValue
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetPriorityValueDate factory function for BACnetPriorityValueDate
+func NewBACnetPriorityValueDate(dateValue *BACnetApplicationTagDate, peekedTagHeader *BACnetTagHeader, objectType BACnetObjectType) *BACnetPriorityValueDate {
+ _result := &BACnetPriorityValueDate{
+ DateValue: dateValue,
+ BACnetPriorityValue: NewBACnetPriorityValue(peekedTagHeader, objectType),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetPriorityValueDate(structType interface{}) *BACnetPriorityValueDate {
+ if casted, ok := structType.(BACnetPriorityValueDate); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetPriorityValueDate); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetPriorityValue); ok {
+ return CastBACnetPriorityValueDate(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetPriorityValue); ok {
+ return CastBACnetPriorityValueDate(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetPriorityValueDate) GetTypeName() string {
+ return "BACnetPriorityValueDate"
+}
+
+func (m *BACnetPriorityValueDate) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetPriorityValueDate) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (dateValue)
+ lengthInBits += m.DateValue.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetPriorityValueDate) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetPriorityValueDateParse(readBuffer utils.ReadBuffer, objectType BACnetObjectType) (*BACnetPriorityValueDate, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetPriorityValueDate"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (dateValue)
+ if pullErr := readBuffer.PullContext("dateValue"); pullErr != nil {
+ return nil, pullErr
+ }
+ _dateValue, _dateValueErr := BACnetApplicationTagParse(readBuffer)
+ if _dateValueErr != nil {
+ return nil, errors.Wrap(_dateValueErr, "Error parsing 'dateValue' field")
+ }
+ dateValue := CastBACnetApplicationTagDate(_dateValue)
+ if closeErr := readBuffer.CloseContext("dateValue"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetPriorityValueDate"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetPriorityValueDate{
+ DateValue: CastBACnetApplicationTagDate(dateValue),
+ BACnetPriorityValue: &BACnetPriorityValue{},
+ }
+ _child.BACnetPriorityValue.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetPriorityValueDate) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetPriorityValueDate"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (dateValue)
+ if pushErr := writeBuffer.PushContext("dateValue"); pushErr != nil {
+ return pushErr
+ }
+ _dateValueErr := m.DateValue.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("dateValue"); popErr != nil {
+ return popErr
+ }
+ if _dateValueErr != nil {
+ return errors.Wrap(_dateValueErr, "Error serializing 'dateValue' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetPriorityValueDate"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetPriorityValueDate) 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/BACnetPriorityValueDateTime.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityValueDateTime.go
new file mode 100644
index 0000000000..33f7922552
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityValueDateTime.go
@@ -0,0 +1,202 @@
+/*
+ * 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.
+
+// BACnetPriorityValueDateTime is the data-structure of this message
+type BACnetPriorityValueDateTime struct {
+ *BACnetPriorityValue
+ DateTimeValue *BACnetDateTimeEnclosed
+
+ // Arguments.
+ ObjectType BACnetObjectType
+}
+
+// IBACnetPriorityValueDateTime is the corresponding interface of BACnetPriorityValueDateTime
+type IBACnetPriorityValueDateTime interface {
+ IBACnetPriorityValue
+ // GetDateTimeValue returns DateTimeValue (property field)
+ GetDateTimeValue() *BACnetDateTimeEnclosed
+ // 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 *BACnetPriorityValueDateTime) InitializeParent(parent *BACnetPriorityValue, peekedTagHeader *BACnetTagHeader) {
+ m.BACnetPriorityValue.PeekedTagHeader = peekedTagHeader
+}
+
+func (m *BACnetPriorityValueDateTime) GetParent() *BACnetPriorityValue {
+ return m.BACnetPriorityValue
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetPriorityValueDateTime) GetDateTimeValue() *BACnetDateTimeEnclosed {
+ return m.DateTimeValue
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetPriorityValueDateTime factory function for BACnetPriorityValueDateTime
+func NewBACnetPriorityValueDateTime(dateTimeValue *BACnetDateTimeEnclosed, peekedTagHeader *BACnetTagHeader, objectType BACnetObjectType) *BACnetPriorityValueDateTime {
+ _result := &BACnetPriorityValueDateTime{
+ DateTimeValue: dateTimeValue,
+ BACnetPriorityValue: NewBACnetPriorityValue(peekedTagHeader, objectType),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetPriorityValueDateTime(structType interface{}) *BACnetPriorityValueDateTime {
+ if casted, ok := structType.(BACnetPriorityValueDateTime); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetPriorityValueDateTime); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetPriorityValue); ok {
+ return CastBACnetPriorityValueDateTime(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetPriorityValue); ok {
+ return CastBACnetPriorityValueDateTime(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetPriorityValueDateTime) GetTypeName() string {
+ return "BACnetPriorityValueDateTime"
+}
+
+func (m *BACnetPriorityValueDateTime) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetPriorityValueDateTime) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (dateTimeValue)
+ lengthInBits += m.DateTimeValue.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetPriorityValueDateTime) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetPriorityValueDateTimeParse(readBuffer utils.ReadBuffer, objectType BACnetObjectType) (*BACnetPriorityValueDateTime, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetPriorityValueDateTime"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (dateTimeValue)
+ if pullErr := readBuffer.PullContext("dateTimeValue"); pullErr != nil {
+ return nil, pullErr
+ }
+ _dateTimeValue, _dateTimeValueErr := BACnetDateTimeEnclosedParse(readBuffer, uint8(uint8(1)))
+ if _dateTimeValueErr != nil {
+ return nil, errors.Wrap(_dateTimeValueErr, "Error parsing 'dateTimeValue' field")
+ }
+ dateTimeValue := CastBACnetDateTimeEnclosed(_dateTimeValue)
+ if closeErr := readBuffer.CloseContext("dateTimeValue"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetPriorityValueDateTime"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetPriorityValueDateTime{
+ DateTimeValue: CastBACnetDateTimeEnclosed(dateTimeValue),
+ BACnetPriorityValue: &BACnetPriorityValue{},
+ }
+ _child.BACnetPriorityValue.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetPriorityValueDateTime) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetPriorityValueDateTime"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (dateTimeValue)
+ if pushErr := writeBuffer.PushContext("dateTimeValue"); pushErr != nil {
+ return pushErr
+ }
+ _dateTimeValueErr := m.DateTimeValue.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("dateTimeValue"); popErr != nil {
+ return popErr
+ }
+ if _dateTimeValueErr != nil {
+ return errors.Wrap(_dateTimeValueErr, "Error serializing 'dateTimeValue' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetPriorityValueDateTime"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetPriorityValueDateTime) 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/BACnetPriorityValueDouble.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityValueDouble.go
new file mode 100644
index 0000000000..f989aa0b44
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityValueDouble.go
@@ -0,0 +1,202 @@
+/*
+ * 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.
+
+// BACnetPriorityValueDouble is the data-structure of this message
+type BACnetPriorityValueDouble struct {
+ *BACnetPriorityValue
+ DoubleValue *BACnetApplicationTagDouble
+
+ // Arguments.
+ ObjectType BACnetObjectType
+}
+
+// IBACnetPriorityValueDouble is the corresponding interface of BACnetPriorityValueDouble
+type IBACnetPriorityValueDouble interface {
+ IBACnetPriorityValue
+ // GetDoubleValue returns DoubleValue (property field)
+ GetDoubleValue() *BACnetApplicationTagDouble
+ // 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 *BACnetPriorityValueDouble) InitializeParent(parent *BACnetPriorityValue, peekedTagHeader *BACnetTagHeader) {
+ m.BACnetPriorityValue.PeekedTagHeader = peekedTagHeader
+}
+
+func (m *BACnetPriorityValueDouble) GetParent() *BACnetPriorityValue {
+ return m.BACnetPriorityValue
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetPriorityValueDouble) GetDoubleValue() *BACnetApplicationTagDouble {
+ return m.DoubleValue
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetPriorityValueDouble factory function for BACnetPriorityValueDouble
+func NewBACnetPriorityValueDouble(doubleValue *BACnetApplicationTagDouble, peekedTagHeader *BACnetTagHeader, objectType BACnetObjectType) *BACnetPriorityValueDouble {
+ _result := &BACnetPriorityValueDouble{
+ DoubleValue: doubleValue,
+ BACnetPriorityValue: NewBACnetPriorityValue(peekedTagHeader, objectType),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetPriorityValueDouble(structType interface{}) *BACnetPriorityValueDouble {
+ if casted, ok := structType.(BACnetPriorityValueDouble); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetPriorityValueDouble); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetPriorityValue); ok {
+ return CastBACnetPriorityValueDouble(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetPriorityValue); ok {
+ return CastBACnetPriorityValueDouble(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetPriorityValueDouble) GetTypeName() string {
+ return "BACnetPriorityValueDouble"
+}
+
+func (m *BACnetPriorityValueDouble) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetPriorityValueDouble) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (doubleValue)
+ lengthInBits += m.DoubleValue.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetPriorityValueDouble) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetPriorityValueDoubleParse(readBuffer utils.ReadBuffer, objectType BACnetObjectType) (*BACnetPriorityValueDouble, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetPriorityValueDouble"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (doubleValue)
+ if pullErr := readBuffer.PullContext("doubleValue"); pullErr != nil {
+ return nil, pullErr
+ }
+ _doubleValue, _doubleValueErr := BACnetApplicationTagParse(readBuffer)
+ if _doubleValueErr != nil {
+ return nil, errors.Wrap(_doubleValueErr, "Error parsing 'doubleValue' field")
+ }
+ doubleValue := CastBACnetApplicationTagDouble(_doubleValue)
+ if closeErr := readBuffer.CloseContext("doubleValue"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetPriorityValueDouble"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetPriorityValueDouble{
+ DoubleValue: CastBACnetApplicationTagDouble(doubleValue),
+ BACnetPriorityValue: &BACnetPriorityValue{},
+ }
+ _child.BACnetPriorityValue.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetPriorityValueDouble) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetPriorityValueDouble"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (doubleValue)
+ if pushErr := writeBuffer.PushContext("doubleValue"); pushErr != nil {
+ return pushErr
+ }
+ _doubleValueErr := m.DoubleValue.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("doubleValue"); popErr != nil {
+ return popErr
+ }
+ if _doubleValueErr != nil {
+ return errors.Wrap(_doubleValueErr, "Error serializing 'doubleValue' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetPriorityValueDouble"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetPriorityValueDouble) 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/BACnetPriorityValueEnumerated.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityValueEnumerated.go
new file mode 100644
index 0000000000..1291568125
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityValueEnumerated.go
@@ -0,0 +1,202 @@
+/*
+ * 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.
+
+// BACnetPriorityValueEnumerated is the data-structure of this message
+type BACnetPriorityValueEnumerated struct {
+ *BACnetPriorityValue
+ EnumeratedValue *BACnetApplicationTagEnumerated
+
+ // Arguments.
+ ObjectType BACnetObjectType
+}
+
+// IBACnetPriorityValueEnumerated is the corresponding interface of BACnetPriorityValueEnumerated
+type IBACnetPriorityValueEnumerated interface {
+ IBACnetPriorityValue
+ // GetEnumeratedValue returns EnumeratedValue (property field)
+ GetEnumeratedValue() *BACnetApplicationTagEnumerated
+ // 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 *BACnetPriorityValueEnumerated) InitializeParent(parent *BACnetPriorityValue, peekedTagHeader *BACnetTagHeader) {
+ m.BACnetPriorityValue.PeekedTagHeader = peekedTagHeader
+}
+
+func (m *BACnetPriorityValueEnumerated) GetParent() *BACnetPriorityValue {
+ return m.BACnetPriorityValue
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetPriorityValueEnumerated) GetEnumeratedValue() *BACnetApplicationTagEnumerated {
+ return m.EnumeratedValue
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetPriorityValueEnumerated factory function for BACnetPriorityValueEnumerated
+func NewBACnetPriorityValueEnumerated(enumeratedValue *BACnetApplicationTagEnumerated, peekedTagHeader *BACnetTagHeader, objectType BACnetObjectType) *BACnetPriorityValueEnumerated {
+ _result := &BACnetPriorityValueEnumerated{
+ EnumeratedValue: enumeratedValue,
+ BACnetPriorityValue: NewBACnetPriorityValue(peekedTagHeader, objectType),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetPriorityValueEnumerated(structType interface{}) *BACnetPriorityValueEnumerated {
+ if casted, ok := structType.(BACnetPriorityValueEnumerated); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetPriorityValueEnumerated); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetPriorityValue); ok {
+ return CastBACnetPriorityValueEnumerated(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetPriorityValue); ok {
+ return CastBACnetPriorityValueEnumerated(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetPriorityValueEnumerated) GetTypeName() string {
+ return "BACnetPriorityValueEnumerated"
+}
+
+func (m *BACnetPriorityValueEnumerated) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetPriorityValueEnumerated) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (enumeratedValue)
+ lengthInBits += m.EnumeratedValue.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetPriorityValueEnumerated) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetPriorityValueEnumeratedParse(readBuffer utils.ReadBuffer, objectType BACnetObjectType) (*BACnetPriorityValueEnumerated, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetPriorityValueEnumerated"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (enumeratedValue)
+ if pullErr := readBuffer.PullContext("enumeratedValue"); pullErr != nil {
+ return nil, pullErr
+ }
+ _enumeratedValue, _enumeratedValueErr := BACnetApplicationTagParse(readBuffer)
+ if _enumeratedValueErr != nil {
+ return nil, errors.Wrap(_enumeratedValueErr, "Error parsing 'enumeratedValue' field")
+ }
+ enumeratedValue := CastBACnetApplicationTagEnumerated(_enumeratedValue)
+ if closeErr := readBuffer.CloseContext("enumeratedValue"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetPriorityValueEnumerated"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetPriorityValueEnumerated{
+ EnumeratedValue: CastBACnetApplicationTagEnumerated(enumeratedValue),
+ BACnetPriorityValue: &BACnetPriorityValue{},
+ }
+ _child.BACnetPriorityValue.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetPriorityValueEnumerated) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetPriorityValueEnumerated"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (enumeratedValue)
+ if pushErr := writeBuffer.PushContext("enumeratedValue"); pushErr != nil {
+ return pushErr
+ }
+ _enumeratedValueErr := m.EnumeratedValue.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("enumeratedValue"); popErr != nil {
+ return popErr
+ }
+ if _enumeratedValueErr != nil {
+ return errors.Wrap(_enumeratedValueErr, "Error serializing 'enumeratedValue' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetPriorityValueEnumerated"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetPriorityValueEnumerated) 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/BACnetPriorityValueInteger.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityValueInteger.go
new file mode 100644
index 0000000000..c24ac05042
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityValueInteger.go
@@ -0,0 +1,202 @@
+/*
+ * 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.
+
+// BACnetPriorityValueInteger is the data-structure of this message
+type BACnetPriorityValueInteger struct {
+ *BACnetPriorityValue
+ IntegerValue *BACnetApplicationTagSignedInteger
+
+ // Arguments.
+ ObjectType BACnetObjectType
+}
+
+// IBACnetPriorityValueInteger is the corresponding interface of BACnetPriorityValueInteger
+type IBACnetPriorityValueInteger interface {
+ IBACnetPriorityValue
+ // GetIntegerValue returns IntegerValue (property field)
+ GetIntegerValue() *BACnetApplicationTagSignedInteger
+ // 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 *BACnetPriorityValueInteger) InitializeParent(parent *BACnetPriorityValue, peekedTagHeader *BACnetTagHeader) {
+ m.BACnetPriorityValue.PeekedTagHeader = peekedTagHeader
+}
+
+func (m *BACnetPriorityValueInteger) GetParent() *BACnetPriorityValue {
+ return m.BACnetPriorityValue
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetPriorityValueInteger) GetIntegerValue() *BACnetApplicationTagSignedInteger {
+ return m.IntegerValue
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetPriorityValueInteger factory function for BACnetPriorityValueInteger
+func NewBACnetPriorityValueInteger(integerValue *BACnetApplicationTagSignedInteger, peekedTagHeader *BACnetTagHeader, objectType BACnetObjectType) *BACnetPriorityValueInteger {
+ _result := &BACnetPriorityValueInteger{
+ IntegerValue: integerValue,
+ BACnetPriorityValue: NewBACnetPriorityValue(peekedTagHeader, objectType),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetPriorityValueInteger(structType interface{}) *BACnetPriorityValueInteger {
+ if casted, ok := structType.(BACnetPriorityValueInteger); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetPriorityValueInteger); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetPriorityValue); ok {
+ return CastBACnetPriorityValueInteger(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetPriorityValue); ok {
+ return CastBACnetPriorityValueInteger(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetPriorityValueInteger) GetTypeName() string {
+ return "BACnetPriorityValueInteger"
+}
+
+func (m *BACnetPriorityValueInteger) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetPriorityValueInteger) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (integerValue)
+ lengthInBits += m.IntegerValue.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetPriorityValueInteger) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetPriorityValueIntegerParse(readBuffer utils.ReadBuffer, objectType BACnetObjectType) (*BACnetPriorityValueInteger, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetPriorityValueInteger"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (integerValue)
+ if pullErr := readBuffer.PullContext("integerValue"); pullErr != nil {
+ return nil, pullErr
+ }
+ _integerValue, _integerValueErr := BACnetApplicationTagParse(readBuffer)
+ if _integerValueErr != nil {
+ return nil, errors.Wrap(_integerValueErr, "Error parsing 'integerValue' field")
+ }
+ integerValue := CastBACnetApplicationTagSignedInteger(_integerValue)
+ if closeErr := readBuffer.CloseContext("integerValue"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetPriorityValueInteger"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetPriorityValueInteger{
+ IntegerValue: CastBACnetApplicationTagSignedInteger(integerValue),
+ BACnetPriorityValue: &BACnetPriorityValue{},
+ }
+ _child.BACnetPriorityValue.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetPriorityValueInteger) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetPriorityValueInteger"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (integerValue)
+ if pushErr := writeBuffer.PushContext("integerValue"); pushErr != nil {
+ return pushErr
+ }
+ _integerValueErr := m.IntegerValue.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("integerValue"); popErr != nil {
+ return popErr
+ }
+ if _integerValueErr != nil {
+ return errors.Wrap(_integerValueErr, "Error serializing 'integerValue' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetPriorityValueInteger"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetPriorityValueInteger) 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/BACnetPriorityValueNull.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityValueNull.go
new file mode 100644
index 0000000000..44eeb0ef37
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityValueNull.go
@@ -0,0 +1,202 @@
+/*
+ * 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.
+
+// BACnetPriorityValueNull is the data-structure of this message
+type BACnetPriorityValueNull struct {
+ *BACnetPriorityValue
+ NullValue *BACnetApplicationTagNull
+
+ // Arguments.
+ ObjectType BACnetObjectType
+}
+
+// IBACnetPriorityValueNull is the corresponding interface of BACnetPriorityValueNull
+type IBACnetPriorityValueNull interface {
+ IBACnetPriorityValue
+ // GetNullValue returns NullValue (property field)
+ GetNullValue() *BACnetApplicationTagNull
+ // 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 *BACnetPriorityValueNull) InitializeParent(parent *BACnetPriorityValue, peekedTagHeader *BACnetTagHeader) {
+ m.BACnetPriorityValue.PeekedTagHeader = peekedTagHeader
+}
+
+func (m *BACnetPriorityValueNull) GetParent() *BACnetPriorityValue {
+ return m.BACnetPriorityValue
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetPriorityValueNull) GetNullValue() *BACnetApplicationTagNull {
+ return m.NullValue
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetPriorityValueNull factory function for BACnetPriorityValueNull
+func NewBACnetPriorityValueNull(nullValue *BACnetApplicationTagNull, peekedTagHeader *BACnetTagHeader, objectType BACnetObjectType) *BACnetPriorityValueNull {
+ _result := &BACnetPriorityValueNull{
+ NullValue: nullValue,
+ BACnetPriorityValue: NewBACnetPriorityValue(peekedTagHeader, objectType),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetPriorityValueNull(structType interface{}) *BACnetPriorityValueNull {
+ if casted, ok := structType.(BACnetPriorityValueNull); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetPriorityValueNull); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetPriorityValue); ok {
+ return CastBACnetPriorityValueNull(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetPriorityValue); ok {
+ return CastBACnetPriorityValueNull(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetPriorityValueNull) GetTypeName() string {
+ return "BACnetPriorityValueNull"
+}
+
+func (m *BACnetPriorityValueNull) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetPriorityValueNull) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (nullValue)
+ lengthInBits += m.NullValue.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetPriorityValueNull) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetPriorityValueNullParse(readBuffer utils.ReadBuffer, objectType BACnetObjectType) (*BACnetPriorityValueNull, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetPriorityValueNull"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (nullValue)
+ if pullErr := readBuffer.PullContext("nullValue"); pullErr != nil {
+ return nil, pullErr
+ }
+ _nullValue, _nullValueErr := BACnetApplicationTagParse(readBuffer)
+ if _nullValueErr != nil {
+ return nil, errors.Wrap(_nullValueErr, "Error parsing 'nullValue' field")
+ }
+ nullValue := CastBACnetApplicationTagNull(_nullValue)
+ if closeErr := readBuffer.CloseContext("nullValue"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetPriorityValueNull"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetPriorityValueNull{
+ NullValue: CastBACnetApplicationTagNull(nullValue),
+ BACnetPriorityValue: &BACnetPriorityValue{},
+ }
+ _child.BACnetPriorityValue.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetPriorityValueNull) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetPriorityValueNull"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (nullValue)
+ if pushErr := writeBuffer.PushContext("nullValue"); pushErr != nil {
+ return pushErr
+ }
+ _nullValueErr := m.NullValue.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("nullValue"); popErr != nil {
+ return popErr
+ }
+ if _nullValueErr != nil {
+ return errors.Wrap(_nullValueErr, "Error serializing 'nullValue' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetPriorityValueNull"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetPriorityValueNull) 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/BACnetPriorityValueObjectidentifier.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityValueObjectidentifier.go
new file mode 100644
index 0000000000..4314a7cdf3
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityValueObjectidentifier.go
@@ -0,0 +1,202 @@
+/*
+ * 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.
+
+// BACnetPriorityValueObjectidentifier is the data-structure of this message
+type BACnetPriorityValueObjectidentifier struct {
+ *BACnetPriorityValue
+ ObjectidentifierValue *BACnetApplicationTagObjectIdentifier
+
+ // Arguments.
+ ObjectType BACnetObjectType
+}
+
+// IBACnetPriorityValueObjectidentifier is the corresponding interface of BACnetPriorityValueObjectidentifier
+type IBACnetPriorityValueObjectidentifier interface {
+ IBACnetPriorityValue
+ // GetObjectidentifierValue returns ObjectidentifierValue (property field)
+ GetObjectidentifierValue() *BACnetApplicationTagObjectIdentifier
+ // 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 *BACnetPriorityValueObjectidentifier) InitializeParent(parent *BACnetPriorityValue, peekedTagHeader *BACnetTagHeader) {
+ m.BACnetPriorityValue.PeekedTagHeader = peekedTagHeader
+}
+
+func (m *BACnetPriorityValueObjectidentifier) GetParent() *BACnetPriorityValue {
+ return m.BACnetPriorityValue
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetPriorityValueObjectidentifier) GetObjectidentifierValue() *BACnetApplicationTagObjectIdentifier {
+ return m.ObjectidentifierValue
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetPriorityValueObjectidentifier factory function for BACnetPriorityValueObjectidentifier
+func NewBACnetPriorityValueObjectidentifier(objectidentifierValue *BACnetApplicationTagObjectIdentifier, peekedTagHeader *BACnetTagHeader, objectType BACnetObjectType) *BACnetPriorityValueObjectidentifier {
+ _result := &BACnetPriorityValueObjectidentifier{
+ ObjectidentifierValue: objectidentifierValue,
+ BACnetPriorityValue: NewBACnetPriorityValue(peekedTagHeader, objectType),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetPriorityValueObjectidentifier(structType interface{}) *BACnetPriorityValueObjectidentifier {
+ if casted, ok := structType.(BACnetPriorityValueObjectidentifier); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetPriorityValueObjectidentifier); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetPriorityValue); ok {
+ return CastBACnetPriorityValueObjectidentifier(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetPriorityValue); ok {
+ return CastBACnetPriorityValueObjectidentifier(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetPriorityValueObjectidentifier) GetTypeName() string {
+ return "BACnetPriorityValueObjectidentifier"
+}
+
+func (m *BACnetPriorityValueObjectidentifier) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetPriorityValueObjectidentifier) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (objectidentifierValue)
+ lengthInBits += m.ObjectidentifierValue.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetPriorityValueObjectidentifier) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetPriorityValueObjectidentifierParse(readBuffer utils.ReadBuffer, objectType BACnetObjectType) (*BACnetPriorityValueObjectidentifier, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetPriorityValueObjectidentifier"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (objectidentifierValue)
+ if pullErr := readBuffer.PullContext("objectidentifierValue"); pullErr != nil {
+ return nil, pullErr
+ }
+ _objectidentifierValue, _objectidentifierValueErr := BACnetApplicationTagParse(readBuffer)
+ if _objectidentifierValueErr != nil {
+ return nil, errors.Wrap(_objectidentifierValueErr, "Error parsing 'objectidentifierValue' field")
+ }
+ objectidentifierValue := CastBACnetApplicationTagObjectIdentifier(_objectidentifierValue)
+ if closeErr := readBuffer.CloseContext("objectidentifierValue"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetPriorityValueObjectidentifier"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetPriorityValueObjectidentifier{
+ ObjectidentifierValue: CastBACnetApplicationTagObjectIdentifier(objectidentifierValue),
+ BACnetPriorityValue: &BACnetPriorityValue{},
+ }
+ _child.BACnetPriorityValue.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetPriorityValueObjectidentifier) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetPriorityValueObjectidentifier"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (objectidentifierValue)
+ if pushErr := writeBuffer.PushContext("objectidentifierValue"); pushErr != nil {
+ return pushErr
+ }
+ _objectidentifierValueErr := m.ObjectidentifierValue.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("objectidentifierValue"); popErr != nil {
+ return popErr
+ }
+ if _objectidentifierValueErr != nil {
+ return errors.Wrap(_objectidentifierValueErr, "Error serializing 'objectidentifierValue' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetPriorityValueObjectidentifier"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetPriorityValueObjectidentifier) 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/BACnetPriorityValueOctetString.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityValueOctetString.go
new file mode 100644
index 0000000000..8431bd0dd7
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityValueOctetString.go
@@ -0,0 +1,202 @@
+/*
+ * 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.
+
+// BACnetPriorityValueOctetString is the data-structure of this message
+type BACnetPriorityValueOctetString struct {
+ *BACnetPriorityValue
+ OctetStringValue *BACnetApplicationTagOctetString
+
+ // Arguments.
+ ObjectType BACnetObjectType
+}
+
+// IBACnetPriorityValueOctetString is the corresponding interface of BACnetPriorityValueOctetString
+type IBACnetPriorityValueOctetString interface {
+ IBACnetPriorityValue
+ // GetOctetStringValue returns OctetStringValue (property field)
+ GetOctetStringValue() *BACnetApplicationTagOctetString
+ // 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 *BACnetPriorityValueOctetString) InitializeParent(parent *BACnetPriorityValue, peekedTagHeader *BACnetTagHeader) {
+ m.BACnetPriorityValue.PeekedTagHeader = peekedTagHeader
+}
+
+func (m *BACnetPriorityValueOctetString) GetParent() *BACnetPriorityValue {
+ return m.BACnetPriorityValue
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetPriorityValueOctetString) GetOctetStringValue() *BACnetApplicationTagOctetString {
+ return m.OctetStringValue
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetPriorityValueOctetString factory function for BACnetPriorityValueOctetString
+func NewBACnetPriorityValueOctetString(octetStringValue *BACnetApplicationTagOctetString, peekedTagHeader *BACnetTagHeader, objectType BACnetObjectType) *BACnetPriorityValueOctetString {
+ _result := &BACnetPriorityValueOctetString{
+ OctetStringValue: octetStringValue,
+ BACnetPriorityValue: NewBACnetPriorityValue(peekedTagHeader, objectType),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetPriorityValueOctetString(structType interface{}) *BACnetPriorityValueOctetString {
+ if casted, ok := structType.(BACnetPriorityValueOctetString); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetPriorityValueOctetString); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetPriorityValue); ok {
+ return CastBACnetPriorityValueOctetString(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetPriorityValue); ok {
+ return CastBACnetPriorityValueOctetString(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetPriorityValueOctetString) GetTypeName() string {
+ return "BACnetPriorityValueOctetString"
+}
+
+func (m *BACnetPriorityValueOctetString) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetPriorityValueOctetString) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (octetStringValue)
+ lengthInBits += m.OctetStringValue.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetPriorityValueOctetString) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetPriorityValueOctetStringParse(readBuffer utils.ReadBuffer, objectType BACnetObjectType) (*BACnetPriorityValueOctetString, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetPriorityValueOctetString"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (octetStringValue)
+ if pullErr := readBuffer.PullContext("octetStringValue"); pullErr != nil {
+ return nil, pullErr
+ }
+ _octetStringValue, _octetStringValueErr := BACnetApplicationTagParse(readBuffer)
+ if _octetStringValueErr != nil {
+ return nil, errors.Wrap(_octetStringValueErr, "Error parsing 'octetStringValue' field")
+ }
+ octetStringValue := CastBACnetApplicationTagOctetString(_octetStringValue)
+ if closeErr := readBuffer.CloseContext("octetStringValue"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetPriorityValueOctetString"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetPriorityValueOctetString{
+ OctetStringValue: CastBACnetApplicationTagOctetString(octetStringValue),
+ BACnetPriorityValue: &BACnetPriorityValue{},
+ }
+ _child.BACnetPriorityValue.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetPriorityValueOctetString) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetPriorityValueOctetString"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (octetStringValue)
+ if pushErr := writeBuffer.PushContext("octetStringValue"); pushErr != nil {
+ return pushErr
+ }
+ _octetStringValueErr := m.OctetStringValue.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("octetStringValue"); popErr != nil {
+ return popErr
+ }
+ if _octetStringValueErr != nil {
+ return errors.Wrap(_octetStringValueErr, "Error serializing 'octetStringValue' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetPriorityValueOctetString"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetPriorityValueOctetString) 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/BACnetPriorityValueReal.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityValueReal.go
new file mode 100644
index 0000000000..7b36bc66cd
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityValueReal.go
@@ -0,0 +1,202 @@
+/*
+ * 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.
+
+// BACnetPriorityValueReal is the data-structure of this message
+type BACnetPriorityValueReal struct {
+ *BACnetPriorityValue
+ RealValue *BACnetApplicationTagReal
+
+ // Arguments.
+ ObjectType BACnetObjectType
+}
+
+// IBACnetPriorityValueReal is the corresponding interface of BACnetPriorityValueReal
+type IBACnetPriorityValueReal interface {
+ IBACnetPriorityValue
+ // GetRealValue returns RealValue (property field)
+ GetRealValue() *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 *BACnetPriorityValueReal) InitializeParent(parent *BACnetPriorityValue, peekedTagHeader *BACnetTagHeader) {
+ m.BACnetPriorityValue.PeekedTagHeader = peekedTagHeader
+}
+
+func (m *BACnetPriorityValueReal) GetParent() *BACnetPriorityValue {
+ return m.BACnetPriorityValue
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetPriorityValueReal) GetRealValue() *BACnetApplicationTagReal {
+ return m.RealValue
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetPriorityValueReal factory function for BACnetPriorityValueReal
+func NewBACnetPriorityValueReal(realValue *BACnetApplicationTagReal, peekedTagHeader *BACnetTagHeader, objectType BACnetObjectType) *BACnetPriorityValueReal {
+ _result := &BACnetPriorityValueReal{
+ RealValue: realValue,
+ BACnetPriorityValue: NewBACnetPriorityValue(peekedTagHeader, objectType),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetPriorityValueReal(structType interface{}) *BACnetPriorityValueReal {
+ if casted, ok := structType.(BACnetPriorityValueReal); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetPriorityValueReal); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetPriorityValue); ok {
+ return CastBACnetPriorityValueReal(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetPriorityValue); ok {
+ return CastBACnetPriorityValueReal(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetPriorityValueReal) GetTypeName() string {
+ return "BACnetPriorityValueReal"
+}
+
+func (m *BACnetPriorityValueReal) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetPriorityValueReal) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (realValue)
+ lengthInBits += m.RealValue.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetPriorityValueReal) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetPriorityValueRealParse(readBuffer utils.ReadBuffer, objectType BACnetObjectType) (*BACnetPriorityValueReal, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetPriorityValueReal"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (realValue)
+ if pullErr := readBuffer.PullContext("realValue"); pullErr != nil {
+ return nil, pullErr
+ }
+ _realValue, _realValueErr := BACnetApplicationTagParse(readBuffer)
+ if _realValueErr != nil {
+ return nil, errors.Wrap(_realValueErr, "Error parsing 'realValue' field")
+ }
+ realValue := CastBACnetApplicationTagReal(_realValue)
+ if closeErr := readBuffer.CloseContext("realValue"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetPriorityValueReal"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetPriorityValueReal{
+ RealValue: CastBACnetApplicationTagReal(realValue),
+ BACnetPriorityValue: &BACnetPriorityValue{},
+ }
+ _child.BACnetPriorityValue.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetPriorityValueReal) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetPriorityValueReal"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (realValue)
+ if pushErr := writeBuffer.PushContext("realValue"); pushErr != nil {
+ return pushErr
+ }
+ _realValueErr := m.RealValue.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("realValue"); popErr != nil {
+ return popErr
+ }
+ if _realValueErr != nil {
+ return errors.Wrap(_realValueErr, "Error serializing 'realValue' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetPriorityValueReal"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetPriorityValueReal) 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/BACnetPriorityValueTime.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityValueTime.go
new file mode 100644
index 0000000000..eb6f4b6324
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityValueTime.go
@@ -0,0 +1,202 @@
+/*
+ * 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.
+
+// BACnetPriorityValueTime is the data-structure of this message
+type BACnetPriorityValueTime struct {
+ *BACnetPriorityValue
+ TimeValue *BACnetApplicationTagTime
+
+ // Arguments.
+ ObjectType BACnetObjectType
+}
+
+// IBACnetPriorityValueTime is the corresponding interface of BACnetPriorityValueTime
+type IBACnetPriorityValueTime interface {
+ IBACnetPriorityValue
+ // GetTimeValue returns TimeValue (property field)
+ GetTimeValue() *BACnetApplicationTagTime
+ // 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 *BACnetPriorityValueTime) InitializeParent(parent *BACnetPriorityValue, peekedTagHeader *BACnetTagHeader) {
+ m.BACnetPriorityValue.PeekedTagHeader = peekedTagHeader
+}
+
+func (m *BACnetPriorityValueTime) GetParent() *BACnetPriorityValue {
+ return m.BACnetPriorityValue
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetPriorityValueTime) GetTimeValue() *BACnetApplicationTagTime {
+ return m.TimeValue
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetPriorityValueTime factory function for BACnetPriorityValueTime
+func NewBACnetPriorityValueTime(timeValue *BACnetApplicationTagTime, peekedTagHeader *BACnetTagHeader, objectType BACnetObjectType) *BACnetPriorityValueTime {
+ _result := &BACnetPriorityValueTime{
+ TimeValue: timeValue,
+ BACnetPriorityValue: NewBACnetPriorityValue(peekedTagHeader, objectType),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetPriorityValueTime(structType interface{}) *BACnetPriorityValueTime {
+ if casted, ok := structType.(BACnetPriorityValueTime); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetPriorityValueTime); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetPriorityValue); ok {
+ return CastBACnetPriorityValueTime(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetPriorityValue); ok {
+ return CastBACnetPriorityValueTime(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetPriorityValueTime) GetTypeName() string {
+ return "BACnetPriorityValueTime"
+}
+
+func (m *BACnetPriorityValueTime) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetPriorityValueTime) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (timeValue)
+ lengthInBits += m.TimeValue.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetPriorityValueTime) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetPriorityValueTimeParse(readBuffer utils.ReadBuffer, objectType BACnetObjectType) (*BACnetPriorityValueTime, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetPriorityValueTime"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (timeValue)
+ if pullErr := readBuffer.PullContext("timeValue"); pullErr != nil {
+ return nil, pullErr
+ }
+ _timeValue, _timeValueErr := BACnetApplicationTagParse(readBuffer)
+ if _timeValueErr != nil {
+ return nil, errors.Wrap(_timeValueErr, "Error parsing 'timeValue' field")
+ }
+ timeValue := CastBACnetApplicationTagTime(_timeValue)
+ if closeErr := readBuffer.CloseContext("timeValue"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetPriorityValueTime"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetPriorityValueTime{
+ TimeValue: CastBACnetApplicationTagTime(timeValue),
+ BACnetPriorityValue: &BACnetPriorityValue{},
+ }
+ _child.BACnetPriorityValue.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetPriorityValueTime) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetPriorityValueTime"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (timeValue)
+ if pushErr := writeBuffer.PushContext("timeValue"); pushErr != nil {
+ return pushErr
+ }
+ _timeValueErr := m.TimeValue.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("timeValue"); popErr != nil {
+ return popErr
+ }
+ if _timeValueErr != nil {
+ return errors.Wrap(_timeValueErr, "Error serializing 'timeValue' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetPriorityValueTime"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetPriorityValueTime) 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/BACnetPriorityValueUnsigned.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityValueUnsigned.go
new file mode 100644
index 0000000000..2b48702d2c
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetPriorityValueUnsigned.go
@@ -0,0 +1,202 @@
+/*
+ * 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.
+
+// BACnetPriorityValueUnsigned is the data-structure of this message
+type BACnetPriorityValueUnsigned struct {
+ *BACnetPriorityValue
+ UnsignedValue *BACnetApplicationTagUnsignedInteger
+
+ // Arguments.
+ ObjectType BACnetObjectType
+}
+
+// IBACnetPriorityValueUnsigned is the corresponding interface of BACnetPriorityValueUnsigned
+type IBACnetPriorityValueUnsigned interface {
+ IBACnetPriorityValue
+ // GetUnsignedValue returns UnsignedValue (property field)
+ GetUnsignedValue() *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 *BACnetPriorityValueUnsigned) InitializeParent(parent *BACnetPriorityValue, peekedTagHeader *BACnetTagHeader) {
+ m.BACnetPriorityValue.PeekedTagHeader = peekedTagHeader
+}
+
+func (m *BACnetPriorityValueUnsigned) GetParent() *BACnetPriorityValue {
+ return m.BACnetPriorityValue
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetPriorityValueUnsigned) GetUnsignedValue() *BACnetApplicationTagUnsignedInteger {
+ return m.UnsignedValue
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetPriorityValueUnsigned factory function for BACnetPriorityValueUnsigned
+func NewBACnetPriorityValueUnsigned(unsignedValue *BACnetApplicationTagUnsignedInteger, peekedTagHeader *BACnetTagHeader, objectType BACnetObjectType) *BACnetPriorityValueUnsigned {
+ _result := &BACnetPriorityValueUnsigned{
+ UnsignedValue: unsignedValue,
+ BACnetPriorityValue: NewBACnetPriorityValue(peekedTagHeader, objectType),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetPriorityValueUnsigned(structType interface{}) *BACnetPriorityValueUnsigned {
+ if casted, ok := structType.(BACnetPriorityValueUnsigned); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetPriorityValueUnsigned); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetPriorityValue); ok {
+ return CastBACnetPriorityValueUnsigned(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetPriorityValue); ok {
+ return CastBACnetPriorityValueUnsigned(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetPriorityValueUnsigned) GetTypeName() string {
+ return "BACnetPriorityValueUnsigned"
+}
+
+func (m *BACnetPriorityValueUnsigned) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetPriorityValueUnsigned) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (unsignedValue)
+ lengthInBits += m.UnsignedValue.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetPriorityValueUnsigned) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetPriorityValueUnsignedParse(readBuffer utils.ReadBuffer, objectType BACnetObjectType) (*BACnetPriorityValueUnsigned, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetPriorityValueUnsigned"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (unsignedValue)
+ if pullErr := readBuffer.PullContext("unsignedValue"); pullErr != nil {
+ return nil, pullErr
+ }
+ _unsignedValue, _unsignedValueErr := BACnetApplicationTagParse(readBuffer)
+ if _unsignedValueErr != nil {
+ return nil, errors.Wrap(_unsignedValueErr, "Error parsing 'unsignedValue' field")
+ }
+ unsignedValue := CastBACnetApplicationTagUnsignedInteger(_unsignedValue)
+ if closeErr := readBuffer.CloseContext("unsignedValue"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetPriorityValueUnsigned"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetPriorityValueUnsigned{
+ UnsignedValue: CastBACnetApplicationTagUnsignedInteger(unsignedValue),
+ BACnetPriorityValue: &BACnetPriorityValue{},
+ }
+ _child.BACnetPriorityValue.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetPriorityValueUnsigned) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetPriorityValueUnsigned"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (unsignedValue)
+ if pushErr := writeBuffer.PushContext("unsignedValue"); pushErr != nil {
+ return pushErr
+ }
+ _unsignedValueErr := m.UnsignedValue.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("unsignedValue"); popErr != nil {
+ return popErr
+ }
+ if _unsignedValueErr != nil {
+ return errors.Wrap(_unsignedValueErr, "Error serializing 'unsignedValue' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetPriorityValueUnsigned"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetPriorityValueUnsigned) 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/plc4j/drivers/bacnet/src/test/java/org/apache/plc4x/java/bacnetip/RandomPackagesTest.java b/plc4j/drivers/bacnet/src/test/java/org/apache/plc4x/java/bacnetip/RandomPackagesTest.java
index f16f135a0f..e19482373e 100644
--- a/plc4j/drivers/bacnet/src/test/java/org/apache/plc4x/java/bacnetip/RandomPackagesTest.java
+++ b/plc4j/drivers/bacnet/src/test/java/org/apache/plc4x/java/bacnetip/RandomPackagesTest.java
@@ -448,10 +448,23 @@ public class RandomPackagesTest {
assertEquals(BACnetObjectType.ANALOG_OUTPUT, baCnetServiceAckReadProperty.getObjectIdentifier().getObjectType());
assertEquals(0, baCnetServiceAckReadProperty.getObjectIdentifier().getInstanceNumber());
assertEquals(BACnetPropertyIdentifier.PRIORITY_ARRAY, baCnetServiceAckReadProperty.getPropertyIdentifier().getValue());
- /* FIXME: we get now a bunch of tags here (Priority Array)
- BACnetPropertyValuePriorityValue baCnetPropertyValuePriorityValue = (BACnetPropertyValuePriorityValue) ((BACnetConstructedDataUnspecified)baCnetServiceAckReadProperty.getValues()).getData();
- assertArrayEquals(new byte[]{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, baCnetPropertyValuePriorityValue.getValues());
- */
+ BACnetConstructedDataPriorityArray priorityArray = (BACnetConstructedDataPriorityArray) baCnetServiceAckReadProperty.getValues();
+ assertEquals(BACnetPriorityValueNull.class,priorityArray.getPriorityArray().getPriorityValue01().getClass());
+ assertEquals(BACnetPriorityValueNull.class,priorityArray.getPriorityArray().getPriorityValue02().getClass());
+ assertEquals(BACnetPriorityValueNull.class,priorityArray.getPriorityArray().getPriorityValue03().getClass());
+ assertEquals(BACnetPriorityValueNull.class,priorityArray.getPriorityArray().getPriorityValue04().getClass());
+ assertEquals(BACnetPriorityValueNull.class,priorityArray.getPriorityArray().getPriorityValue05().getClass());
+ assertEquals(BACnetPriorityValueNull.class,priorityArray.getPriorityArray().getPriorityValue06().getClass());
+ assertEquals(BACnetPriorityValueNull.class,priorityArray.getPriorityArray().getPriorityValue07().getClass());
+ assertEquals(BACnetPriorityValueNull.class,priorityArray.getPriorityArray().getPriorityValue08().getClass());
+ assertEquals(BACnetPriorityValueNull.class,priorityArray.getPriorityArray().getPriorityValue09().getClass());
+ assertEquals(BACnetPriorityValueNull.class,priorityArray.getPriorityArray().getPriorityValue10().getClass());
+ assertEquals(BACnetPriorityValueNull.class,priorityArray.getPriorityArray().getPriorityValue11().getClass());
+ assertEquals(BACnetPriorityValueNull.class,priorityArray.getPriorityArray().getPriorityValue12().getClass());
+ assertEquals(BACnetPriorityValueNull.class,priorityArray.getPriorityArray().getPriorityValue13().getClass());
+ assertEquals(BACnetPriorityValueNull.class,priorityArray.getPriorityArray().getPriorityValue14().getClass());
+ assertEquals(BACnetPriorityValueNull.class,priorityArray.getPriorityArray().getPriorityValue15().getClass());
+ assertEquals(BACnetPriorityValueNull.class,priorityArray.getPriorityArray().getPriorityValue16().getClass());
}),
DynamicTest.dynamicTest("No. 9 - BACnet Virtual Link Control BVLC Function Register-Foreign-Device",
() -> {
diff --git a/protocols/bacnetip/src/main/resources/protocols/bacnetip/bacnetip.mspec b/protocols/bacnetip/src/main/resources/protocols/bacnetip/bacnetip.mspec
index 68e87d38f5..cad0a1d9b0 100644
--- a/protocols/bacnetip/src/main/resources/protocols/bacnetip/bacnetip.mspec
+++ b/protocols/bacnetip/src/main/resources/protocols/bacnetip/bacnetip.mspec
@@ -1836,13 +1836,13 @@
objectIdentifier ]
[simple BACnetPropertyIdentifierTagged('2', 'TagClass.CONTEXT_SPECIFIC_TAGS')
propertyIdentifier ]
- [optional BACnetContextTagUnsignedInteger('3', 'BACnetDataType.UNSIGNED_INTEGER')
+ [optional BACnetContextTagUnsignedInteger('3', 'BACnetDataType.UNSIGNED_INTEGER')
arrayIndex ]
- [optional BACnetConstructedData('4', 'objectIdentifier.objectType', 'propertyIdentifier.value')
+ [optional BACnetConstructedData('4', 'objectIdentifier.objectType', 'propertyIdentifier.value')
propertyValue ]
- [optional BACnetContextTagUnsignedInteger('5', 'BACnetDataType.UNSIGNED_INTEGER')
+ [optional BACnetContextTagUnsignedInteger('5', 'BACnetDataType.UNSIGNED_INTEGER')
priority ]
- [optional BACnetContextTagBoolean('6', 'BACnetDataType.BOOLEAN')
+ [optional BACnetContextTagBoolean('6', 'BACnetDataType.BOOLEAN')
postDelay ]
[simple BACnetContextTagBoolean('7', 'BACnetDataType.BOOLEAN')
quitOnFailure ]
@@ -1850,6 +1850,94 @@
writeSuccessful ]
]
+[type BACnetPriorityArray(BACnetObjectType objectType)
+ [simple BACnetPriorityValue('objectType') priorityValue01 ]
+ [simple BACnetPriorityValue('objectType') priorityValue02 ]
+ [simple BACnetPriorityValue('objectType') priorityValue03 ]
+ [simple BACnetPriorityValue('objectType') priorityValue04 ]
+ [simple BACnetPriorityValue('objectType') priorityValue05 ]
+ [simple BACnetPriorityValue('objectType') priorityValue06 ]
+ [simple BACnetPriorityValue('objectType') priorityValue07 ]
+ [simple BACnetPriorityValue('objectType') priorityValue08 ]
+ [simple BACnetPriorityValue('objectType') priorityValue09 ]
+ [simple BACnetPriorityValue('objectType') priorityValue10 ]
+ [simple BACnetPriorityValue('objectType') priorityValue11 ]
+ [simple BACnetPriorityValue('objectType') priorityValue12 ]
+ [simple BACnetPriorityValue('objectType') priorityValue13 ]
+ [simple BACnetPriorityValue('objectType') priorityValue14 ]
+ [simple BACnetPriorityValue('objectType') priorityValue15 ]
+ [simple BACnetPriorityValue('objectType') priorityValue16 ]
+]
+
+[type BACnetPriorityValue(BACnetObjectType objectType)
+ [peek BACnetTagHeader
+ peekedTagHeader ]
+ [virtual uint 8 peekedTagNumber 'peekedTagHeader.actualTagNumber' ]
+ [virtual bit peekedIsContextTag 'peekedTagHeader.tagClass == TagClass.CONTEXT_SPECIFIC_TAGS']
+ [typeSwitch peekedTagNumber, peekedIsContextTag
+ ['0x0', 'false' BACnetPriorityValueNull
+ [simple BACnetApplicationTagNull
+ nullValue ]
+ ]
+ ['0x4', 'false' BACnetPriorityValueReal
+ [simple BACnetApplicationTagReal
+ realValue ]
+ ]
+ ['0x9', 'false' BACnetPriorityValueEnumerated
+ [simple BACnetApplicationTagEnumerated
+ enumeratedValue ]
+ ]
+ ['0x2', 'false' BACnetPriorityValueUnsigned
+ [simple BACnetApplicationTagUnsignedInteger
+ unsignedValue ]
+ ]
+ ['0x1', 'false' BACnetPriorityValueBoolean
+ [simple BACnetApplicationTagBoolean
+ booleanValue ]
+ ]
+ ['0x3', 'false' BACnetPriorityValueInteger
+ [simple BACnetApplicationTagSignedInteger
+ integerValue ]
+ ]
+ ['0x5', 'false' BACnetPriorityValueDouble
+ [simple BACnetApplicationTagDouble
+ doubleValue ]
+ ]
+ ['0xB', 'false' BACnetPriorityValueTime
+ [simple BACnetApplicationTagTime
+ timeValue ]
+ ]
+ ['0x7', 'false' BACnetPriorityValueCharacterString
+ [simple BACnetApplicationTagCharacterString
+ characterStringValue ]
+ ]
+ ['0x6', 'false' BACnetPriorityValueOctetString
+ [simple BACnetApplicationTagOctetString
+ octetStringValue ]
+ ]
+ ['0x8', 'false' BACnetPriorityValueBitString
+ [simple BACnetApplicationTagBitString
+ bitStringValue ]
+ ]
+ ['0xA', 'false' BACnetPriorityValueDate
+ [simple BACnetApplicationTagDate
+ dateValue ]
+ ]
+ ['0xC', 'false' BACnetPriorityValueObjectidentifier
+ [simple BACnetApplicationTagObjectIdentifier
+ objectidentifierValue ]
+ ]
+ ['0', 'true' BACnetPriorityValueConstructedValue
+ [simple BACnetConstructedData('0', 'objectType', 'BACnetPropertyIdentifier.VENDOR_PROPRIETARY_VALUE')
+ constructedValue ]
+ ]
+ ['1', 'true' BACnetPriorityValueDateTime
+ [simple BACnetDateTimeEnclosed('1')
+ dateTimeValue ]
+ ]
+ ]
+]
+
[type BACnetPropertyStatesEnclosed(uint 8 tagNumber)
[simple BACnetOpeningTag('tagNumber')
openingTag ]
@@ -2808,7 +2896,9 @@
//[*, 'PRESCALE' BACnetConstructedDataPrescale [validation '1 == 2' "TODO: implement me PRESCALE BACnetConstructedDataPrescale"]]
//[*, 'PRESENT_VALUE' BACnetConstructedDataPresentValue [validation '1 == 2' "TODO: implement me PRESENT_VALUE BACnetConstructedDataPresentValue"]]
//[*, 'PRIORITY' BACnetConstructedDataPriority [validation '1 == 2' "TODO: implement me PRIORITY BACnetConstructedDataPriority"]]
- //[*, 'PRIORITY_ARRAY' BACnetConstructedDataPriorityArray [validation '1 == 2' "TODO: implement me PRIORITY_ARRAY BACnetConstructedDataPriorityArray"]]
+ [*, 'PRIORITY_ARRAY' BACnetConstructedDataPriorityArray
+ [simple BACnetPriorityArray('objectType') priorityArray ]
+ ]
//[*, 'PRIORITY_FOR_WRITING' BACnetConstructedDataPriorityForWriting [validation '1 == 2' "TODO: implement me PRIORITY_FOR_WRITING BACnetConstructedDataPriorityForWriting"]]
//[*, 'PROCESS_IDENTIFIER' BACnetConstructedDataProcessIdentifier [validation '1 == 2' "TODO: implement me PROCESS_IDENTIFIER BACnetConstructedDataProcessIdentifier"]]
//[*, 'PROCESS_IDENTIFIER_FILTER' BACnetConstructedDataProcessIdentifierFilter [validation '1 == 2' "TODO: implement me PROCESS_IDENTIFIER_FILTER BACnetConstructedDataProcessIdentifierFilter"]]
@@ -2820,7 +2910,7 @@
//[*, 'PROPERTY_LIST' BACnetConstructedDataPropertyList [validation '1 == 2' "TODO: implement me PROPERTY_LIST BACnetConstructedDataPropertyList"]]
//[*, 'PROPORTIONAL_CONSTANT' BACnetConstructedDataProportionalConstant [validation '1 == 2' "TODO: implement me PROPORTIONAL_CONSTANT BACnetConstructedDataProportionalConstant"]]
[*, 'PROPORTIONAL_CONSTANT_UNITS' BACnetConstructedDataProportionalConstantUnits
- [simple BACnetEngineeringUnitsTagged('0', 'TagClass.APPLICATION_TAGS') units ]
+ [simple BACnetEngineeringUnitsTagged('0', 'TagClass.APPLICATION_TAGS') units ]
//[*, 'PROTOCOL_LEVEL' BACnetConstructedDataProtocolLevel [validation '1 == 2' "TODO: implement me PROTOCOL_LEVEL BACnetConstructedDataProtocolLevel"]]
//[*, 'PROTOCOL_CONFORMANCE_CLASS' BACnetConstructedDataProtocolConformanceClass [validation '1 == 2' "TODO: implement me PROTOCOL_CONFORMANCE_CLASS BACnetConstructedDataProtocolConformanceClass"]]