You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@plc4x.apache.org by sr...@apache.org on 2022/06/03 09:32:01 UTC
[plc4x] branch develop updated: feat(bacnet): implemented several properties
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 e8ba2500bb feat(bacnet): implemented several properties
e8ba2500bb is described below
commit e8ba2500bbbfa8c834d309e820541e65635526ce
Author: Sebastian Rühl <sr...@apache.org>
AuthorDate: Fri Jun 3 11:31:54 2022 +0200
feat(bacnet): implemented several properties
- BBMD_ACCEPT_FD_REGISTRATIONS
- IP_DHCP_LEASE_TIME_REMAINING
- IPV6_DHCP_LEASE_TIME_REMAINING
- MANUAL_SLAVE_ADDRESS_BINDING
- MINIMUM_VALUE
- POSITIVE_ACCESS_RULES
- REPRESENTS
---
.../protocols/bacnetip/readwrite/ParserHelper.go | 18 ++
.../bacnetip/readwrite/XmlParserHelper.go | 20 ++
.../bacnetip/readwrite/model/BACnetAccessRule.go | 329 +++++++++++++++++++++
.../model/BACnetAccessRuleLocationSpecifier.go | 122 ++++++++
.../BACnetAccessRuleLocationSpecifierTagged.go | 197 ++++++++++++
.../model/BACnetAccessRuleTimeRangeSpecifier.go | 122 ++++++++
.../BACnetAccessRuleTimeRangeSpecifierTagged.go | 197 ++++++++++++
.../readwrite/model/BACnetAddressBinding.go | 195 ++++++++++++
.../readwrite/model/BACnetConstructedData.go | 14 +
...CnetConstructedDataBBMDAcceptFDRegistrations.go | 211 +++++++++++++
...ACnetConstructedDataIPDHCPLeaseTimeRemaining.go | 211 +++++++++++++
...netConstructedDataIPv6DHCPLeaseTimeRemaining.go | 211 +++++++++++++
...CnetConstructedDataManualSlaveAddressBinding.go | 226 ++++++++++++++
.../model/BACnetConstructedDataMinimumValue.go | 211 +++++++++++++
.../BACnetConstructedDataPositiveAccessRules.go | 226 ++++++++++++++
.../model/BACnetConstructedDataRepresents.go | 211 +++++++++++++
.../model/BACnetEventTransitionBitsApplication.go | 220 --------------
.../knxnetip/readwrite/model/KnxManufacturer.go | 40 ++-
.../protocols/bacnetip/bacnet-private-enums.mspec | 12 +
.../resources/protocols/bacnetip/bacnetip.mspec | 92 ++++--
.../bacnetip/ObjectPropertyDeDuplicationTest.java | 21 ++
21 files changed, 2848 insertions(+), 258 deletions(-)
diff --git a/plc4go/protocols/bacnetip/readwrite/ParserHelper.go b/plc4go/protocols/bacnetip/readwrite/ParserHelper.go
index 30e7e89230..ad1968bfe4 100644
--- a/plc4go/protocols/bacnetip/readwrite/ParserHelper.go
+++ b/plc4go/protocols/bacnetip/readwrite/ParserHelper.go
@@ -282,6 +282,13 @@ func (m BacnetipParserHelper) Parse(typeName string, arguments []string, io util
}
tagClass := model.TagClassByName(arguments[1])
return model.BACnetLiftCarDirectionTaggedParse(io, tagNumber, tagClass)
+ case "BACnetAccessRuleTimeRangeSpecifierTagged":
+ tagNumber, err := utils.StrToUint8(arguments[0])
+ if err != nil {
+ return nil, errors.Wrap(err, "Error parsing")
+ }
+ tagClass := model.TagClassByName(arguments[1])
+ return model.BACnetAccessRuleTimeRangeSpecifierTaggedParse(io, tagNumber, tagClass)
case "BACnetConfirmedServiceRequestConfirmedTextMessageMessageClass":
tagNumber, err := utils.StrToUint8(arguments[0])
if err != nil {
@@ -297,6 +304,8 @@ func (m BacnetipParserHelper) Parse(typeName string, arguments []string, io util
}
tagClass := model.TagClassByName(arguments[1])
return model.BACnetBackupStateTaggedParse(io, tagNumber, tagClass)
+ case "BACnetAddressBinding":
+ return model.BACnetAddressBindingParse(io)
case "ListOfCovNotificationsValue":
objectTypeArgument := model.BACnetObjectTypeByName(arguments[0])
return model.ListOfCovNotificationsValueParse(io, objectTypeArgument)
@@ -569,6 +578,13 @@ func (m BacnetipParserHelper) Parse(typeName string, arguments []string, io util
case "BACnetPriorityValue":
objectTypeArgument := model.BACnetObjectTypeByName(arguments[0])
return model.BACnetPriorityValueParse(io, objectTypeArgument)
+ case "BACnetAccessRuleLocationSpecifierTagged":
+ tagNumber, err := utils.StrToUint8(arguments[0])
+ if err != nil {
+ return nil, errors.Wrap(err, "Error parsing")
+ }
+ tagClass := model.TagClassByName(arguments[1])
+ return model.BACnetAccessRuleLocationSpecifierTaggedParse(io, tagNumber, tagClass)
case "BACnetMaintenanceTagged":
tagNumber, err := utils.StrToUint8(arguments[0])
if err != nil {
@@ -998,6 +1014,8 @@ func (m BacnetipParserHelper) Parse(typeName string, arguments []string, io util
return nil, errors.Wrap(err, "Error parsing")
}
return model.BACnetRecipientProcessEnclosedParse(io, tagNumber)
+ case "BACnetAccessRule":
+ return model.BACnetAccessRuleParse(io)
case "BACnetShedStateTagged":
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 dfd1c2ea73..b52264b7a9 100644
--- a/plc4go/protocols/bacnetip/readwrite/XmlParserHelper.go
+++ b/plc4go/protocols/bacnetip/readwrite/XmlParserHelper.go
@@ -326,6 +326,14 @@ func (m BacnetipXmlParserHelper) Parse(typeName string, xmlString string, parser
tagNumber := uint8(parsedUint0)
tagClass := model.TagClassByName(parserArguments[1])
return model.BACnetLiftCarDirectionTaggedParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)), tagNumber, tagClass)
+ case "BACnetAccessRuleTimeRangeSpecifierTagged":
+ parsedUint0, err := strconv.ParseUint(parserArguments[0], 10, 8)
+ if err != nil {
+ return nil, err
+ }
+ tagNumber := uint8(parsedUint0)
+ tagClass := model.TagClassByName(parserArguments[1])
+ return model.BACnetAccessRuleTimeRangeSpecifierTaggedParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)), tagNumber, tagClass)
case "BACnetConfirmedServiceRequestConfirmedTextMessageMessageClass":
parsedUint0, err := strconv.ParseUint(parserArguments[0], 10, 8)
if err != nil {
@@ -343,6 +351,8 @@ func (m BacnetipXmlParserHelper) Parse(typeName string, xmlString string, parser
tagNumber := uint8(parsedUint0)
tagClass := model.TagClassByName(parserArguments[1])
return model.BACnetBackupStateTaggedParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)), tagNumber, tagClass)
+ case "BACnetAddressBinding":
+ return model.BACnetAddressBindingParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
case "ListOfCovNotificationsValue":
objectTypeArgument := model.BACnetObjectTypeByName(parserArguments[0])
return model.ListOfCovNotificationsValueParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)), objectTypeArgument)
@@ -652,6 +662,14 @@ func (m BacnetipXmlParserHelper) Parse(typeName string, xmlString string, parser
case "BACnetPriorityValue":
objectTypeArgument := model.BACnetObjectTypeByName(parserArguments[0])
return model.BACnetPriorityValueParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)), objectTypeArgument)
+ case "BACnetAccessRuleLocationSpecifierTagged":
+ parsedUint0, err := strconv.ParseUint(parserArguments[0], 10, 8)
+ if err != nil {
+ return nil, err
+ }
+ tagNumber := uint8(parsedUint0)
+ tagClass := model.TagClassByName(parserArguments[1])
+ return model.BACnetAccessRuleLocationSpecifierTaggedParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)), tagNumber, tagClass)
case "BACnetMaintenanceTagged":
parsedUint0, err := strconv.ParseUint(parserArguments[0], 10, 8)
if err != nil {
@@ -1135,6 +1153,8 @@ func (m BacnetipXmlParserHelper) Parse(typeName string, xmlString string, parser
}
tagNumber := uint8(parsedUint0)
return model.BACnetRecipientProcessEnclosedParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)), tagNumber)
+ case "BACnetAccessRule":
+ return model.BACnetAccessRuleParse(utils.NewXmlReadBuffer(strings.NewReader(xmlString)))
case "BACnetShedStateTagged":
parsedUint0, err := strconv.ParseUint(parserArguments[0], 10, 8)
if err != nil {
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessRule.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessRule.go
new file mode 100644
index 0000000000..aecf8481c2
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessRule.go
@@ -0,0 +1,329 @@
+/*
+ * 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"
+ "io"
+)
+
+// Code generated by code-generation. DO NOT EDIT.
+
+// BACnetAccessRule is the data-structure of this message
+type BACnetAccessRule struct {
+ TimeRangeSpecifier *BACnetAccessRuleTimeRangeSpecifierTagged
+ TimeRange *BACnetDeviceObjectPropertyReferenceEnclosed
+ LocationSpecifier *BACnetAccessRuleLocationSpecifierTagged
+ Location *BACnetDeviceObjectReferenceEnclosed
+ Enable *BACnetContextTagBoolean
+}
+
+// IBACnetAccessRule is the corresponding interface of BACnetAccessRule
+type IBACnetAccessRule interface {
+ // GetTimeRangeSpecifier returns TimeRangeSpecifier (property field)
+ GetTimeRangeSpecifier() *BACnetAccessRuleTimeRangeSpecifierTagged
+ // GetTimeRange returns TimeRange (property field)
+ GetTimeRange() *BACnetDeviceObjectPropertyReferenceEnclosed
+ // GetLocationSpecifier returns LocationSpecifier (property field)
+ GetLocationSpecifier() *BACnetAccessRuleLocationSpecifierTagged
+ // GetLocation returns Location (property field)
+ GetLocation() *BACnetDeviceObjectReferenceEnclosed
+ // GetEnable returns Enable (property field)
+ GetEnable() *BACnetContextTagBoolean
+ // 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 *BACnetAccessRule) GetTimeRangeSpecifier() *BACnetAccessRuleTimeRangeSpecifierTagged {
+ return m.TimeRangeSpecifier
+}
+
+func (m *BACnetAccessRule) GetTimeRange() *BACnetDeviceObjectPropertyReferenceEnclosed {
+ return m.TimeRange
+}
+
+func (m *BACnetAccessRule) GetLocationSpecifier() *BACnetAccessRuleLocationSpecifierTagged {
+ return m.LocationSpecifier
+}
+
+func (m *BACnetAccessRule) GetLocation() *BACnetDeviceObjectReferenceEnclosed {
+ return m.Location
+}
+
+func (m *BACnetAccessRule) GetEnable() *BACnetContextTagBoolean {
+ return m.Enable
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetAccessRule factory function for BACnetAccessRule
+func NewBACnetAccessRule(timeRangeSpecifier *BACnetAccessRuleTimeRangeSpecifierTagged, timeRange *BACnetDeviceObjectPropertyReferenceEnclosed, locationSpecifier *BACnetAccessRuleLocationSpecifierTagged, location *BACnetDeviceObjectReferenceEnclosed, enable *BACnetContextTagBoolean) *BACnetAccessRule {
+ return &BACnetAccessRule{TimeRangeSpecifier: timeRangeSpecifier, TimeRange: timeRange, LocationSpecifier: locationSpecifier, Location: location, Enable: enable}
+}
+
+func CastBACnetAccessRule(structType interface{}) *BACnetAccessRule {
+ if casted, ok := structType.(BACnetAccessRule); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetAccessRule); ok {
+ return casted
+ }
+ return nil
+}
+
+func (m *BACnetAccessRule) GetTypeName() string {
+ return "BACnetAccessRule"
+}
+
+func (m *BACnetAccessRule) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetAccessRule) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(0)
+
+ // Simple field (timeRangeSpecifier)
+ lengthInBits += m.TimeRangeSpecifier.GetLengthInBits()
+
+ // Optional Field (timeRange)
+ if m.TimeRange != nil {
+ lengthInBits += (*m.TimeRange).GetLengthInBits()
+ }
+
+ // Simple field (locationSpecifier)
+ lengthInBits += m.LocationSpecifier.GetLengthInBits()
+
+ // Optional Field (location)
+ if m.Location != nil {
+ lengthInBits += (*m.Location).GetLengthInBits()
+ }
+
+ // Simple field (enable)
+ lengthInBits += m.Enable.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetAccessRule) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetAccessRuleParse(readBuffer utils.ReadBuffer) (*BACnetAccessRule, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetAccessRule"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (timeRangeSpecifier)
+ if pullErr := readBuffer.PullContext("timeRangeSpecifier"); pullErr != nil {
+ return nil, pullErr
+ }
+ _timeRangeSpecifier, _timeRangeSpecifierErr := BACnetAccessRuleTimeRangeSpecifierTaggedParse(readBuffer, uint8(uint8(0)), TagClass(TagClass_CONTEXT_SPECIFIC_TAGS))
+ if _timeRangeSpecifierErr != nil {
+ return nil, errors.Wrap(_timeRangeSpecifierErr, "Error parsing 'timeRangeSpecifier' field")
+ }
+ timeRangeSpecifier := CastBACnetAccessRuleTimeRangeSpecifierTagged(_timeRangeSpecifier)
+ if closeErr := readBuffer.CloseContext("timeRangeSpecifier"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Optional Field (timeRange) (Can be skipped, if a given expression evaluates to false)
+ var timeRange *BACnetDeviceObjectPropertyReferenceEnclosed = nil
+ if bool((timeRangeSpecifier) != (nil)) {
+ currentPos = positionAware.GetPos()
+ if pullErr := readBuffer.PullContext("timeRange"); pullErr != nil {
+ return nil, pullErr
+ }
+ _val, _err := BACnetDeviceObjectPropertyReferenceEnclosedParse(readBuffer, uint8(1))
+ switch {
+ case errors.Is(_err, utils.ParseAssertError{}) || errors.Is(_err, io.EOF):
+ readBuffer.Reset(currentPos)
+ case _err != nil:
+ return nil, errors.Wrap(_err, "Error parsing 'timeRange' field")
+ default:
+ timeRange = CastBACnetDeviceObjectPropertyReferenceEnclosed(_val)
+ if closeErr := readBuffer.CloseContext("timeRange"); closeErr != nil {
+ return nil, closeErr
+ }
+ }
+ }
+
+ // Simple Field (locationSpecifier)
+ if pullErr := readBuffer.PullContext("locationSpecifier"); pullErr != nil {
+ return nil, pullErr
+ }
+ _locationSpecifier, _locationSpecifierErr := BACnetAccessRuleLocationSpecifierTaggedParse(readBuffer, uint8(uint8(2)), TagClass(TagClass_CONTEXT_SPECIFIC_TAGS))
+ if _locationSpecifierErr != nil {
+ return nil, errors.Wrap(_locationSpecifierErr, "Error parsing 'locationSpecifier' field")
+ }
+ locationSpecifier := CastBACnetAccessRuleLocationSpecifierTagged(_locationSpecifier)
+ if closeErr := readBuffer.CloseContext("locationSpecifier"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Optional Field (location) (Can be skipped, if a given expression evaluates to false)
+ var location *BACnetDeviceObjectReferenceEnclosed = nil
+ if bool((locationSpecifier) != (nil)) {
+ currentPos = positionAware.GetPos()
+ if pullErr := readBuffer.PullContext("location"); pullErr != nil {
+ return nil, pullErr
+ }
+ _val, _err := BACnetDeviceObjectReferenceEnclosedParse(readBuffer, uint8(3))
+ switch {
+ case errors.Is(_err, utils.ParseAssertError{}) || errors.Is(_err, io.EOF):
+ readBuffer.Reset(currentPos)
+ case _err != nil:
+ return nil, errors.Wrap(_err, "Error parsing 'location' field")
+ default:
+ location = CastBACnetDeviceObjectReferenceEnclosed(_val)
+ if closeErr := readBuffer.CloseContext("location"); closeErr != nil {
+ return nil, closeErr
+ }
+ }
+ }
+
+ // Simple Field (enable)
+ if pullErr := readBuffer.PullContext("enable"); pullErr != nil {
+ return nil, pullErr
+ }
+ _enable, _enableErr := BACnetContextTagParse(readBuffer, uint8(uint8(4)), BACnetDataType(BACnetDataType_BOOLEAN))
+ if _enableErr != nil {
+ return nil, errors.Wrap(_enableErr, "Error parsing 'enable' field")
+ }
+ enable := CastBACnetContextTagBoolean(_enable)
+ if closeErr := readBuffer.CloseContext("enable"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetAccessRule"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create the instance
+ return NewBACnetAccessRule(timeRangeSpecifier, timeRange, locationSpecifier, location, enable), nil
+}
+
+func (m *BACnetAccessRule) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ if pushErr := writeBuffer.PushContext("BACnetAccessRule"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (timeRangeSpecifier)
+ if pushErr := writeBuffer.PushContext("timeRangeSpecifier"); pushErr != nil {
+ return pushErr
+ }
+ _timeRangeSpecifierErr := m.TimeRangeSpecifier.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("timeRangeSpecifier"); popErr != nil {
+ return popErr
+ }
+ if _timeRangeSpecifierErr != nil {
+ return errors.Wrap(_timeRangeSpecifierErr, "Error serializing 'timeRangeSpecifier' field")
+ }
+
+ // Optional Field (timeRange) (Can be skipped, if the value is null)
+ var timeRange *BACnetDeviceObjectPropertyReferenceEnclosed = nil
+ if m.TimeRange != nil {
+ if pushErr := writeBuffer.PushContext("timeRange"); pushErr != nil {
+ return pushErr
+ }
+ timeRange = m.TimeRange
+ _timeRangeErr := timeRange.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("timeRange"); popErr != nil {
+ return popErr
+ }
+ if _timeRangeErr != nil {
+ return errors.Wrap(_timeRangeErr, "Error serializing 'timeRange' field")
+ }
+ }
+
+ // Simple Field (locationSpecifier)
+ if pushErr := writeBuffer.PushContext("locationSpecifier"); pushErr != nil {
+ return pushErr
+ }
+ _locationSpecifierErr := m.LocationSpecifier.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("locationSpecifier"); popErr != nil {
+ return popErr
+ }
+ if _locationSpecifierErr != nil {
+ return errors.Wrap(_locationSpecifierErr, "Error serializing 'locationSpecifier' field")
+ }
+
+ // Optional Field (location) (Can be skipped, if the value is null)
+ var location *BACnetDeviceObjectReferenceEnclosed = nil
+ if m.Location != nil {
+ if pushErr := writeBuffer.PushContext("location"); pushErr != nil {
+ return pushErr
+ }
+ location = m.Location
+ _locationErr := location.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("location"); popErr != nil {
+ return popErr
+ }
+ if _locationErr != nil {
+ return errors.Wrap(_locationErr, "Error serializing 'location' field")
+ }
+ }
+
+ // Simple Field (enable)
+ if pushErr := writeBuffer.PushContext("enable"); pushErr != nil {
+ return pushErr
+ }
+ _enableErr := m.Enable.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("enable"); popErr != nil {
+ return popErr
+ }
+ if _enableErr != nil {
+ return errors.Wrap(_enableErr, "Error serializing 'enable' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetAccessRule"); popErr != nil {
+ return popErr
+ }
+ return nil
+}
+
+func (m *BACnetAccessRule) 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/BACnetAccessRuleLocationSpecifier.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessRuleLocationSpecifier.go
new file mode 100644
index 0000000000..a5c955d51d
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessRuleLocationSpecifier.go
@@ -0,0 +1,122 @@
+/*
+ * 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.
+
+// BACnetAccessRuleLocationSpecifier is an enum
+type BACnetAccessRuleLocationSpecifier uint8
+
+type IBACnetAccessRuleLocationSpecifier interface {
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+const (
+ BACnetAccessRuleLocationSpecifier_SPECIFIED BACnetAccessRuleLocationSpecifier = 0
+ BACnetAccessRuleLocationSpecifier_ALL BACnetAccessRuleLocationSpecifier = 1
+)
+
+var BACnetAccessRuleLocationSpecifierValues []BACnetAccessRuleLocationSpecifier
+
+func init() {
+ _ = errors.New
+ BACnetAccessRuleLocationSpecifierValues = []BACnetAccessRuleLocationSpecifier{
+ BACnetAccessRuleLocationSpecifier_SPECIFIED,
+ BACnetAccessRuleLocationSpecifier_ALL,
+ }
+}
+
+func BACnetAccessRuleLocationSpecifierByValue(value uint8) BACnetAccessRuleLocationSpecifier {
+ switch value {
+ case 0:
+ return BACnetAccessRuleLocationSpecifier_SPECIFIED
+ case 1:
+ return BACnetAccessRuleLocationSpecifier_ALL
+ }
+ return 0
+}
+
+func BACnetAccessRuleLocationSpecifierByName(value string) BACnetAccessRuleLocationSpecifier {
+ switch value {
+ case "SPECIFIED":
+ return BACnetAccessRuleLocationSpecifier_SPECIFIED
+ case "ALL":
+ return BACnetAccessRuleLocationSpecifier_ALL
+ }
+ return 0
+}
+
+func BACnetAccessRuleLocationSpecifierKnows(value uint8) bool {
+ for _, typeValue := range BACnetAccessRuleLocationSpecifierValues {
+ if uint8(typeValue) == value {
+ return true
+ }
+ }
+ return false
+}
+
+func CastBACnetAccessRuleLocationSpecifier(structType interface{}) BACnetAccessRuleLocationSpecifier {
+ castFunc := func(typ interface{}) BACnetAccessRuleLocationSpecifier {
+ if sBACnetAccessRuleLocationSpecifier, ok := typ.(BACnetAccessRuleLocationSpecifier); ok {
+ return sBACnetAccessRuleLocationSpecifier
+ }
+ return 0
+ }
+ return castFunc(structType)
+}
+
+func (m BACnetAccessRuleLocationSpecifier) GetLengthInBits() uint16 {
+ return 8
+}
+
+func (m BACnetAccessRuleLocationSpecifier) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetAccessRuleLocationSpecifierParse(readBuffer utils.ReadBuffer) (BACnetAccessRuleLocationSpecifier, error) {
+ val, err := readBuffer.ReadUint8("BACnetAccessRuleLocationSpecifier", 8)
+ if err != nil {
+ return 0, nil
+ }
+ return BACnetAccessRuleLocationSpecifierByValue(val), nil
+}
+
+func (e BACnetAccessRuleLocationSpecifier) Serialize(writeBuffer utils.WriteBuffer) error {
+ return writeBuffer.WriteUint8("BACnetAccessRuleLocationSpecifier", 8, uint8(e), utils.WithAdditionalStringRepresentation(e.name()))
+}
+
+func (e BACnetAccessRuleLocationSpecifier) name() string {
+ switch e {
+ case BACnetAccessRuleLocationSpecifier_SPECIFIED:
+ return "SPECIFIED"
+ case BACnetAccessRuleLocationSpecifier_ALL:
+ return "ALL"
+ }
+ return ""
+}
+
+func (e BACnetAccessRuleLocationSpecifier) String() string {
+ return e.name()
+}
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessRuleLocationSpecifierTagged.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessRuleLocationSpecifierTagged.go
new file mode 100644
index 0000000000..1cc5802234
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessRuleLocationSpecifierTagged.go
@@ -0,0 +1,197 @@
+/*
+ * 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.
+
+// BACnetAccessRuleLocationSpecifierTagged is the data-structure of this message
+type BACnetAccessRuleLocationSpecifierTagged struct {
+ Header *BACnetTagHeader
+ Value BACnetAccessRuleLocationSpecifier
+
+ // Arguments.
+ TagNumber uint8
+ TagClass TagClass
+}
+
+// IBACnetAccessRuleLocationSpecifierTagged is the corresponding interface of BACnetAccessRuleLocationSpecifierTagged
+type IBACnetAccessRuleLocationSpecifierTagged interface {
+ // GetHeader returns Header (property field)
+ GetHeader() *BACnetTagHeader
+ // GetValue returns Value (property field)
+ GetValue() BACnetAccessRuleLocationSpecifier
+ // 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 *BACnetAccessRuleLocationSpecifierTagged) GetHeader() *BACnetTagHeader {
+ return m.Header
+}
+
+func (m *BACnetAccessRuleLocationSpecifierTagged) GetValue() BACnetAccessRuleLocationSpecifier {
+ return m.Value
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetAccessRuleLocationSpecifierTagged factory function for BACnetAccessRuleLocationSpecifierTagged
+func NewBACnetAccessRuleLocationSpecifierTagged(header *BACnetTagHeader, value BACnetAccessRuleLocationSpecifier, tagNumber uint8, tagClass TagClass) *BACnetAccessRuleLocationSpecifierTagged {
+ return &BACnetAccessRuleLocationSpecifierTagged{Header: header, Value: value, TagNumber: tagNumber, TagClass: tagClass}
+}
+
+func CastBACnetAccessRuleLocationSpecifierTagged(structType interface{}) *BACnetAccessRuleLocationSpecifierTagged {
+ if casted, ok := structType.(BACnetAccessRuleLocationSpecifierTagged); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetAccessRuleLocationSpecifierTagged); ok {
+ return casted
+ }
+ return nil
+}
+
+func (m *BACnetAccessRuleLocationSpecifierTagged) GetTypeName() string {
+ return "BACnetAccessRuleLocationSpecifierTagged"
+}
+
+func (m *BACnetAccessRuleLocationSpecifierTagged) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetAccessRuleLocationSpecifierTagged) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(0)
+
+ // Simple field (header)
+ lengthInBits += m.Header.GetLengthInBits()
+
+ // Manual Field (value)
+ lengthInBits += uint16(int32(m.GetHeader().GetActualLength()) * int32(int32(8)))
+
+ return lengthInBits
+}
+
+func (m *BACnetAccessRuleLocationSpecifierTagged) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetAccessRuleLocationSpecifierTaggedParse(readBuffer utils.ReadBuffer, tagNumber uint8, tagClass TagClass) (*BACnetAccessRuleLocationSpecifierTagged, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetAccessRuleLocationSpecifierTagged"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (header)
+ if pullErr := readBuffer.PullContext("header"); pullErr != nil {
+ return nil, pullErr
+ }
+ _header, _headerErr := BACnetTagHeaderParse(readBuffer)
+ if _headerErr != nil {
+ return nil, errors.Wrap(_headerErr, "Error parsing 'header' field")
+ }
+ header := CastBACnetTagHeader(_header)
+ if closeErr := readBuffer.CloseContext("header"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Validation
+ if !(bool((header.GetTagClass()) == (tagClass))) {
+ return nil, utils.ParseValidationError{"tag class doesn't match"}
+ }
+
+ // Validation
+ if !(bool(bool(bool((header.GetTagClass()) == (TagClass_APPLICATION_TAGS)))) || bool(bool(bool((header.GetActualTagNumber()) == (tagNumber))))) {
+ return nil, utils.ParseAssertError{"tagnumber doesn't match"}
+ }
+
+ // Manual Field (value)
+ _value, _valueErr := ReadEnumGenericFailing(readBuffer, header.GetActualLength(), BACnetAccessRuleLocationSpecifier_SPECIFIED)
+ if _valueErr != nil {
+ return nil, errors.Wrap(_valueErr, "Error parsing 'value' field")
+ }
+ value := _value.(BACnetAccessRuleLocationSpecifier)
+
+ if closeErr := readBuffer.CloseContext("BACnetAccessRuleLocationSpecifierTagged"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create the instance
+ return NewBACnetAccessRuleLocationSpecifierTagged(header, value, tagNumber, tagClass), nil
+}
+
+func (m *BACnetAccessRuleLocationSpecifierTagged) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ if pushErr := writeBuffer.PushContext("BACnetAccessRuleLocationSpecifierTagged"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (header)
+ if pushErr := writeBuffer.PushContext("header"); pushErr != nil {
+ return pushErr
+ }
+ _headerErr := m.Header.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("header"); popErr != nil {
+ return popErr
+ }
+ if _headerErr != nil {
+ return errors.Wrap(_headerErr, "Error serializing 'header' field")
+ }
+
+ // Manual Field (value)
+ _valueErr := WriteEnumGeneric(writeBuffer, m.GetValue())
+ if _valueErr != nil {
+ return errors.Wrap(_valueErr, "Error serializing 'value' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetAccessRuleLocationSpecifierTagged"); popErr != nil {
+ return popErr
+ }
+ return nil
+}
+
+func (m *BACnetAccessRuleLocationSpecifierTagged) 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/BACnetAccessRuleTimeRangeSpecifier.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessRuleTimeRangeSpecifier.go
new file mode 100644
index 0000000000..345b0905e9
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessRuleTimeRangeSpecifier.go
@@ -0,0 +1,122 @@
+/*
+ * 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.
+
+// BACnetAccessRuleTimeRangeSpecifier is an enum
+type BACnetAccessRuleTimeRangeSpecifier uint8
+
+type IBACnetAccessRuleTimeRangeSpecifier interface {
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+const (
+ BACnetAccessRuleTimeRangeSpecifier_SPECIFIED BACnetAccessRuleTimeRangeSpecifier = 0
+ BACnetAccessRuleTimeRangeSpecifier_ALWAYS BACnetAccessRuleTimeRangeSpecifier = 1
+)
+
+var BACnetAccessRuleTimeRangeSpecifierValues []BACnetAccessRuleTimeRangeSpecifier
+
+func init() {
+ _ = errors.New
+ BACnetAccessRuleTimeRangeSpecifierValues = []BACnetAccessRuleTimeRangeSpecifier{
+ BACnetAccessRuleTimeRangeSpecifier_SPECIFIED,
+ BACnetAccessRuleTimeRangeSpecifier_ALWAYS,
+ }
+}
+
+func BACnetAccessRuleTimeRangeSpecifierByValue(value uint8) BACnetAccessRuleTimeRangeSpecifier {
+ switch value {
+ case 0:
+ return BACnetAccessRuleTimeRangeSpecifier_SPECIFIED
+ case 1:
+ return BACnetAccessRuleTimeRangeSpecifier_ALWAYS
+ }
+ return 0
+}
+
+func BACnetAccessRuleTimeRangeSpecifierByName(value string) BACnetAccessRuleTimeRangeSpecifier {
+ switch value {
+ case "SPECIFIED":
+ return BACnetAccessRuleTimeRangeSpecifier_SPECIFIED
+ case "ALWAYS":
+ return BACnetAccessRuleTimeRangeSpecifier_ALWAYS
+ }
+ return 0
+}
+
+func BACnetAccessRuleTimeRangeSpecifierKnows(value uint8) bool {
+ for _, typeValue := range BACnetAccessRuleTimeRangeSpecifierValues {
+ if uint8(typeValue) == value {
+ return true
+ }
+ }
+ return false
+}
+
+func CastBACnetAccessRuleTimeRangeSpecifier(structType interface{}) BACnetAccessRuleTimeRangeSpecifier {
+ castFunc := func(typ interface{}) BACnetAccessRuleTimeRangeSpecifier {
+ if sBACnetAccessRuleTimeRangeSpecifier, ok := typ.(BACnetAccessRuleTimeRangeSpecifier); ok {
+ return sBACnetAccessRuleTimeRangeSpecifier
+ }
+ return 0
+ }
+ return castFunc(structType)
+}
+
+func (m BACnetAccessRuleTimeRangeSpecifier) GetLengthInBits() uint16 {
+ return 8
+}
+
+func (m BACnetAccessRuleTimeRangeSpecifier) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetAccessRuleTimeRangeSpecifierParse(readBuffer utils.ReadBuffer) (BACnetAccessRuleTimeRangeSpecifier, error) {
+ val, err := readBuffer.ReadUint8("BACnetAccessRuleTimeRangeSpecifier", 8)
+ if err != nil {
+ return 0, nil
+ }
+ return BACnetAccessRuleTimeRangeSpecifierByValue(val), nil
+}
+
+func (e BACnetAccessRuleTimeRangeSpecifier) Serialize(writeBuffer utils.WriteBuffer) error {
+ return writeBuffer.WriteUint8("BACnetAccessRuleTimeRangeSpecifier", 8, uint8(e), utils.WithAdditionalStringRepresentation(e.name()))
+}
+
+func (e BACnetAccessRuleTimeRangeSpecifier) name() string {
+ switch e {
+ case BACnetAccessRuleTimeRangeSpecifier_SPECIFIED:
+ return "SPECIFIED"
+ case BACnetAccessRuleTimeRangeSpecifier_ALWAYS:
+ return "ALWAYS"
+ }
+ return ""
+}
+
+func (e BACnetAccessRuleTimeRangeSpecifier) String() string {
+ return e.name()
+}
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessRuleTimeRangeSpecifierTagged.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessRuleTimeRangeSpecifierTagged.go
new file mode 100644
index 0000000000..8775f22132
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAccessRuleTimeRangeSpecifierTagged.go
@@ -0,0 +1,197 @@
+/*
+ * 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.
+
+// BACnetAccessRuleTimeRangeSpecifierTagged is the data-structure of this message
+type BACnetAccessRuleTimeRangeSpecifierTagged struct {
+ Header *BACnetTagHeader
+ Value BACnetAccessRuleTimeRangeSpecifier
+
+ // Arguments.
+ TagNumber uint8
+ TagClass TagClass
+}
+
+// IBACnetAccessRuleTimeRangeSpecifierTagged is the corresponding interface of BACnetAccessRuleTimeRangeSpecifierTagged
+type IBACnetAccessRuleTimeRangeSpecifierTagged interface {
+ // GetHeader returns Header (property field)
+ GetHeader() *BACnetTagHeader
+ // GetValue returns Value (property field)
+ GetValue() BACnetAccessRuleTimeRangeSpecifier
+ // 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 *BACnetAccessRuleTimeRangeSpecifierTagged) GetHeader() *BACnetTagHeader {
+ return m.Header
+}
+
+func (m *BACnetAccessRuleTimeRangeSpecifierTagged) GetValue() BACnetAccessRuleTimeRangeSpecifier {
+ return m.Value
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetAccessRuleTimeRangeSpecifierTagged factory function for BACnetAccessRuleTimeRangeSpecifierTagged
+func NewBACnetAccessRuleTimeRangeSpecifierTagged(header *BACnetTagHeader, value BACnetAccessRuleTimeRangeSpecifier, tagNumber uint8, tagClass TagClass) *BACnetAccessRuleTimeRangeSpecifierTagged {
+ return &BACnetAccessRuleTimeRangeSpecifierTagged{Header: header, Value: value, TagNumber: tagNumber, TagClass: tagClass}
+}
+
+func CastBACnetAccessRuleTimeRangeSpecifierTagged(structType interface{}) *BACnetAccessRuleTimeRangeSpecifierTagged {
+ if casted, ok := structType.(BACnetAccessRuleTimeRangeSpecifierTagged); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetAccessRuleTimeRangeSpecifierTagged); ok {
+ return casted
+ }
+ return nil
+}
+
+func (m *BACnetAccessRuleTimeRangeSpecifierTagged) GetTypeName() string {
+ return "BACnetAccessRuleTimeRangeSpecifierTagged"
+}
+
+func (m *BACnetAccessRuleTimeRangeSpecifierTagged) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetAccessRuleTimeRangeSpecifierTagged) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(0)
+
+ // Simple field (header)
+ lengthInBits += m.Header.GetLengthInBits()
+
+ // Manual Field (value)
+ lengthInBits += uint16(int32(m.GetHeader().GetActualLength()) * int32(int32(8)))
+
+ return lengthInBits
+}
+
+func (m *BACnetAccessRuleTimeRangeSpecifierTagged) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetAccessRuleTimeRangeSpecifierTaggedParse(readBuffer utils.ReadBuffer, tagNumber uint8, tagClass TagClass) (*BACnetAccessRuleTimeRangeSpecifierTagged, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetAccessRuleTimeRangeSpecifierTagged"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (header)
+ if pullErr := readBuffer.PullContext("header"); pullErr != nil {
+ return nil, pullErr
+ }
+ _header, _headerErr := BACnetTagHeaderParse(readBuffer)
+ if _headerErr != nil {
+ return nil, errors.Wrap(_headerErr, "Error parsing 'header' field")
+ }
+ header := CastBACnetTagHeader(_header)
+ if closeErr := readBuffer.CloseContext("header"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Validation
+ if !(bool((header.GetTagClass()) == (tagClass))) {
+ return nil, utils.ParseValidationError{"tag class doesn't match"}
+ }
+
+ // Validation
+ if !(bool(bool(bool((header.GetTagClass()) == (TagClass_APPLICATION_TAGS)))) || bool(bool(bool((header.GetActualTagNumber()) == (tagNumber))))) {
+ return nil, utils.ParseAssertError{"tagnumber doesn't match"}
+ }
+
+ // Manual Field (value)
+ _value, _valueErr := ReadEnumGenericFailing(readBuffer, header.GetActualLength(), BACnetAccessRuleTimeRangeSpecifier_SPECIFIED)
+ if _valueErr != nil {
+ return nil, errors.Wrap(_valueErr, "Error parsing 'value' field")
+ }
+ value := _value.(BACnetAccessRuleTimeRangeSpecifier)
+
+ if closeErr := readBuffer.CloseContext("BACnetAccessRuleTimeRangeSpecifierTagged"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create the instance
+ return NewBACnetAccessRuleTimeRangeSpecifierTagged(header, value, tagNumber, tagClass), nil
+}
+
+func (m *BACnetAccessRuleTimeRangeSpecifierTagged) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ if pushErr := writeBuffer.PushContext("BACnetAccessRuleTimeRangeSpecifierTagged"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (header)
+ if pushErr := writeBuffer.PushContext("header"); pushErr != nil {
+ return pushErr
+ }
+ _headerErr := m.Header.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("header"); popErr != nil {
+ return popErr
+ }
+ if _headerErr != nil {
+ return errors.Wrap(_headerErr, "Error serializing 'header' field")
+ }
+
+ // Manual Field (value)
+ _valueErr := WriteEnumGeneric(writeBuffer, m.GetValue())
+ if _valueErr != nil {
+ return errors.Wrap(_valueErr, "Error serializing 'value' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetAccessRuleTimeRangeSpecifierTagged"); popErr != nil {
+ return popErr
+ }
+ return nil
+}
+
+func (m *BACnetAccessRuleTimeRangeSpecifierTagged) 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/BACnetAddressBinding.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetAddressBinding.go
new file mode 100644
index 0000000000..fbedfeef99
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetAddressBinding.go
@@ -0,0 +1,195 @@
+/*
+ * 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.
+
+// BACnetAddressBinding is the data-structure of this message
+type BACnetAddressBinding struct {
+ DeviceIdentifier *BACnetApplicationTagObjectIdentifier
+ DeviceAddress *BACnetAddress
+}
+
+// IBACnetAddressBinding is the corresponding interface of BACnetAddressBinding
+type IBACnetAddressBinding interface {
+ // GetDeviceIdentifier returns DeviceIdentifier (property field)
+ GetDeviceIdentifier() *BACnetApplicationTagObjectIdentifier
+ // GetDeviceAddress returns DeviceAddress (property field)
+ GetDeviceAddress() *BACnetAddress
+ // 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 *BACnetAddressBinding) GetDeviceIdentifier() *BACnetApplicationTagObjectIdentifier {
+ return m.DeviceIdentifier
+}
+
+func (m *BACnetAddressBinding) GetDeviceAddress() *BACnetAddress {
+ return m.DeviceAddress
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetAddressBinding factory function for BACnetAddressBinding
+func NewBACnetAddressBinding(deviceIdentifier *BACnetApplicationTagObjectIdentifier, deviceAddress *BACnetAddress) *BACnetAddressBinding {
+ return &BACnetAddressBinding{DeviceIdentifier: deviceIdentifier, DeviceAddress: deviceAddress}
+}
+
+func CastBACnetAddressBinding(structType interface{}) *BACnetAddressBinding {
+ if casted, ok := structType.(BACnetAddressBinding); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetAddressBinding); ok {
+ return casted
+ }
+ return nil
+}
+
+func (m *BACnetAddressBinding) GetTypeName() string {
+ return "BACnetAddressBinding"
+}
+
+func (m *BACnetAddressBinding) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetAddressBinding) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(0)
+
+ // Simple field (deviceIdentifier)
+ lengthInBits += m.DeviceIdentifier.GetLengthInBits()
+
+ // Simple field (deviceAddress)
+ lengthInBits += m.DeviceAddress.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetAddressBinding) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetAddressBindingParse(readBuffer utils.ReadBuffer) (*BACnetAddressBinding, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetAddressBinding"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (deviceIdentifier)
+ if pullErr := readBuffer.PullContext("deviceIdentifier"); pullErr != nil {
+ return nil, pullErr
+ }
+ _deviceIdentifier, _deviceIdentifierErr := BACnetApplicationTagParse(readBuffer)
+ if _deviceIdentifierErr != nil {
+ return nil, errors.Wrap(_deviceIdentifierErr, "Error parsing 'deviceIdentifier' field")
+ }
+ deviceIdentifier := CastBACnetApplicationTagObjectIdentifier(_deviceIdentifier)
+ if closeErr := readBuffer.CloseContext("deviceIdentifier"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Simple Field (deviceAddress)
+ if pullErr := readBuffer.PullContext("deviceAddress"); pullErr != nil {
+ return nil, pullErr
+ }
+ _deviceAddress, _deviceAddressErr := BACnetAddressParse(readBuffer)
+ if _deviceAddressErr != nil {
+ return nil, errors.Wrap(_deviceAddressErr, "Error parsing 'deviceAddress' field")
+ }
+ deviceAddress := CastBACnetAddress(_deviceAddress)
+ if closeErr := readBuffer.CloseContext("deviceAddress"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetAddressBinding"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create the instance
+ return NewBACnetAddressBinding(deviceIdentifier, deviceAddress), nil
+}
+
+func (m *BACnetAddressBinding) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ if pushErr := writeBuffer.PushContext("BACnetAddressBinding"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (deviceIdentifier)
+ if pushErr := writeBuffer.PushContext("deviceIdentifier"); pushErr != nil {
+ return pushErr
+ }
+ _deviceIdentifierErr := m.DeviceIdentifier.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("deviceIdentifier"); popErr != nil {
+ return popErr
+ }
+ if _deviceIdentifierErr != nil {
+ return errors.Wrap(_deviceIdentifierErr, "Error serializing 'deviceIdentifier' field")
+ }
+
+ // Simple Field (deviceAddress)
+ if pushErr := writeBuffer.PushContext("deviceAddress"); pushErr != nil {
+ return pushErr
+ }
+ _deviceAddressErr := m.DeviceAddress.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("deviceAddress"); popErr != nil {
+ return popErr
+ }
+ if _deviceAddressErr != nil {
+ return errors.Wrap(_deviceAddressErr, "Error serializing 'deviceAddress' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetAddressBinding"); popErr != nil {
+ return popErr
+ }
+ return nil
+}
+
+func (m *BACnetAddressBinding) 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/BACnetConstructedData.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedData.go
index 50748b5026..7067be52aa 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedData.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedData.go
@@ -292,6 +292,8 @@ func BACnetConstructedDataParse(readBuffer utils.ReadBuffer, tagNumber uint8, ob
_child, typeSwitchError = BACnetConstructedDataTrendLogAllParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case objectTypeArgument == BACnetObjectType_TREND_LOG_MULTIPLE && propertyIdentifierArgument == BACnetPropertyIdentifier_ALL: // BACnetConstructedDataTrendLogMultipleAll
_child, typeSwitchError = BACnetConstructedDataTrendLogMultipleAllParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
+ case true && propertyIdentifierArgument == BACnetPropertyIdentifier_BBMD_ACCEPT_FD_REGISTRATIONS: // BACnetConstructedDataBBMDAcceptFDRegistrations
+ _child, typeSwitchError = BACnetConstructedDataBBMDAcceptFDRegistrationsParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_CAR_LOAD_UNITS: // BACnetConstructedDataCarLoadUnits
_child, typeSwitchError = BACnetConstructedDataCarLoadUnitsParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_CONTROLLED_VARIABLE_UNITS: // BACnetConstructedDataControlledVariableUnits
@@ -338,6 +340,10 @@ func BACnetConstructedDataParse(readBuffer utils.ReadBuffer, tagNumber uint8, ob
_child, typeSwitchError = BACnetConstructedDataIntegralConstantUnitsParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case objectTypeArgument == BACnetObjectType_ANALOG_INPUT && propertyIdentifierArgument == BACnetPropertyIdentifier_INTERFACE_VALUE: // BACnetConstructedDataAnalogInputInterfaceValue
_child, typeSwitchError = BACnetConstructedDataAnalogInputInterfaceValueParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
+ case true && propertyIdentifierArgument == BACnetPropertyIdentifier_IP_DHCP_LEASE_TIME_REMAINING: // BACnetConstructedDataIPDHCPLeaseTimeRemaining
+ _child, typeSwitchError = BACnetConstructedDataIPDHCPLeaseTimeRemainingParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
+ case true && propertyIdentifierArgument == BACnetPropertyIdentifier_IPV6_DHCP_LEASE_TIME_REMAINING: // BACnetConstructedDataIPv6DHCPLeaseTimeRemaining
+ _child, typeSwitchError = BACnetConstructedDataIPv6DHCPLeaseTimeRemainingParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_LIFE_SAFETY_ALARM_VALUES: // BACnetConstructedDataLifeSafetyAlarmValues
_child, typeSwitchError = BACnetConstructedDataLifeSafetyAlarmValuesParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_LIMIT_ENABLE: // BACnetConstructedDataLimitEnable
@@ -348,6 +354,8 @@ func BACnetConstructedDataParse(readBuffer utils.ReadBuffer, tagNumber uint8, ob
_child, typeSwitchError = BACnetConstructedDataAccumulatorLowLimitParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_LOW_LIMIT: // BACnetConstructedDataLowLimit
_child, typeSwitchError = BACnetConstructedDataLowLimitParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
+ case true && propertyIdentifierArgument == BACnetPropertyIdentifier_MANUAL_SLAVE_ADDRESS_BINDING: // BACnetConstructedDataManualSlaveAddressBinding
+ _child, typeSwitchError = BACnetConstructedDataManualSlaveAddressBindingParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case objectTypeArgument == BACnetObjectType_ACCUMULATOR && propertyIdentifierArgument == BACnetPropertyIdentifier_MAX_PRES_VALUE: // BACnetConstructedDataAccumulatorMaxPresValue
_child, typeSwitchError = BACnetConstructedDataAccumulatorMaxPresValueParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_MAX_PRES_VALUE: // BACnetConstructedDataMaxPresValue
@@ -358,6 +366,8 @@ func BACnetConstructedDataParse(readBuffer utils.ReadBuffer, tagNumber uint8, ob
_child, typeSwitchError = BACnetConstructedDataAccumulatorMinPresValueParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_MIN_PRES_VALUE: // BACnetConstructedDataMinPresValue
_child, typeSwitchError = BACnetConstructedDataMinPresValueParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
+ case true && propertyIdentifierArgument == BACnetPropertyIdentifier_MINIMUM_VALUE: // BACnetConstructedDataMinimumValue
+ _child, typeSwitchError = BACnetConstructedDataMinimumValueParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_NOTIFICATION_CLASS: // BACnetConstructedDataNotificationClass
_child, typeSwitchError = BACnetConstructedDataNotificationClassParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_NOTIFY_TYPE: // BACnetConstructedDataNotifyType
@@ -372,6 +382,8 @@ func BACnetConstructedDataParse(readBuffer utils.ReadBuffer, tagNumber uint8, ob
_child, typeSwitchError = BACnetConstructedDataOutOfServiceParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_OUTPUT_UNITS: // BACnetConstructedDataOutputUnits
_child, typeSwitchError = BACnetConstructedDataOutputUnitsParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
+ case true && propertyIdentifierArgument == BACnetPropertyIdentifier_POSITIVE_ACCESS_RULES: // BACnetConstructedDataPositiveAccessRules
+ _child, typeSwitchError = BACnetConstructedDataPositiveAccessRulesParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case objectTypeArgument == BACnetObjectType_ANALOG_INPUT && propertyIdentifierArgument == BACnetPropertyIdentifier_PRESENT_VALUE: // BACnetConstructedDataAnalogInputPresentValue
_child, typeSwitchError = BACnetConstructedDataAnalogInputPresentValueParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_PRIORITY_ARRAY: // BACnetConstructedDataPriorityArray
@@ -388,6 +400,8 @@ func BACnetConstructedDataParse(readBuffer utils.ReadBuffer, tagNumber uint8, ob
_child, typeSwitchError = BACnetConstructedDataReliabilityParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_RELIABILITY_EVALUATION_INHIBIT: // BACnetConstructedDataReliabilityEvaluationInhibit
_child, typeSwitchError = BACnetConstructedDataReliabilityEvaluationInhibitParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
+ case true && propertyIdentifierArgument == BACnetPropertyIdentifier_REPRESENTS: // BACnetConstructedDataRepresents
+ _child, typeSwitchError = BACnetConstructedDataRepresentsParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_RESOLUTION: // BACnetConstructedDataResolution
_child, typeSwitchError = BACnetConstructedDataResolutionParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_STATUS_FLAGS: // BACnetConstructedDataStatusFlags
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBBMDAcceptFDRegistrations.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBBMDAcceptFDRegistrations.go
new file mode 100644
index 0000000000..44246b050f
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataBBMDAcceptFDRegistrations.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.
+
+// BACnetConstructedDataBBMDAcceptFDRegistrations is the data-structure of this message
+type BACnetConstructedDataBBMDAcceptFDRegistrations struct {
+ *BACnetConstructedData
+ BbmdAcceptFDRegistrations *BACnetApplicationTagBoolean
+
+ // Arguments.
+ TagNumber uint8
+}
+
+// IBACnetConstructedDataBBMDAcceptFDRegistrations is the corresponding interface of BACnetConstructedDataBBMDAcceptFDRegistrations
+type IBACnetConstructedDataBBMDAcceptFDRegistrations interface {
+ IBACnetConstructedData
+ // GetBbmdAcceptFDRegistrations returns BbmdAcceptFDRegistrations (property field)
+ GetBbmdAcceptFDRegistrations() *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 *BACnetConstructedDataBBMDAcceptFDRegistrations) GetObjectTypeArgument() BACnetObjectType {
+ return 0
+}
+
+func (m *BACnetConstructedDataBBMDAcceptFDRegistrations) GetPropertyIdentifierArgument() BACnetPropertyIdentifier {
+ return BACnetPropertyIdentifier_BBMD_ACCEPT_FD_REGISTRATIONS
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+func (m *BACnetConstructedDataBBMDAcceptFDRegistrations) InitializeParent(parent *BACnetConstructedData, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag) {
+ m.BACnetConstructedData.OpeningTag = openingTag
+ m.BACnetConstructedData.ClosingTag = closingTag
+}
+
+func (m *BACnetConstructedDataBBMDAcceptFDRegistrations) GetParent() *BACnetConstructedData {
+ return m.BACnetConstructedData
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetConstructedDataBBMDAcceptFDRegistrations) GetBbmdAcceptFDRegistrations() *BACnetApplicationTagBoolean {
+ return m.BbmdAcceptFDRegistrations
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetConstructedDataBBMDAcceptFDRegistrations factory function for BACnetConstructedDataBBMDAcceptFDRegistrations
+func NewBACnetConstructedDataBBMDAcceptFDRegistrations(bbmdAcceptFDRegistrations *BACnetApplicationTagBoolean, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag, tagNumber uint8) *BACnetConstructedDataBBMDAcceptFDRegistrations {
+ _result := &BACnetConstructedDataBBMDAcceptFDRegistrations{
+ BbmdAcceptFDRegistrations: bbmdAcceptFDRegistrations,
+ BACnetConstructedData: NewBACnetConstructedData(openingTag, closingTag, tagNumber),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetConstructedDataBBMDAcceptFDRegistrations(structType interface{}) *BACnetConstructedDataBBMDAcceptFDRegistrations {
+ if casted, ok := structType.(BACnetConstructedDataBBMDAcceptFDRegistrations); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConstructedDataBBMDAcceptFDRegistrations); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConstructedData); ok {
+ return CastBACnetConstructedDataBBMDAcceptFDRegistrations(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConstructedData); ok {
+ return CastBACnetConstructedDataBBMDAcceptFDRegistrations(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetConstructedDataBBMDAcceptFDRegistrations) GetTypeName() string {
+ return "BACnetConstructedDataBBMDAcceptFDRegistrations"
+}
+
+func (m *BACnetConstructedDataBBMDAcceptFDRegistrations) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetConstructedDataBBMDAcceptFDRegistrations) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (bbmdAcceptFDRegistrations)
+ lengthInBits += m.BbmdAcceptFDRegistrations.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetConstructedDataBBMDAcceptFDRegistrations) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetConstructedDataBBMDAcceptFDRegistrationsParse(readBuffer utils.ReadBuffer, tagNumber uint8, objectTypeArgument BACnetObjectType, propertyIdentifierArgument BACnetPropertyIdentifier) (*BACnetConstructedDataBBMDAcceptFDRegistrations, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetConstructedDataBBMDAcceptFDRegistrations"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (bbmdAcceptFDRegistrations)
+ if pullErr := readBuffer.PullContext("bbmdAcceptFDRegistrations"); pullErr != nil {
+ return nil, pullErr
+ }
+ _bbmdAcceptFDRegistrations, _bbmdAcceptFDRegistrationsErr := BACnetApplicationTagParse(readBuffer)
+ if _bbmdAcceptFDRegistrationsErr != nil {
+ return nil, errors.Wrap(_bbmdAcceptFDRegistrationsErr, "Error parsing 'bbmdAcceptFDRegistrations' field")
+ }
+ bbmdAcceptFDRegistrations := CastBACnetApplicationTagBoolean(_bbmdAcceptFDRegistrations)
+ if closeErr := readBuffer.CloseContext("bbmdAcceptFDRegistrations"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetConstructedDataBBMDAcceptFDRegistrations"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetConstructedDataBBMDAcceptFDRegistrations{
+ BbmdAcceptFDRegistrations: CastBACnetApplicationTagBoolean(bbmdAcceptFDRegistrations),
+ BACnetConstructedData: &BACnetConstructedData{},
+ }
+ _child.BACnetConstructedData.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetConstructedDataBBMDAcceptFDRegistrations) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetConstructedDataBBMDAcceptFDRegistrations"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (bbmdAcceptFDRegistrations)
+ if pushErr := writeBuffer.PushContext("bbmdAcceptFDRegistrations"); pushErr != nil {
+ return pushErr
+ }
+ _bbmdAcceptFDRegistrationsErr := m.BbmdAcceptFDRegistrations.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("bbmdAcceptFDRegistrations"); popErr != nil {
+ return popErr
+ }
+ if _bbmdAcceptFDRegistrationsErr != nil {
+ return errors.Wrap(_bbmdAcceptFDRegistrationsErr, "Error serializing 'bbmdAcceptFDRegistrations' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetConstructedDataBBMDAcceptFDRegistrations"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetConstructedDataBBMDAcceptFDRegistrations) 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/BACnetConstructedDataIPDHCPLeaseTimeRemaining.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataIPDHCPLeaseTimeRemaining.go
new file mode 100644
index 0000000000..67d4c68dc5
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataIPDHCPLeaseTimeRemaining.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.
+
+// BACnetConstructedDataIPDHCPLeaseTimeRemaining is the data-structure of this message
+type BACnetConstructedDataIPDHCPLeaseTimeRemaining struct {
+ *BACnetConstructedData
+ IpDhcpLeaseTimeRemaining *BACnetApplicationTagUnsignedInteger
+
+ // Arguments.
+ TagNumber uint8
+}
+
+// IBACnetConstructedDataIPDHCPLeaseTimeRemaining is the corresponding interface of BACnetConstructedDataIPDHCPLeaseTimeRemaining
+type IBACnetConstructedDataIPDHCPLeaseTimeRemaining interface {
+ IBACnetConstructedData
+ // GetIpDhcpLeaseTimeRemaining returns IpDhcpLeaseTimeRemaining (property field)
+ GetIpDhcpLeaseTimeRemaining() *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 *BACnetConstructedDataIPDHCPLeaseTimeRemaining) GetObjectTypeArgument() BACnetObjectType {
+ return 0
+}
+
+func (m *BACnetConstructedDataIPDHCPLeaseTimeRemaining) GetPropertyIdentifierArgument() BACnetPropertyIdentifier {
+ return BACnetPropertyIdentifier_IP_DHCP_LEASE_TIME_REMAINING
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+func (m *BACnetConstructedDataIPDHCPLeaseTimeRemaining) InitializeParent(parent *BACnetConstructedData, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag) {
+ m.BACnetConstructedData.OpeningTag = openingTag
+ m.BACnetConstructedData.ClosingTag = closingTag
+}
+
+func (m *BACnetConstructedDataIPDHCPLeaseTimeRemaining) GetParent() *BACnetConstructedData {
+ return m.BACnetConstructedData
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetConstructedDataIPDHCPLeaseTimeRemaining) GetIpDhcpLeaseTimeRemaining() *BACnetApplicationTagUnsignedInteger {
+ return m.IpDhcpLeaseTimeRemaining
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetConstructedDataIPDHCPLeaseTimeRemaining factory function for BACnetConstructedDataIPDHCPLeaseTimeRemaining
+func NewBACnetConstructedDataIPDHCPLeaseTimeRemaining(ipDhcpLeaseTimeRemaining *BACnetApplicationTagUnsignedInteger, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag, tagNumber uint8) *BACnetConstructedDataIPDHCPLeaseTimeRemaining {
+ _result := &BACnetConstructedDataIPDHCPLeaseTimeRemaining{
+ IpDhcpLeaseTimeRemaining: ipDhcpLeaseTimeRemaining,
+ BACnetConstructedData: NewBACnetConstructedData(openingTag, closingTag, tagNumber),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetConstructedDataIPDHCPLeaseTimeRemaining(structType interface{}) *BACnetConstructedDataIPDHCPLeaseTimeRemaining {
+ if casted, ok := structType.(BACnetConstructedDataIPDHCPLeaseTimeRemaining); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConstructedDataIPDHCPLeaseTimeRemaining); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConstructedData); ok {
+ return CastBACnetConstructedDataIPDHCPLeaseTimeRemaining(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConstructedData); ok {
+ return CastBACnetConstructedDataIPDHCPLeaseTimeRemaining(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetConstructedDataIPDHCPLeaseTimeRemaining) GetTypeName() string {
+ return "BACnetConstructedDataIPDHCPLeaseTimeRemaining"
+}
+
+func (m *BACnetConstructedDataIPDHCPLeaseTimeRemaining) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetConstructedDataIPDHCPLeaseTimeRemaining) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (ipDhcpLeaseTimeRemaining)
+ lengthInBits += m.IpDhcpLeaseTimeRemaining.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetConstructedDataIPDHCPLeaseTimeRemaining) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetConstructedDataIPDHCPLeaseTimeRemainingParse(readBuffer utils.ReadBuffer, tagNumber uint8, objectTypeArgument BACnetObjectType, propertyIdentifierArgument BACnetPropertyIdentifier) (*BACnetConstructedDataIPDHCPLeaseTimeRemaining, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetConstructedDataIPDHCPLeaseTimeRemaining"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (ipDhcpLeaseTimeRemaining)
+ if pullErr := readBuffer.PullContext("ipDhcpLeaseTimeRemaining"); pullErr != nil {
+ return nil, pullErr
+ }
+ _ipDhcpLeaseTimeRemaining, _ipDhcpLeaseTimeRemainingErr := BACnetApplicationTagParse(readBuffer)
+ if _ipDhcpLeaseTimeRemainingErr != nil {
+ return nil, errors.Wrap(_ipDhcpLeaseTimeRemainingErr, "Error parsing 'ipDhcpLeaseTimeRemaining' field")
+ }
+ ipDhcpLeaseTimeRemaining := CastBACnetApplicationTagUnsignedInteger(_ipDhcpLeaseTimeRemaining)
+ if closeErr := readBuffer.CloseContext("ipDhcpLeaseTimeRemaining"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetConstructedDataIPDHCPLeaseTimeRemaining"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetConstructedDataIPDHCPLeaseTimeRemaining{
+ IpDhcpLeaseTimeRemaining: CastBACnetApplicationTagUnsignedInteger(ipDhcpLeaseTimeRemaining),
+ BACnetConstructedData: &BACnetConstructedData{},
+ }
+ _child.BACnetConstructedData.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetConstructedDataIPDHCPLeaseTimeRemaining) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetConstructedDataIPDHCPLeaseTimeRemaining"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (ipDhcpLeaseTimeRemaining)
+ if pushErr := writeBuffer.PushContext("ipDhcpLeaseTimeRemaining"); pushErr != nil {
+ return pushErr
+ }
+ _ipDhcpLeaseTimeRemainingErr := m.IpDhcpLeaseTimeRemaining.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("ipDhcpLeaseTimeRemaining"); popErr != nil {
+ return popErr
+ }
+ if _ipDhcpLeaseTimeRemainingErr != nil {
+ return errors.Wrap(_ipDhcpLeaseTimeRemainingErr, "Error serializing 'ipDhcpLeaseTimeRemaining' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetConstructedDataIPDHCPLeaseTimeRemaining"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetConstructedDataIPDHCPLeaseTimeRemaining) 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/BACnetConstructedDataIPv6DHCPLeaseTimeRemaining.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataIPv6DHCPLeaseTimeRemaining.go
new file mode 100644
index 0000000000..51f792bcbe
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataIPv6DHCPLeaseTimeRemaining.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.
+
+// BACnetConstructedDataIPv6DHCPLeaseTimeRemaining is the data-structure of this message
+type BACnetConstructedDataIPv6DHCPLeaseTimeRemaining struct {
+ *BACnetConstructedData
+ Ipv6DhcpLeaseTimeRemaining *BACnetApplicationTagUnsignedInteger
+
+ // Arguments.
+ TagNumber uint8
+}
+
+// IBACnetConstructedDataIPv6DHCPLeaseTimeRemaining is the corresponding interface of BACnetConstructedDataIPv6DHCPLeaseTimeRemaining
+type IBACnetConstructedDataIPv6DHCPLeaseTimeRemaining interface {
+ IBACnetConstructedData
+ // GetIpv6DhcpLeaseTimeRemaining returns Ipv6DhcpLeaseTimeRemaining (property field)
+ GetIpv6DhcpLeaseTimeRemaining() *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 *BACnetConstructedDataIPv6DHCPLeaseTimeRemaining) GetObjectTypeArgument() BACnetObjectType {
+ return 0
+}
+
+func (m *BACnetConstructedDataIPv6DHCPLeaseTimeRemaining) GetPropertyIdentifierArgument() BACnetPropertyIdentifier {
+ return BACnetPropertyIdentifier_IPV6_DHCP_LEASE_TIME_REMAINING
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+func (m *BACnetConstructedDataIPv6DHCPLeaseTimeRemaining) InitializeParent(parent *BACnetConstructedData, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag) {
+ m.BACnetConstructedData.OpeningTag = openingTag
+ m.BACnetConstructedData.ClosingTag = closingTag
+}
+
+func (m *BACnetConstructedDataIPv6DHCPLeaseTimeRemaining) GetParent() *BACnetConstructedData {
+ return m.BACnetConstructedData
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetConstructedDataIPv6DHCPLeaseTimeRemaining) GetIpv6DhcpLeaseTimeRemaining() *BACnetApplicationTagUnsignedInteger {
+ return m.Ipv6DhcpLeaseTimeRemaining
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetConstructedDataIPv6DHCPLeaseTimeRemaining factory function for BACnetConstructedDataIPv6DHCPLeaseTimeRemaining
+func NewBACnetConstructedDataIPv6DHCPLeaseTimeRemaining(ipv6DhcpLeaseTimeRemaining *BACnetApplicationTagUnsignedInteger, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag, tagNumber uint8) *BACnetConstructedDataIPv6DHCPLeaseTimeRemaining {
+ _result := &BACnetConstructedDataIPv6DHCPLeaseTimeRemaining{
+ Ipv6DhcpLeaseTimeRemaining: ipv6DhcpLeaseTimeRemaining,
+ BACnetConstructedData: NewBACnetConstructedData(openingTag, closingTag, tagNumber),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetConstructedDataIPv6DHCPLeaseTimeRemaining(structType interface{}) *BACnetConstructedDataIPv6DHCPLeaseTimeRemaining {
+ if casted, ok := structType.(BACnetConstructedDataIPv6DHCPLeaseTimeRemaining); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConstructedDataIPv6DHCPLeaseTimeRemaining); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConstructedData); ok {
+ return CastBACnetConstructedDataIPv6DHCPLeaseTimeRemaining(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConstructedData); ok {
+ return CastBACnetConstructedDataIPv6DHCPLeaseTimeRemaining(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetConstructedDataIPv6DHCPLeaseTimeRemaining) GetTypeName() string {
+ return "BACnetConstructedDataIPv6DHCPLeaseTimeRemaining"
+}
+
+func (m *BACnetConstructedDataIPv6DHCPLeaseTimeRemaining) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetConstructedDataIPv6DHCPLeaseTimeRemaining) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (ipv6DhcpLeaseTimeRemaining)
+ lengthInBits += m.Ipv6DhcpLeaseTimeRemaining.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetConstructedDataIPv6DHCPLeaseTimeRemaining) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetConstructedDataIPv6DHCPLeaseTimeRemainingParse(readBuffer utils.ReadBuffer, tagNumber uint8, objectTypeArgument BACnetObjectType, propertyIdentifierArgument BACnetPropertyIdentifier) (*BACnetConstructedDataIPv6DHCPLeaseTimeRemaining, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetConstructedDataIPv6DHCPLeaseTimeRemaining"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (ipv6DhcpLeaseTimeRemaining)
+ if pullErr := readBuffer.PullContext("ipv6DhcpLeaseTimeRemaining"); pullErr != nil {
+ return nil, pullErr
+ }
+ _ipv6DhcpLeaseTimeRemaining, _ipv6DhcpLeaseTimeRemainingErr := BACnetApplicationTagParse(readBuffer)
+ if _ipv6DhcpLeaseTimeRemainingErr != nil {
+ return nil, errors.Wrap(_ipv6DhcpLeaseTimeRemainingErr, "Error parsing 'ipv6DhcpLeaseTimeRemaining' field")
+ }
+ ipv6DhcpLeaseTimeRemaining := CastBACnetApplicationTagUnsignedInteger(_ipv6DhcpLeaseTimeRemaining)
+ if closeErr := readBuffer.CloseContext("ipv6DhcpLeaseTimeRemaining"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetConstructedDataIPv6DHCPLeaseTimeRemaining"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetConstructedDataIPv6DHCPLeaseTimeRemaining{
+ Ipv6DhcpLeaseTimeRemaining: CastBACnetApplicationTagUnsignedInteger(ipv6DhcpLeaseTimeRemaining),
+ BACnetConstructedData: &BACnetConstructedData{},
+ }
+ _child.BACnetConstructedData.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetConstructedDataIPv6DHCPLeaseTimeRemaining) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetConstructedDataIPv6DHCPLeaseTimeRemaining"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (ipv6DhcpLeaseTimeRemaining)
+ if pushErr := writeBuffer.PushContext("ipv6DhcpLeaseTimeRemaining"); pushErr != nil {
+ return pushErr
+ }
+ _ipv6DhcpLeaseTimeRemainingErr := m.Ipv6DhcpLeaseTimeRemaining.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("ipv6DhcpLeaseTimeRemaining"); popErr != nil {
+ return popErr
+ }
+ if _ipv6DhcpLeaseTimeRemainingErr != nil {
+ return errors.Wrap(_ipv6DhcpLeaseTimeRemainingErr, "Error serializing 'ipv6DhcpLeaseTimeRemaining' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetConstructedDataIPv6DHCPLeaseTimeRemaining"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetConstructedDataIPv6DHCPLeaseTimeRemaining) 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/BACnetConstructedDataManualSlaveAddressBinding.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataManualSlaveAddressBinding.go
new file mode 100644
index 0000000000..18fddeca33
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataManualSlaveAddressBinding.go
@@ -0,0 +1,226 @@
+/*
+ * 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.
+
+// BACnetConstructedDataManualSlaveAddressBinding is the data-structure of this message
+type BACnetConstructedDataManualSlaveAddressBinding struct {
+ *BACnetConstructedData
+ ManualSlaveAddressBinding []*BACnetAddressBinding
+
+ // Arguments.
+ TagNumber uint8
+}
+
+// IBACnetConstructedDataManualSlaveAddressBinding is the corresponding interface of BACnetConstructedDataManualSlaveAddressBinding
+type IBACnetConstructedDataManualSlaveAddressBinding interface {
+ IBACnetConstructedData
+ // GetManualSlaveAddressBinding returns ManualSlaveAddressBinding (property field)
+ GetManualSlaveAddressBinding() []*BACnetAddressBinding
+ // 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 *BACnetConstructedDataManualSlaveAddressBinding) GetObjectTypeArgument() BACnetObjectType {
+ return 0
+}
+
+func (m *BACnetConstructedDataManualSlaveAddressBinding) GetPropertyIdentifierArgument() BACnetPropertyIdentifier {
+ return BACnetPropertyIdentifier_MANUAL_SLAVE_ADDRESS_BINDING
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+func (m *BACnetConstructedDataManualSlaveAddressBinding) InitializeParent(parent *BACnetConstructedData, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag) {
+ m.BACnetConstructedData.OpeningTag = openingTag
+ m.BACnetConstructedData.ClosingTag = closingTag
+}
+
+func (m *BACnetConstructedDataManualSlaveAddressBinding) GetParent() *BACnetConstructedData {
+ return m.BACnetConstructedData
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetConstructedDataManualSlaveAddressBinding) GetManualSlaveAddressBinding() []*BACnetAddressBinding {
+ return m.ManualSlaveAddressBinding
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetConstructedDataManualSlaveAddressBinding factory function for BACnetConstructedDataManualSlaveAddressBinding
+func NewBACnetConstructedDataManualSlaveAddressBinding(manualSlaveAddressBinding []*BACnetAddressBinding, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag, tagNumber uint8) *BACnetConstructedDataManualSlaveAddressBinding {
+ _result := &BACnetConstructedDataManualSlaveAddressBinding{
+ ManualSlaveAddressBinding: manualSlaveAddressBinding,
+ BACnetConstructedData: NewBACnetConstructedData(openingTag, closingTag, tagNumber),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetConstructedDataManualSlaveAddressBinding(structType interface{}) *BACnetConstructedDataManualSlaveAddressBinding {
+ if casted, ok := structType.(BACnetConstructedDataManualSlaveAddressBinding); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConstructedDataManualSlaveAddressBinding); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConstructedData); ok {
+ return CastBACnetConstructedDataManualSlaveAddressBinding(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConstructedData); ok {
+ return CastBACnetConstructedDataManualSlaveAddressBinding(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetConstructedDataManualSlaveAddressBinding) GetTypeName() string {
+ return "BACnetConstructedDataManualSlaveAddressBinding"
+}
+
+func (m *BACnetConstructedDataManualSlaveAddressBinding) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetConstructedDataManualSlaveAddressBinding) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Array field
+ if len(m.ManualSlaveAddressBinding) > 0 {
+ for _, element := range m.ManualSlaveAddressBinding {
+ lengthInBits += element.GetLengthInBits()
+ }
+ }
+
+ return lengthInBits
+}
+
+func (m *BACnetConstructedDataManualSlaveAddressBinding) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetConstructedDataManualSlaveAddressBindingParse(readBuffer utils.ReadBuffer, tagNumber uint8, objectTypeArgument BACnetObjectType, propertyIdentifierArgument BACnetPropertyIdentifier) (*BACnetConstructedDataManualSlaveAddressBinding, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetConstructedDataManualSlaveAddressBinding"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Array field (manualSlaveAddressBinding)
+ if pullErr := readBuffer.PullContext("manualSlaveAddressBinding", utils.WithRenderAsList(true)); pullErr != nil {
+ return nil, pullErr
+ }
+ // Terminated array
+ manualSlaveAddressBinding := make([]*BACnetAddressBinding, 0)
+ {
+ for !bool(IsBACnetConstructedDataClosingTag(readBuffer, false, tagNumber)) {
+ _item, _err := BACnetAddressBindingParse(readBuffer)
+ if _err != nil {
+ return nil, errors.Wrap(_err, "Error parsing 'manualSlaveAddressBinding' field")
+ }
+ manualSlaveAddressBinding = append(manualSlaveAddressBinding, CastBACnetAddressBinding(_item))
+
+ }
+ }
+ if closeErr := readBuffer.CloseContext("manualSlaveAddressBinding", utils.WithRenderAsList(true)); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetConstructedDataManualSlaveAddressBinding"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetConstructedDataManualSlaveAddressBinding{
+ ManualSlaveAddressBinding: manualSlaveAddressBinding,
+ BACnetConstructedData: &BACnetConstructedData{},
+ }
+ _child.BACnetConstructedData.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetConstructedDataManualSlaveAddressBinding) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetConstructedDataManualSlaveAddressBinding"); pushErr != nil {
+ return pushErr
+ }
+
+ // Array Field (manualSlaveAddressBinding)
+ if m.ManualSlaveAddressBinding != nil {
+ if pushErr := writeBuffer.PushContext("manualSlaveAddressBinding", utils.WithRenderAsList(true)); pushErr != nil {
+ return pushErr
+ }
+ for _, _element := range m.ManualSlaveAddressBinding {
+ _elementErr := _element.Serialize(writeBuffer)
+ if _elementErr != nil {
+ return errors.Wrap(_elementErr, "Error serializing 'manualSlaveAddressBinding' field")
+ }
+ }
+ if popErr := writeBuffer.PopContext("manualSlaveAddressBinding", utils.WithRenderAsList(true)); popErr != nil {
+ return popErr
+ }
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetConstructedDataManualSlaveAddressBinding"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetConstructedDataManualSlaveAddressBinding) 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/BACnetConstructedDataMinimumValue.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataMinimumValue.go
new file mode 100644
index 0000000000..5375ef5d6e
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataMinimumValue.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.
+
+// BACnetConstructedDataMinimumValue is the data-structure of this message
+type BACnetConstructedDataMinimumValue struct {
+ *BACnetConstructedData
+ MinimumValue *BACnetApplicationTagReal
+
+ // Arguments.
+ TagNumber uint8
+}
+
+// IBACnetConstructedDataMinimumValue is the corresponding interface of BACnetConstructedDataMinimumValue
+type IBACnetConstructedDataMinimumValue interface {
+ IBACnetConstructedData
+ // GetMinimumValue returns MinimumValue (property field)
+ GetMinimumValue() *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 *BACnetConstructedDataMinimumValue) GetObjectTypeArgument() BACnetObjectType {
+ return 0
+}
+
+func (m *BACnetConstructedDataMinimumValue) GetPropertyIdentifierArgument() BACnetPropertyIdentifier {
+ return BACnetPropertyIdentifier_MINIMUM_VALUE
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+func (m *BACnetConstructedDataMinimumValue) InitializeParent(parent *BACnetConstructedData, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag) {
+ m.BACnetConstructedData.OpeningTag = openingTag
+ m.BACnetConstructedData.ClosingTag = closingTag
+}
+
+func (m *BACnetConstructedDataMinimumValue) GetParent() *BACnetConstructedData {
+ return m.BACnetConstructedData
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetConstructedDataMinimumValue) GetMinimumValue() *BACnetApplicationTagReal {
+ return m.MinimumValue
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetConstructedDataMinimumValue factory function for BACnetConstructedDataMinimumValue
+func NewBACnetConstructedDataMinimumValue(minimumValue *BACnetApplicationTagReal, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag, tagNumber uint8) *BACnetConstructedDataMinimumValue {
+ _result := &BACnetConstructedDataMinimumValue{
+ MinimumValue: minimumValue,
+ BACnetConstructedData: NewBACnetConstructedData(openingTag, closingTag, tagNumber),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetConstructedDataMinimumValue(structType interface{}) *BACnetConstructedDataMinimumValue {
+ if casted, ok := structType.(BACnetConstructedDataMinimumValue); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConstructedDataMinimumValue); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConstructedData); ok {
+ return CastBACnetConstructedDataMinimumValue(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConstructedData); ok {
+ return CastBACnetConstructedDataMinimumValue(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetConstructedDataMinimumValue) GetTypeName() string {
+ return "BACnetConstructedDataMinimumValue"
+}
+
+func (m *BACnetConstructedDataMinimumValue) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetConstructedDataMinimumValue) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (minimumValue)
+ lengthInBits += m.MinimumValue.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetConstructedDataMinimumValue) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetConstructedDataMinimumValueParse(readBuffer utils.ReadBuffer, tagNumber uint8, objectTypeArgument BACnetObjectType, propertyIdentifierArgument BACnetPropertyIdentifier) (*BACnetConstructedDataMinimumValue, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetConstructedDataMinimumValue"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (minimumValue)
+ if pullErr := readBuffer.PullContext("minimumValue"); pullErr != nil {
+ return nil, pullErr
+ }
+ _minimumValue, _minimumValueErr := BACnetApplicationTagParse(readBuffer)
+ if _minimumValueErr != nil {
+ return nil, errors.Wrap(_minimumValueErr, "Error parsing 'minimumValue' field")
+ }
+ minimumValue := CastBACnetApplicationTagReal(_minimumValue)
+ if closeErr := readBuffer.CloseContext("minimumValue"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetConstructedDataMinimumValue"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetConstructedDataMinimumValue{
+ MinimumValue: CastBACnetApplicationTagReal(minimumValue),
+ BACnetConstructedData: &BACnetConstructedData{},
+ }
+ _child.BACnetConstructedData.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetConstructedDataMinimumValue) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetConstructedDataMinimumValue"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (minimumValue)
+ if pushErr := writeBuffer.PushContext("minimumValue"); pushErr != nil {
+ return pushErr
+ }
+ _minimumValueErr := m.MinimumValue.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("minimumValue"); popErr != nil {
+ return popErr
+ }
+ if _minimumValueErr != nil {
+ return errors.Wrap(_minimumValueErr, "Error serializing 'minimumValue' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetConstructedDataMinimumValue"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetConstructedDataMinimumValue) 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/BACnetConstructedDataPositiveAccessRules.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataPositiveAccessRules.go
new file mode 100644
index 0000000000..bc8781548f
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataPositiveAccessRules.go
@@ -0,0 +1,226 @@
+/*
+ * 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.
+
+// BACnetConstructedDataPositiveAccessRules is the data-structure of this message
+type BACnetConstructedDataPositiveAccessRules struct {
+ *BACnetConstructedData
+ PositiveAccessRules []*BACnetAccessRule
+
+ // Arguments.
+ TagNumber uint8
+}
+
+// IBACnetConstructedDataPositiveAccessRules is the corresponding interface of BACnetConstructedDataPositiveAccessRules
+type IBACnetConstructedDataPositiveAccessRules interface {
+ IBACnetConstructedData
+ // GetPositiveAccessRules returns PositiveAccessRules (property field)
+ GetPositiveAccessRules() []*BACnetAccessRule
+ // 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 *BACnetConstructedDataPositiveAccessRules) GetObjectTypeArgument() BACnetObjectType {
+ return 0
+}
+
+func (m *BACnetConstructedDataPositiveAccessRules) GetPropertyIdentifierArgument() BACnetPropertyIdentifier {
+ return BACnetPropertyIdentifier_POSITIVE_ACCESS_RULES
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+func (m *BACnetConstructedDataPositiveAccessRules) InitializeParent(parent *BACnetConstructedData, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag) {
+ m.BACnetConstructedData.OpeningTag = openingTag
+ m.BACnetConstructedData.ClosingTag = closingTag
+}
+
+func (m *BACnetConstructedDataPositiveAccessRules) GetParent() *BACnetConstructedData {
+ return m.BACnetConstructedData
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetConstructedDataPositiveAccessRules) GetPositiveAccessRules() []*BACnetAccessRule {
+ return m.PositiveAccessRules
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetConstructedDataPositiveAccessRules factory function for BACnetConstructedDataPositiveAccessRules
+func NewBACnetConstructedDataPositiveAccessRules(positiveAccessRules []*BACnetAccessRule, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag, tagNumber uint8) *BACnetConstructedDataPositiveAccessRules {
+ _result := &BACnetConstructedDataPositiveAccessRules{
+ PositiveAccessRules: positiveAccessRules,
+ BACnetConstructedData: NewBACnetConstructedData(openingTag, closingTag, tagNumber),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetConstructedDataPositiveAccessRules(structType interface{}) *BACnetConstructedDataPositiveAccessRules {
+ if casted, ok := structType.(BACnetConstructedDataPositiveAccessRules); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConstructedDataPositiveAccessRules); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConstructedData); ok {
+ return CastBACnetConstructedDataPositiveAccessRules(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConstructedData); ok {
+ return CastBACnetConstructedDataPositiveAccessRules(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetConstructedDataPositiveAccessRules) GetTypeName() string {
+ return "BACnetConstructedDataPositiveAccessRules"
+}
+
+func (m *BACnetConstructedDataPositiveAccessRules) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetConstructedDataPositiveAccessRules) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Array field
+ if len(m.PositiveAccessRules) > 0 {
+ for _, element := range m.PositiveAccessRules {
+ lengthInBits += element.GetLengthInBits()
+ }
+ }
+
+ return lengthInBits
+}
+
+func (m *BACnetConstructedDataPositiveAccessRules) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetConstructedDataPositiveAccessRulesParse(readBuffer utils.ReadBuffer, tagNumber uint8, objectTypeArgument BACnetObjectType, propertyIdentifierArgument BACnetPropertyIdentifier) (*BACnetConstructedDataPositiveAccessRules, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetConstructedDataPositiveAccessRules"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Array field (positiveAccessRules)
+ if pullErr := readBuffer.PullContext("positiveAccessRules", utils.WithRenderAsList(true)); pullErr != nil {
+ return nil, pullErr
+ }
+ // Terminated array
+ positiveAccessRules := make([]*BACnetAccessRule, 0)
+ {
+ for !bool(IsBACnetConstructedDataClosingTag(readBuffer, false, tagNumber)) {
+ _item, _err := BACnetAccessRuleParse(readBuffer)
+ if _err != nil {
+ return nil, errors.Wrap(_err, "Error parsing 'positiveAccessRules' field")
+ }
+ positiveAccessRules = append(positiveAccessRules, CastBACnetAccessRule(_item))
+
+ }
+ }
+ if closeErr := readBuffer.CloseContext("positiveAccessRules", utils.WithRenderAsList(true)); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetConstructedDataPositiveAccessRules"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetConstructedDataPositiveAccessRules{
+ PositiveAccessRules: positiveAccessRules,
+ BACnetConstructedData: &BACnetConstructedData{},
+ }
+ _child.BACnetConstructedData.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetConstructedDataPositiveAccessRules) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetConstructedDataPositiveAccessRules"); pushErr != nil {
+ return pushErr
+ }
+
+ // Array Field (positiveAccessRules)
+ if m.PositiveAccessRules != nil {
+ if pushErr := writeBuffer.PushContext("positiveAccessRules", utils.WithRenderAsList(true)); pushErr != nil {
+ return pushErr
+ }
+ for _, _element := range m.PositiveAccessRules {
+ _elementErr := _element.Serialize(writeBuffer)
+ if _elementErr != nil {
+ return errors.Wrap(_elementErr, "Error serializing 'positiveAccessRules' field")
+ }
+ }
+ if popErr := writeBuffer.PopContext("positiveAccessRules", utils.WithRenderAsList(true)); popErr != nil {
+ return popErr
+ }
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetConstructedDataPositiveAccessRules"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetConstructedDataPositiveAccessRules) 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/BACnetConstructedDataRepresents.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataRepresents.go
new file mode 100644
index 0000000000..6c0a88e48e
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataRepresents.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.
+
+// BACnetConstructedDataRepresents is the data-structure of this message
+type BACnetConstructedDataRepresents struct {
+ *BACnetConstructedData
+ Represents *BACnetDeviceObjectReference
+
+ // Arguments.
+ TagNumber uint8
+}
+
+// IBACnetConstructedDataRepresents is the corresponding interface of BACnetConstructedDataRepresents
+type IBACnetConstructedDataRepresents interface {
+ IBACnetConstructedData
+ // GetRepresents returns Represents (property field)
+ GetRepresents() *BACnetDeviceObjectReference
+ // 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 *BACnetConstructedDataRepresents) GetObjectTypeArgument() BACnetObjectType {
+ return 0
+}
+
+func (m *BACnetConstructedDataRepresents) GetPropertyIdentifierArgument() BACnetPropertyIdentifier {
+ return BACnetPropertyIdentifier_REPRESENTS
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+func (m *BACnetConstructedDataRepresents) InitializeParent(parent *BACnetConstructedData, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag) {
+ m.BACnetConstructedData.OpeningTag = openingTag
+ m.BACnetConstructedData.ClosingTag = closingTag
+}
+
+func (m *BACnetConstructedDataRepresents) GetParent() *BACnetConstructedData {
+ return m.BACnetConstructedData
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetConstructedDataRepresents) GetRepresents() *BACnetDeviceObjectReference {
+ return m.Represents
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetConstructedDataRepresents factory function for BACnetConstructedDataRepresents
+func NewBACnetConstructedDataRepresents(represents *BACnetDeviceObjectReference, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag, tagNumber uint8) *BACnetConstructedDataRepresents {
+ _result := &BACnetConstructedDataRepresents{
+ Represents: represents,
+ BACnetConstructedData: NewBACnetConstructedData(openingTag, closingTag, tagNumber),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetConstructedDataRepresents(structType interface{}) *BACnetConstructedDataRepresents {
+ if casted, ok := structType.(BACnetConstructedDataRepresents); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConstructedDataRepresents); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConstructedData); ok {
+ return CastBACnetConstructedDataRepresents(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConstructedData); ok {
+ return CastBACnetConstructedDataRepresents(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetConstructedDataRepresents) GetTypeName() string {
+ return "BACnetConstructedDataRepresents"
+}
+
+func (m *BACnetConstructedDataRepresents) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetConstructedDataRepresents) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (represents)
+ lengthInBits += m.Represents.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetConstructedDataRepresents) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetConstructedDataRepresentsParse(readBuffer utils.ReadBuffer, tagNumber uint8, objectTypeArgument BACnetObjectType, propertyIdentifierArgument BACnetPropertyIdentifier) (*BACnetConstructedDataRepresents, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetConstructedDataRepresents"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (represents)
+ if pullErr := readBuffer.PullContext("represents"); pullErr != nil {
+ return nil, pullErr
+ }
+ _represents, _representsErr := BACnetDeviceObjectReferenceParse(readBuffer)
+ if _representsErr != nil {
+ return nil, errors.Wrap(_representsErr, "Error parsing 'represents' field")
+ }
+ represents := CastBACnetDeviceObjectReference(_represents)
+ if closeErr := readBuffer.CloseContext("represents"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetConstructedDataRepresents"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetConstructedDataRepresents{
+ Represents: CastBACnetDeviceObjectReference(represents),
+ BACnetConstructedData: &BACnetConstructedData{},
+ }
+ _child.BACnetConstructedData.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetConstructedDataRepresents) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetConstructedDataRepresents"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (represents)
+ if pushErr := writeBuffer.PushContext("represents"); pushErr != nil {
+ return pushErr
+ }
+ _representsErr := m.Represents.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("represents"); popErr != nil {
+ return popErr
+ }
+ if _representsErr != nil {
+ return errors.Wrap(_representsErr, "Error serializing 'represents' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetConstructedDataRepresents"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetConstructedDataRepresents) 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/BACnetEventTransitionBitsApplication.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetEventTransitionBitsApplication.go
deleted file mode 100644
index 906a70f69c..0000000000
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetEventTransitionBitsApplication.go
+++ /dev/null
@@ -1,220 +0,0 @@
-/*
- * 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.
-
-// BACnetEventTransitionBitsApplication is the data-structure of this message
-type BACnetEventTransitionBitsApplication struct {
- RawBits *BACnetApplicationTagBitString
-}
-
-// IBACnetEventTransitionBitsApplication is the corresponding interface of BACnetEventTransitionBitsApplication
-type IBACnetEventTransitionBitsApplication interface {
- // GetRawBits returns RawBits (property field)
- GetRawBits() *BACnetApplicationTagBitString
- // GetToOffnormal returns ToOffnormal (virtual field)
- GetToOffnormal() bool
- // GetToFault returns ToFault (virtual field)
- GetToFault() bool
- // GetToNormal returns ToNormal (virtual field)
- GetToNormal() 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
-}
-
-///////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////
-/////////////////////// Accessors for property fields.
-///////////////////////
-
-func (m *BACnetEventTransitionBitsApplication) GetRawBits() *BACnetApplicationTagBitString {
- return m.RawBits
-}
-
-///////////////////////
-///////////////////////
-///////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////
-/////////////////////// Accessors for virtual fields.
-///////////////////////
-
-func (m *BACnetEventTransitionBitsApplication) GetToOffnormal() bool {
- return bool(m.GetRawBits().GetPayload().GetData()[0])
-}
-
-func (m *BACnetEventTransitionBitsApplication) GetToFault() bool {
- return bool(m.GetRawBits().GetPayload().GetData()[1])
-}
-
-func (m *BACnetEventTransitionBitsApplication) GetToNormal() bool {
- return bool(m.GetRawBits().GetPayload().GetData()[2])
-}
-
-///////////////////////
-///////////////////////
-///////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////
-
-// NewBACnetEventTransitionBitsApplication factory function for BACnetEventTransitionBitsApplication
-func NewBACnetEventTransitionBitsApplication(rawBits *BACnetApplicationTagBitString) *BACnetEventTransitionBitsApplication {
- return &BACnetEventTransitionBitsApplication{RawBits: rawBits}
-}
-
-func CastBACnetEventTransitionBitsApplication(structType interface{}) *BACnetEventTransitionBitsApplication {
- if casted, ok := structType.(BACnetEventTransitionBitsApplication); ok {
- return &casted
- }
- if casted, ok := structType.(*BACnetEventTransitionBitsApplication); ok {
- return casted
- }
- return nil
-}
-
-func (m *BACnetEventTransitionBitsApplication) GetTypeName() string {
- return "BACnetEventTransitionBitsApplication"
-}
-
-func (m *BACnetEventTransitionBitsApplication) GetLengthInBits() uint16 {
- return m.GetLengthInBitsConditional(false)
-}
-
-func (m *BACnetEventTransitionBitsApplication) GetLengthInBitsConditional(lastItem bool) uint16 {
- lengthInBits := uint16(0)
-
- // Simple field (rawBits)
- lengthInBits += m.RawBits.GetLengthInBits()
-
- // A virtual field doesn't have any in- or output.
-
- // A virtual field doesn't have any in- or output.
-
- // A virtual field doesn't have any in- or output.
-
- return lengthInBits
-}
-
-func (m *BACnetEventTransitionBitsApplication) GetLengthInBytes() uint16 {
- return m.GetLengthInBits() / 8
-}
-
-func BACnetEventTransitionBitsApplicationParse(readBuffer utils.ReadBuffer) (*BACnetEventTransitionBitsApplication, error) {
- positionAware := readBuffer
- _ = positionAware
- if pullErr := readBuffer.PullContext("BACnetEventTransitionBitsApplication"); pullErr != nil {
- return nil, pullErr
- }
- currentPos := positionAware.GetPos()
- _ = currentPos
-
- // Simple Field (rawBits)
- if pullErr := readBuffer.PullContext("rawBits"); pullErr != nil {
- return nil, pullErr
- }
- _rawBits, _rawBitsErr := BACnetApplicationTagParse(readBuffer)
- if _rawBitsErr != nil {
- return nil, errors.Wrap(_rawBitsErr, "Error parsing 'rawBits' field")
- }
- rawBits := CastBACnetApplicationTagBitString(_rawBits)
- if closeErr := readBuffer.CloseContext("rawBits"); closeErr != nil {
- return nil, closeErr
- }
-
- // Virtual field
- _toOffnormal := rawBits.GetPayload().GetData()[0]
- toOffnormal := bool(_toOffnormal)
- _ = toOffnormal
-
- // Virtual field
- _toFault := rawBits.GetPayload().GetData()[1]
- toFault := bool(_toFault)
- _ = toFault
-
- // Virtual field
- _toNormal := rawBits.GetPayload().GetData()[2]
- toNormal := bool(_toNormal)
- _ = toNormal
-
- if closeErr := readBuffer.CloseContext("BACnetEventTransitionBitsApplication"); closeErr != nil {
- return nil, closeErr
- }
-
- // Create the instance
- return NewBACnetEventTransitionBitsApplication(rawBits), nil
-}
-
-func (m *BACnetEventTransitionBitsApplication) Serialize(writeBuffer utils.WriteBuffer) error {
- positionAware := writeBuffer
- _ = positionAware
- if pushErr := writeBuffer.PushContext("BACnetEventTransitionBitsApplication"); pushErr != nil {
- return pushErr
- }
-
- // Simple Field (rawBits)
- if pushErr := writeBuffer.PushContext("rawBits"); pushErr != nil {
- return pushErr
- }
- _rawBitsErr := m.RawBits.Serialize(writeBuffer)
- if popErr := writeBuffer.PopContext("rawBits"); popErr != nil {
- return popErr
- }
- if _rawBitsErr != nil {
- return errors.Wrap(_rawBitsErr, "Error serializing 'rawBits' field")
- }
- // Virtual field
- if _toOffnormalErr := writeBuffer.WriteVirtual("toOffnormal", m.GetToOffnormal()); _toOffnormalErr != nil {
- return errors.Wrap(_toOffnormalErr, "Error serializing 'toOffnormal' field")
- }
- // Virtual field
- if _toFaultErr := writeBuffer.WriteVirtual("toFault", m.GetToFault()); _toFaultErr != nil {
- return errors.Wrap(_toFaultErr, "Error serializing 'toFault' field")
- }
- // Virtual field
- if _toNormalErr := writeBuffer.WriteVirtual("toNormal", m.GetToNormal()); _toNormalErr != nil {
- return errors.Wrap(_toNormalErr, "Error serializing 'toNormal' field")
- }
-
- if popErr := writeBuffer.PopContext("BACnetEventTransitionBitsApplication"); popErr != nil {
- return popErr
- }
- return nil
-}
-
-func (m *BACnetEventTransitionBitsApplication) 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/knxnetip/readwrite/model/KnxManufacturer.go b/plc4go/protocols/knxnetip/readwrite/model/KnxManufacturer.go
index 7246404c5f..33ba6f2ebb 100644
--- a/plc4go/protocols/knxnetip/readwrite/model/KnxManufacturer.go
+++ b/plc4go/protocols/knxnetip/readwrite/model/KnxManufacturer.go
@@ -624,8 +624,9 @@ const (
KnxManufacturer_M_HEFEI_CHUANG_YUE_INTELLIGENT_TECHNOLOGY_CO__LTD KnxManufacturer = 585
KnxManufacturer_M_LARFE KnxManufacturer = 586
KnxManufacturer_M_DONGGUAN_MUHCCI_ELECTRICAL KnxManufacturer = 587
- KnxManufacturer_M_ABB___RESERVED KnxManufacturer = 588
- KnxManufacturer_M_BUSCH_JAEGER_ELEKTRO___RESERVED KnxManufacturer = 589
+ KnxManufacturer_M_STEC KnxManufacturer = 588
+ KnxManufacturer_M_ABB___RESERVED KnxManufacturer = 589
+ KnxManufacturer_M_BUSCH_JAEGER_ELEKTRO___RESERVED KnxManufacturer = 590
)
var KnxManufacturerValues []KnxManufacturer
@@ -1221,6 +1222,7 @@ func init() {
KnxManufacturer_M_HEFEI_CHUANG_YUE_INTELLIGENT_TECHNOLOGY_CO__LTD,
KnxManufacturer_M_LARFE,
KnxManufacturer_M_DONGGUAN_MUHCCI_ELECTRICAL,
+ KnxManufacturer_M_STEC,
KnxManufacturer_M_ABB___RESERVED,
KnxManufacturer_M_BUSCH_JAEGER_ELEKTRO___RESERVED,
}
@@ -3402,16 +3404,20 @@ func (e KnxManufacturer) Number() uint16 {
}
case 588:
{ /* '588' */
- return 43954
+ return 646
}
case 589:
{ /* '589' */
- return 43959
+ return 43954
}
case 59:
{ /* '59' */
return 98
}
+ case 590:
+ { /* '590' */
+ return 43959
+ }
case 6:
{ /* '6' */
return 7
@@ -5780,16 +5786,20 @@ func (e KnxManufacturer) Name() string {
}
case 588:
{ /* '588' */
- return "ABB - reserved"
+ return "STEC"
}
case 589:
{ /* '589' */
- return "Busch-Jaeger Elektro - reserved"
+ return "ABB - reserved"
}
case 59:
{ /* '59' */
return "Electrak"
}
+ case 590:
+ { /* '590' */
+ return "Busch-Jaeger Elektro - reserved"
+ }
case 6:
{ /* '6' */
return "Busch-Jaeger Elektro"
@@ -7070,11 +7080,13 @@ func KnxManufacturerByValue(value uint16) KnxManufacturer {
case 587:
return KnxManufacturer_M_DONGGUAN_MUHCCI_ELECTRICAL
case 588:
- return KnxManufacturer_M_ABB___RESERVED
+ return KnxManufacturer_M_STEC
case 589:
- return KnxManufacturer_M_BUSCH_JAEGER_ELEKTRO___RESERVED
+ return KnxManufacturer_M_ABB___RESERVED
case 59:
return KnxManufacturer_M_ELECTRAK
+ case 590:
+ return KnxManufacturer_M_BUSCH_JAEGER_ELEKTRO___RESERVED
case 6:
return KnxManufacturer_M_BUSCH_JAEGER_ELEKTRO
case 60:
@@ -8255,12 +8267,14 @@ func KnxManufacturerByName(value string) KnxManufacturer {
return KnxManufacturer_M_LARFE
case "M_DONGGUAN_MUHCCI_ELECTRICAL":
return KnxManufacturer_M_DONGGUAN_MUHCCI_ELECTRICAL
+ case "M_STEC":
+ return KnxManufacturer_M_STEC
case "M_ABB___RESERVED":
return KnxManufacturer_M_ABB___RESERVED
- case "M_BUSCH_JAEGER_ELEKTRO___RESERVED":
- return KnxManufacturer_M_BUSCH_JAEGER_ELEKTRO___RESERVED
case "M_ELECTRAK":
return KnxManufacturer_M_ELECTRAK
+ case "M_BUSCH_JAEGER_ELEKTRO___RESERVED":
+ return KnxManufacturer_M_BUSCH_JAEGER_ELEKTRO___RESERVED
case "M_BUSCH_JAEGER_ELEKTRO":
return KnxManufacturer_M_BUSCH_JAEGER_ELEKTRO
case "M_TECHEM":
@@ -9480,12 +9494,14 @@ func (e KnxManufacturer) name() string {
return "M_LARFE"
case KnxManufacturer_M_DONGGUAN_MUHCCI_ELECTRICAL:
return "M_DONGGUAN_MUHCCI_ELECTRICAL"
+ case KnxManufacturer_M_STEC:
+ return "M_STEC"
case KnxManufacturer_M_ABB___RESERVED:
return "M_ABB___RESERVED"
- case KnxManufacturer_M_BUSCH_JAEGER_ELEKTRO___RESERVED:
- return "M_BUSCH_JAEGER_ELEKTRO___RESERVED"
case KnxManufacturer_M_ELECTRAK:
return "M_ELECTRAK"
+ case KnxManufacturer_M_BUSCH_JAEGER_ELEKTRO___RESERVED:
+ return "M_BUSCH_JAEGER_ELEKTRO___RESERVED"
case KnxManufacturer_M_BUSCH_JAEGER_ELEKTRO:
return "M_BUSCH_JAEGER_ELEKTRO"
case KnxManufacturer_M_TECHEM:
diff --git a/protocols/bacnetip/src/main/resources/protocols/bacnetip/bacnet-private-enums.mspec b/protocols/bacnetip/src/main/resources/protocols/bacnetip/bacnet-private-enums.mspec
index 8d2a45d4d6..5f7eb3e7d0 100644
--- a/protocols/bacnetip/src/main/resources/protocols/bacnetip/bacnet-private-enums.mspec
+++ b/protocols/bacnetip/src/main/resources/protocols/bacnetip/bacnet-private-enums.mspec
@@ -30,6 +30,18 @@
['2' SOFT_PASSBACK ]
]
+// Attention: No proprietary extension allowed
+[enum uint 8 BACnetAccessRuleLocationSpecifier
+ ['0' SPECIFIED ]
+ ['1' ALL ]
+]
+
+// Attention: No proprietary extension allowed
+[enum uint 8 BACnetAccessRuleTimeRangeSpecifier
+ ['0' SPECIFIED ]
+ ['1' ALWAYS ]
+]
+
// Attention: No proprietary extension allowed
[enum uint 8 BACnetAuthenticationFactorType
['0' UNDEFINED ]
diff --git a/protocols/bacnetip/src/main/resources/protocols/bacnetip/bacnetip.mspec b/protocols/bacnetip/src/main/resources/protocols/bacnetip/bacnetip.mspec
index 1c26ec4e3a..9f608893c0 100644
--- a/protocols/bacnetip/src/main/resources/protocols/bacnetip/bacnetip.mspec
+++ b/protocols/bacnetip/src/main/resources/protocols/bacnetip/bacnetip.mspec
@@ -2557,7 +2557,9 @@
//[*, 'BACNET_IPV6_UDP_PORT' BACnetConstructedDataBACnetIpV6UdpPort [validation '1 == 2' "TODO: implement me BACNET_IPV6_UDP_PORT BACnetConstructedDataBACnetIpV6UdpPort"]]
//[*, 'BACNET_IPV6_MULTICAST_ADDRESS' BACnetConstructedDataBACnetIpV6MulticastAddress [validation '1 == 2' "TODO: implement me BACNET_IPV6_MULTICAST_ADDRESS BACnetConstructedDataBACnetIpV6MulticastAddress"]]
//[*, 'BASE_DEVICE_SECURITY_POLICY' BACnetConstructedDataBaseDeviceSecurityPolicy [validation '1 == 2' "TODO: implement me BASE_DEVICE_SECURITY_POLICY BACnetConstructedDataBaseDeviceSecurityPolicy"]]
- //[*, 'BBMD_ACCEPT_FD_REGISTRATIONS' BACnetConstructedDataBBMDAcceptFDRegistrations [validation '1 == 2' "TODO: implement me BBMD_ACCEPT_FD_REGISTRATIONS BACnetConstructedDataBBMDAcceptFDRegistrations"]]
+ [*, 'BBMD_ACCEPT_FD_REGISTRATIONS' BACnetConstructedDataBBMDAcceptFDRegistrations
+ [simple BACnetApplicationTagBoolean bbmdAcceptFDRegistrations ]
+ ]
//[*, 'BBMD_BROADCAST_DISTRIBUTION_TABLE' BACnetConstructedDataBBMDBroadcastDistributionTable [validation '1 == 2' "TODO: implement me BBMD_BROADCAST_DISTRIBUTION_TABLE BACnetConstructedDataBBMDBroadcastDistributionTable"]]
//[*, 'BBMD_FOREIGN_DEVICE_TABLE' BACnetConstructedDataBBMDForeignDeviceTable [validation '1 == 2' "TODO: implement me BBMD_FOREIGN_DEVICE_TABLE BACnetConstructedDataBBMDForeignDeviceTable"]]
//[*, 'BELONGS_TO' BACnetConstructedDataBelongsTo [validation '1 == 2' "TODO: implement me BELONGS_TO BACnetConstructedDataBelongsTo"]]
@@ -2749,20 +2751,24 @@
//[*, 'IP_ADDRESS' BACnetConstructedDataIpAddress [validation '1 == 2' "TODO: implement me IP_ADDRESS BACnetConstructedDataIpAddress"]]
//[*, 'IP_DEFAULT_GATEWAY' BACnetConstructedDataIpDefaultGateway [validation '1 == 2' "TODO: implement me IP_DEFAULT_GATEWAY BACnetConstructedDataIpDefaultGateway"]]
//[*, 'IP_DHCP_ENABLE' BACnetConstructedDataIpDhcpEnable [validation '1 == 2' "TODO: implement me IP_DHCP_ENABLE BACnetConstructedDataIpDhcpEnable"]]
- //[*, 'IP_DHCP_LEASE_TIME' BACnetConstructedDataIpDhcpLeaseTime [validation '1 == 2' "TODO: implement me IP_DHCP_LEASE_TIME BACnetConstructedDataIpDhcpLeaseTime"]]
- //[*, 'IP_DHCP_LEASE_TIME_REMAINING' BACnetConstructedDataIpDhcpLeaseTimeRemaining [validation '1 == 2' "TODO: implement me IP_DHCP_LEASE_TIME_REMAINING BACnetConstructedDataIpDhcpLeaseTimeRemaining"]]
+ //[*, 'IP_DHCP_LEASE_TIME' BACnetConstructedDataIPDHCLeaseTime [validation '1 == 2' "TODO: implement me IP_DHCP_LEASE_TIME BACnetConstructedDataIpDhcpLeaseTime"]]
+ [*, 'IP_DHCP_LEASE_TIME_REMAINING' BACnetConstructedDataIPDHCPLeaseTimeRemaining
+ [simple BACnetApplicationTagUnsignedInteger ipDhcpLeaseTimeRemaining ]
+ ]
//[*, 'IP_DHCP_SERVER' BACnetConstructedDataIpDhcpServer [validation '1 == 2' "TODO: implement me IP_DHCP_SERVER BACnetConstructedDataIpDhcpServer"]]
//[*, 'IP_DNS_SERVER' BACnetConstructedDataIpDnsServer [validation '1 == 2' "TODO: implement me IP_DNS_SERVER BACnetConstructedDataIpDnsServer"]]
//[*, 'IP_SUBNET_MASK' BACnetConstructedDataIpSubnetMask [validation '1 == 2' "TODO: implement me IP_SUBNET_MASK BACnetConstructedDataIpSubnetMask"]]
- //[*, 'IPV6_ADDRESS' BACnetConstructedDataIpv6Address [validation '1 == 2' "TODO: implement me IPV6_ADDRESS BACnetConstructedDataIpv6Address"]]
- //[*, 'IPV6_AUTO_ADDRESSING_ENABLE' BACnetConstructedDataIpv6AutoAddressingEnable [validation '1 == 2' "TODO: implement me IPV6_AUTO_ADDRESSING_ENABLE BACnetConstructedDataIpv6AutoAddressingEnable"]]
- //[*, 'IPV6_DEFAULT_GATEWAY' BACnetConstructedDataIpv6DefaultGateway [validation '1 == 2' "TODO: implement me IPV6_DEFAULT_GATEWAY BACnetConstructedDataIpv6DefaultGateway"]]
- //[*, 'IPV6_DHCP_LEASE_TIME' BACnetConstructedDataIpv6DhcpLeaseTime [validation '1 == 2' "TODO: implement me IPV6_DHCP_LEASE_TIME BACnetConstructedDataIpv6DhcpLeaseTime"]]
- //[*, 'IPV6_DHCP_LEASE_TIME_REMAINING' BACnetConstructedDataIpv6DhcpLeaseTimeRemaining [validation '1 == 2' "TODO: implement me IPV6_DHCP_LEASE_TIME_REMAINING BACnetConstructedDataIpv6DhcpLeaseTimeRemaining"]]
- //[*, 'IPV6_DHCP_SERVER' BACnetConstructedDataIpv6DhcpServer [validation '1 == 2' "TODO: implement me IPV6_DHCP_SERVER BACnetConstructedDataIpv6DhcpServer"]]
- //[*, 'IPV6_DNS_SERVER' BACnetConstructedDataIpv6DnsServer [validation '1 == 2' "TODO: implement me IPV6_DNS_SERVER BACnetConstructedDataIpv6DnsServer"]]
- //[*, 'IPV6_PREFIX_LENGTH' BACnetConstructedDataIpv6PrefixLength [validation '1 == 2' "TODO: implement me IPV6_PREFIX_LENGTH BACnetConstructedDataIpv6PrefixLength"]]
- //[*, 'IPV6_ZONE_INDEX' BACnetConstructedDataIpv6ZoneIndex [validation '1 == 2' "TODO: implement me IPV6_ZONE_INDEX BACnetConstructedDataIpv6ZoneIndex"]]
+ //[*, 'IPV6_ADDRESS' BACnetConstructedDataIPv6Address [validation '1 == 2' "TODO: implement me IPV6_ADDRESS BACnetConstructedDataIpv6Address"]]
+ //[*, 'IPV6_AUTO_ADDRESSING_ENABLE' BACnetConstructedDataIPv6AutoAddressingEnable [validation '1 == 2' "TODO: implement me IPV6_AUTO_ADDRESSING_ENABLE BACnetConstructedDataIpv6AutoAddressingEnable"]]
+ //[*, 'IPV6_DEFAULT_GATEWAY' BACnetConstructedDataIPv6DefaultGateway [validation '1 == 2' "TODO: implement me IPV6_DEFAULT_GATEWAY BACnetConstructedDataIpv6DefaultGateway"]]
+ //[*, 'IPV6_DHCP_LEASE_TIME' BACnetConstructedDataIPv6DhcpLeaseTime [validation '1 == 2' "TODO: implement me IPV6_DHCP_LEASE_TIME BACnetConstructedDataIpv6DhcpLeaseTime"]]
+ [*, 'IPV6_DHCP_LEASE_TIME_REMAINING' BACnetConstructedDataIPv6DHCPLeaseTimeRemaining
+ [simple BACnetApplicationTagUnsignedInteger ipv6DhcpLeaseTimeRemaining ]
+ ]
+ //[*, 'IPV6_DHCP_SERVER' BACnetConstructedDataIPv6DhcpServer [validation '1 == 2' "TODO: implement me IPV6_DHCP_SERVER BACnetConstructedDataIpv6DhcpServer"]]
+ //[*, 'IPV6_DNS_SERVER' BACnetConstructedDataIPv6DnsServer [validation '1 == 2' "TODO: implement me IPV6_DNS_SERVER BACnetConstructedDataIpv6DnsServer"]]
+ //[*, 'IPV6_PREFIX_LENGTH' BACnetConstructedDataIPv6PrefixLength [validation '1 == 2' "TODO: implement me IPV6_PREFIX_LENGTH BACnetConstructedDataIpv6PrefixLength"]]
+ //[*, 'IPV6_ZONE_INDEX' BACnetConstructedDataIPv6ZoneIndex [validation '1 == 2' "TODO: implement me IPV6_ZONE_INDEX BACnetConstructedDataIpv6ZoneIndex"]]
//[*, 'IS_UTC' BACnetConstructedDataIsUtc [validation '1 == 2' "TODO: implement me IS_UTC BACnetConstructedDataIsUtc"]]
//[*, 'KEY_SETS' BACnetConstructedDataKeySets [validation '1 == 2' "TODO: implement me KEY_SETS BACnetConstructedDataKeySets"]]
//[*, 'LANDING_CALL_CONTROL' BACnetConstructedDataLandingCallControl [validation '1 == 2' "TODO: implement me LANDING_CALL_CONTROL BACnetConstructedDataLandingCallControl"]]
@@ -2828,7 +2834,12 @@
//[*, 'MAINTENANCE_REQUIRED' BACnetConstructedDataMaintenanceRequired [validation '1 == 2' "TODO: implement me MAINTENANCE_REQUIRED BACnetConstructedDataMaintenanceRequired"]]
//[*, 'MAKING_CAR_CALL' BACnetConstructedDataMakingCarCall [validation '1 == 2' "TODO: implement me MAKING_CAR_CALL BACnetConstructedDataMakingCarCall"]]
//[*, 'MANIPULATED_VARIABLE_REFERENCE' BACnetConstructedDataManipulatedVariableReference [validation '1 == 2' "TODO: implement me MANIPULATED_VARIABLE_REFERENCE BACnetConstructedDataManipulatedVariableReference"]]
- //[*, 'MANUAL_SLAVE_ADDRESS_BINDING' BACnetConstructedDataManualSlaveAddressBinding [validation '1 == 2' "TODO: implement me MANUAL_SLAVE_ADDRESS_BINDING BACnetConstructedDataManualSlaveAddressBinding"]]
+ [*, 'MANUAL_SLAVE_ADDRESS_BINDING' BACnetConstructedDataManualSlaveAddressBinding
+ [array BACnetAddressBinding
+ manualSlaveAddressBinding
+ terminated
+ 'STATIC_CALL("isBACnetConstructedDataClosingTag", readBuffer, false, tagNumber)' ]
+ ]
//[*, 'MASKED_ALARM_VALUES' BACnetConstructedDataMaskedAlarmValues [validation '1 == 2' "TODO: implement me MASKED_ALARM_VALUES BACnetConstructedDataMaskedAlarmValues"]]
//[*, 'MAX_ACTUAL_VALUE' BACnetConstructedDataMaxActualValue [validation '1 == 2' "TODO: implement me MAX_ACTUAL_VALUE BACnetConstructedDataMaxActualValue"]]
//[*, 'MAX_APDU_LENGTH_ACCEPTED' BACnetConstructedDataMaxApduLengthAccepted [validation '1 == 2' "TODO: implement me MAX_APDU_LENGTH_ACCEPTED BACnetConstructedDataMaxApduLengthAccepted"]]
@@ -2855,15 +2866,17 @@
//[*, 'MEMBERS' BACnetConstructedDataMembers [validation '1 == 2' "TODO: implement me MEMBERS BACnetConstructedDataMembers"]]
//[*, 'MIN_ACTUAL_VALUE' BACnetConstructedDataMinActualValue [validation '1 == 2' "TODO: implement me MIN_ACTUAL_VALUE BACnetConstructedDataMinActualValue"]]
['ACCUMULATOR', 'MIN_PRES_VALUE' BACnetConstructedDataAccumulatorMinPresValue
- [simple BACnetApplicationTagUnsignedInteger minPresValue ]
+ [simple BACnetApplicationTagUnsignedInteger minPresValue ]
]
[*, 'MIN_PRES_VALUE' BACnetConstructedDataMinPresValue
- [simple BACnetApplicationTagReal minPresValue ]
+ [simple BACnetApplicationTagReal minPresValue ]
]
//[*, 'MINIMUM_OFF_TIME' BACnetConstructedDataMinimumOffTime [validation '1 == 2' "TODO: implement me MINIMUM_OFF_TIME BACnetConstructedDataMinimumOffTime"]]
//[*, 'MINIMUM_ON_TIME' BACnetConstructedDataMinimumOnTime [validation '1 == 2' "TODO: implement me MINIMUM_ON_TIME BACnetConstructedDataMinimumOnTime"]]
//[*, 'MINIMUM_OUTPUT' BACnetConstructedDataMinimumOutput [validation '1 == 2' "TODO: implement me MINIMUM_OUTPUT BACnetConstructedDataMinimumOutput"]]
- //[*, 'MINIMUM_VALUE' BACnetConstructedDataMinimumValue [validation '1 == 2' "TODO: implement me MINIMUM_VALUE BACnetConstructedDataMinimumValue"]]
+ [*, 'MINIMUM_VALUE' BACnetConstructedDataMinimumValue
+ [simple BACnetApplicationTagReal minimumValue ]
+ ]
//[*, 'MINIMUM_VALUE_TIMESTAMP' BACnetConstructedDataMinimumValueTimestamp [validation '1 == 2' "TODO: implement me MINIMUM_VALUE_TIMESTAMP BACnetConstructedDataMinimumValueTimestamp"]]
//[*, 'MODE' BACnetConstructedDataMode [validation '1 == 2' "TODO: implement me MODE BACnetConstructedDataMode"]]
//[*, 'MODEL_NAME' BACnetConstructedDataModelName [validation '1 == 2' "TODO: implement me MODEL_NAME BACnetConstructedDataModelName"]]
@@ -2922,7 +2935,12 @@
//[*, 'PASSENGER_ALARM' BACnetConstructedDataPassengerAlarm [validation '1 == 2' "TODO: implement me PASSENGER_ALARM BACnetConstructedDataPassengerAlarm"]]
//[*, 'POLARITY' BACnetConstructedDataPolarity [validation '1 == 2' "TODO: implement me POLARITY BACnetConstructedDataPolarity"]]
//[*, 'PORT_FILTER' BACnetConstructedDataPortFilter [validation '1 == 2' "TODO: implement me PORT_FILTER BACnetConstructedDataPortFilter"]]
- //[*, 'POSITIVE_ACCESS_RULES' BACnetConstructedDataPositiveAccessRules [validation '1 == 2' "TODO: implement me POSITIVE_ACCESS_RULES BACnetConstructedDataPositiveAccessRules"]]
+ [*, 'POSITIVE_ACCESS_RULES' BACnetConstructedDataPositiveAccessRules
+ [array BACnetAccessRule
+ positiveAccessRules
+ terminated
+ 'STATIC_CALL("isBACnetConstructedDataClosingTag", readBuffer, false, tagNumber)' ]
+ ]
//[*, 'POWER' BACnetConstructedDataPower [validation '1 == 2' "TODO: implement me POWER BACnetConstructedDataPower"]]
//[*, 'POWER_MODE' BACnetConstructedDataPowerMode [validation '1 == 2' "TODO: implement me POWER_MODE BACnetConstructedDataPowerMode"]]
//[*, 'PRESCALE' BACnetConstructedDataPrescale [validation '1 == 2' "TODO: implement me PRESCALE BACnetConstructedDataPrescale"]]
@@ -2978,7 +2996,9 @@
[simple BACnetApplicationTagBoolean reliabilityEvaluationInhibit ]
]
//[*, 'RELINQUISH_DEFAULT' BACnetConstructedDataRelinquishDefault [validation '1 == 2' "TODO: implement me RELINQUISH_DEFAULT BACnetConstructedDataRelinquishDefault"]]
- //[*, 'REPRESENTS' BACnetConstructedDataRepresents [validation '1 == 2' "TODO: implement me REPRESENTS BACnetConstructedDataRepresents"]]
+ [*, 'REPRESENTS' BACnetConstructedDataRepresents
+ [simple BACnetDeviceObjectReference represents ]
+ ]
//[*, 'REQUESTED_SHED_LEVEL' BACnetConstructedDataRequestedShedLevel [validation '1 == 2' "TODO: implement me REQUESTED_SHED_LEVEL BACnetConstructedDataRequestedShedLevel"]]
//[*, 'REQUESTED_UPDATE_INTERVAL' BACnetConstructedDataRequestedUpdateInterval [validation '1 == 2' "TODO: implement me REQUESTED_UPDATE_INTERVAL BACnetConstructedDataRequestedUpdateInterval"]]
//[*, 'REQUIRED' BACnetConstructedDataRequired [validation '1 == 2' "TODO: implement me REQUIRED BACnetConstructedDataRequired"]]
@@ -3222,18 +3242,38 @@
[type BACnetNameValue
[simple BACnetContextTagCharacterString('0', 'BACnetDataType.CHARACTER_STRING')
- name ]
+ name ]
[optional BACnetConstructedData('1', 'BACnetObjectType.VENDOR_PROPRIETARY_VALUE', 'BACnetPropertyIdentifier.VENDOR_PROPRIETARY_VALUE')
- value ]
+ value ]
]
[type BACnetNameValueCollection
- [simple BACnetOpeningTag('0')
- openingTag ]
- [array BACnetNameValue
+ [simple BACnetOpeningTag('0')
+ openingTag ]
+ [array BACnetNameValue
subordinateList
terminated
- 'STATIC_CALL("isBACnetConstructedDataClosingTag", readBuffer, false, 0)' ]
- [simple BACnetClosingTag('0')
- closingTag ]
+ 'STATIC_CALL("isBACnetConstructedDataClosingTag", readBuffer, false, 0)' ]
+ [simple BACnetClosingTag('0')
+ closingTag ]
+]
+
+[type BACnetAddressBinding
+ [simple BACnetApplicationTagObjectIdentifier
+ deviceIdentifier ]
+ [simple BACnetAddress
+ deviceAddress ]
+]
+
+[type BACnetAccessRule
+ [simple BACnetAccessRuleTimeRangeSpecifierTagged('0', 'TagClass.CONTEXT_SPECIFIC_TAGS')
+ timeRangeSpecifier ]
+ [optional BACnetDeviceObjectPropertyReferenceEnclosed('1')
+ timeRange 'timeRangeSpecifier!=null' ]
+ [simple BACnetAccessRuleLocationSpecifierTagged('2', 'TagClass.CONTEXT_SPECIFIC_TAGS')
+ locationSpecifier ]
+ [optional BACnetDeviceObjectReferenceEnclosed('3')
+ location 'locationSpecifier!=null' ]
+ [simple BACnetContextTagBoolean('4', 'BACnetDataType.BOOLEAN')
+ enable ]
]
diff --git a/protocols/bacnetip/src/test/java/org/apache/plc4x/protocol/bacnetip/ObjectPropertyDeDuplicationTest.java b/protocols/bacnetip/src/test/java/org/apache/plc4x/protocol/bacnetip/ObjectPropertyDeDuplicationTest.java
index d1fb7a5f45..dfbcb6f97d 100644
--- a/protocols/bacnetip/src/test/java/org/apache/plc4x/protocol/bacnetip/ObjectPropertyDeDuplicationTest.java
+++ b/protocols/bacnetip/src/test/java/org/apache/plc4x/protocol/bacnetip/ObjectPropertyDeDuplicationTest.java
@@ -97,6 +97,27 @@ public class ObjectPropertyDeDuplicationTest {
return tests;
}
+ @Disabled("disabled till every type is implemented")
+ @TestFactory
+ Collection<DynamicNode> testUniqueUsagesAreMappedGeneric() {
+ List<DynamicNode> tests = new LinkedList<>();
+ propertyToObjectNameMap.forEach((propertyIdentifier, bacNetObjectNames) -> {
+ if (bacNetObjectNames.size() > 1) {
+ return;
+ }
+ String bacNetObjectName = bacNetObjectNames.get(0);
+ tests.add(
+ DynamicTest.dynamicTest("Unique property " + propertyIdentifier + " for " + bacNetObjectName,
+ () -> {
+ String searchedTypeName = "BACnetConstructedData" + propertyIdentifier;
+ searchedTypeName = searchedTypeName.replaceAll("_", "");
+ assertNotNull(typeDefinitions.get(searchedTypeName), searchedTypeName + " not found");
+ })
+ );
+ });
+ return tests;
+ }
+
@Nested
@Tag("just-output")
class JustOutputs {