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 12:01:05 UTC
[plc4x] branch develop updated: feat(bacnet): implemented unique properties for access user object type
This is an automated email from the ASF dual-hosted git repository.
sruehl pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/plc4x.git
The following commit(s) were added to refs/heads/develop by this push:
new 737d0787b2 feat(bacnet): implemented unique properties for access user object type
737d0787b2 is described below
commit 737d0787b201b74c2e472ac52ac27f0db8e116c6
Author: Sebastian Rühl <sr...@apache.org>
AuthorDate: Fri Jun 3 14:00:58 2022 +0200
feat(bacnet): implemented unique properties for access user object type
- CREDENTIALS
- MEMBERS
- USER_EXTERNAL_IDENTIFIER
- USER_INFORMATION_REFERENCE
- USER_NAME
- USER_TYPE
---
.../readwrite/model/BACnetConstructedData.go | 12 ++
.../model/BACnetConstructedDataCredentials.go | 226 +++++++++++++++++++++
.../model/BACnetConstructedDataMembers.go | 226 +++++++++++++++++++++
.../BACnetConstructedDataUserExternalIdentifier.go | 211 +++++++++++++++++++
...ACnetConstructedDataUserInformationReference.go | 211 +++++++++++++++++++
.../model/BACnetConstructedDataUserName.go | 211 +++++++++++++++++++
.../model/BACnetConstructedDataUserType.go | 211 +++++++++++++++++++
.../resources/protocols/bacnetip/bacnetip.mspec | 52 +++--
8 files changed, 1343 insertions(+), 17 deletions(-)
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedData.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedData.go
index cacfe3a19d..858a41aa54 100644
--- a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedData.go
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedData.go
@@ -348,6 +348,8 @@ func BACnetConstructedDataParse(readBuffer utils.ReadBuffer, tagNumber uint8, ob
_child, typeSwitchError = BACnetConstructedDataCredentialDisableParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_CREDENTIAL_STATUS: // BACnetConstructedDataCredentialStatus
_child, typeSwitchError = BACnetConstructedDataCredentialStatusParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
+ case true && propertyIdentifierArgument == BACnetPropertyIdentifier_CREDENTIALS: // BACnetConstructedDataCredentials
+ _child, typeSwitchError = BACnetConstructedDataCredentialsParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_DAYS_REMAINING: // BACnetConstructedDataDaysRemaining
_child, typeSwitchError = BACnetConstructedDataDaysRemainingParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_DEADBAND: // BACnetConstructedDataDeadband
@@ -448,6 +450,8 @@ func BACnetConstructedDataParse(readBuffer utils.ReadBuffer, tagNumber uint8, ob
_child, typeSwitchError = BACnetConstructedDataMaxPresValueParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_MEMBER_OF: // BACnetConstructedDataMemberOf
_child, typeSwitchError = BACnetConstructedDataMemberOfParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
+ case true && propertyIdentifierArgument == BACnetPropertyIdentifier_MEMBERS: // BACnetConstructedDataMembers
+ _child, typeSwitchError = BACnetConstructedDataMembersParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case objectTypeArgument == BACnetObjectType_ACCUMULATOR && propertyIdentifierArgument == BACnetPropertyIdentifier_MIN_PRES_VALUE: // BACnetConstructedDataAccumulatorMinPresValue
_child, typeSwitchError = BACnetConstructedDataAccumulatorMinPresValueParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_MIN_PRES_VALUE: // BACnetConstructedDataMinPresValue
@@ -528,6 +532,14 @@ func BACnetConstructedDataParse(readBuffer utils.ReadBuffer, tagNumber uint8, ob
_child, typeSwitchError = BACnetConstructedDataUnitsParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_UPDATE_INTERVAL: // BACnetConstructedDataUpdateInterval
_child, typeSwitchError = BACnetConstructedDataUpdateIntervalParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
+ case true && propertyIdentifierArgument == BACnetPropertyIdentifier_USER_EXTERNAL_IDENTIFIER: // BACnetConstructedDataUserExternalIdentifier
+ _child, typeSwitchError = BACnetConstructedDataUserExternalIdentifierParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
+ case true && propertyIdentifierArgument == BACnetPropertyIdentifier_USER_INFORMATION_REFERENCE: // BACnetConstructedDataUserInformationReference
+ _child, typeSwitchError = BACnetConstructedDataUserInformationReferenceParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
+ case true && propertyIdentifierArgument == BACnetPropertyIdentifier_USER_NAME: // BACnetConstructedDataUserName
+ _child, typeSwitchError = BACnetConstructedDataUserNameParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
+ case true && propertyIdentifierArgument == BACnetPropertyIdentifier_USER_TYPE: // BACnetConstructedDataUserType
+ _child, typeSwitchError = BACnetConstructedDataUserTypeParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_USES_REMAINING: // BACnetConstructedDataUsesRemaining
_child, typeSwitchError = BACnetConstructedDataUsesRemainingParse(readBuffer, tagNumber, objectTypeArgument, propertyIdentifierArgument)
case true && propertyIdentifierArgument == BACnetPropertyIdentifier_VERIFICATION_TIME: // BACnetConstructedDataVerificationTime
diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCredentials.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCredentials.go
new file mode 100644
index 0000000000..32692f181b
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataCredentials.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.
+
+// BACnetConstructedDataCredentials is the data-structure of this message
+type BACnetConstructedDataCredentials struct {
+ *BACnetConstructedData
+ Credentials []*BACnetDeviceObjectReference
+
+ // Arguments.
+ TagNumber uint8
+}
+
+// IBACnetConstructedDataCredentials is the corresponding interface of BACnetConstructedDataCredentials
+type IBACnetConstructedDataCredentials interface {
+ IBACnetConstructedData
+ // GetCredentials returns Credentials (property field)
+ GetCredentials() []*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 *BACnetConstructedDataCredentials) GetObjectTypeArgument() BACnetObjectType {
+ return 0
+}
+
+func (m *BACnetConstructedDataCredentials) GetPropertyIdentifierArgument() BACnetPropertyIdentifier {
+ return BACnetPropertyIdentifier_CREDENTIALS
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+func (m *BACnetConstructedDataCredentials) InitializeParent(parent *BACnetConstructedData, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag) {
+ m.BACnetConstructedData.OpeningTag = openingTag
+ m.BACnetConstructedData.ClosingTag = closingTag
+}
+
+func (m *BACnetConstructedDataCredentials) GetParent() *BACnetConstructedData {
+ return m.BACnetConstructedData
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetConstructedDataCredentials) GetCredentials() []*BACnetDeviceObjectReference {
+ return m.Credentials
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetConstructedDataCredentials factory function for BACnetConstructedDataCredentials
+func NewBACnetConstructedDataCredentials(credentials []*BACnetDeviceObjectReference, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag, tagNumber uint8) *BACnetConstructedDataCredentials {
+ _result := &BACnetConstructedDataCredentials{
+ Credentials: credentials,
+ BACnetConstructedData: NewBACnetConstructedData(openingTag, closingTag, tagNumber),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetConstructedDataCredentials(structType interface{}) *BACnetConstructedDataCredentials {
+ if casted, ok := structType.(BACnetConstructedDataCredentials); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConstructedDataCredentials); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConstructedData); ok {
+ return CastBACnetConstructedDataCredentials(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConstructedData); ok {
+ return CastBACnetConstructedDataCredentials(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetConstructedDataCredentials) GetTypeName() string {
+ return "BACnetConstructedDataCredentials"
+}
+
+func (m *BACnetConstructedDataCredentials) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetConstructedDataCredentials) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Array field
+ if len(m.Credentials) > 0 {
+ for _, element := range m.Credentials {
+ lengthInBits += element.GetLengthInBits()
+ }
+ }
+
+ return lengthInBits
+}
+
+func (m *BACnetConstructedDataCredentials) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetConstructedDataCredentialsParse(readBuffer utils.ReadBuffer, tagNumber uint8, objectTypeArgument BACnetObjectType, propertyIdentifierArgument BACnetPropertyIdentifier) (*BACnetConstructedDataCredentials, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetConstructedDataCredentials"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Array field (credentials)
+ if pullErr := readBuffer.PullContext("credentials", utils.WithRenderAsList(true)); pullErr != nil {
+ return nil, pullErr
+ }
+ // Terminated array
+ credentials := make([]*BACnetDeviceObjectReference, 0)
+ {
+ for !bool(IsBACnetConstructedDataClosingTag(readBuffer, false, tagNumber)) {
+ _item, _err := BACnetDeviceObjectReferenceParse(readBuffer)
+ if _err != nil {
+ return nil, errors.Wrap(_err, "Error parsing 'credentials' field")
+ }
+ credentials = append(credentials, CastBACnetDeviceObjectReference(_item))
+
+ }
+ }
+ if closeErr := readBuffer.CloseContext("credentials", utils.WithRenderAsList(true)); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetConstructedDataCredentials"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetConstructedDataCredentials{
+ Credentials: credentials,
+ BACnetConstructedData: &BACnetConstructedData{},
+ }
+ _child.BACnetConstructedData.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetConstructedDataCredentials) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetConstructedDataCredentials"); pushErr != nil {
+ return pushErr
+ }
+
+ // Array Field (credentials)
+ if m.Credentials != nil {
+ if pushErr := writeBuffer.PushContext("credentials", utils.WithRenderAsList(true)); pushErr != nil {
+ return pushErr
+ }
+ for _, _element := range m.Credentials {
+ _elementErr := _element.Serialize(writeBuffer)
+ if _elementErr != nil {
+ return errors.Wrap(_elementErr, "Error serializing 'credentials' field")
+ }
+ }
+ if popErr := writeBuffer.PopContext("credentials", utils.WithRenderAsList(true)); popErr != nil {
+ return popErr
+ }
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetConstructedDataCredentials"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetConstructedDataCredentials) 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/BACnetConstructedDataMembers.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataMembers.go
new file mode 100644
index 0000000000..c7995c5cde
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataMembers.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.
+
+// BACnetConstructedDataMembers is the data-structure of this message
+type BACnetConstructedDataMembers struct {
+ *BACnetConstructedData
+ Members []*BACnetDeviceObjectReference
+
+ // Arguments.
+ TagNumber uint8
+}
+
+// IBACnetConstructedDataMembers is the corresponding interface of BACnetConstructedDataMembers
+type IBACnetConstructedDataMembers interface {
+ IBACnetConstructedData
+ // GetMembers returns Members (property field)
+ GetMembers() []*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 *BACnetConstructedDataMembers) GetObjectTypeArgument() BACnetObjectType {
+ return 0
+}
+
+func (m *BACnetConstructedDataMembers) GetPropertyIdentifierArgument() BACnetPropertyIdentifier {
+ return BACnetPropertyIdentifier_MEMBERS
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+func (m *BACnetConstructedDataMembers) InitializeParent(parent *BACnetConstructedData, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag) {
+ m.BACnetConstructedData.OpeningTag = openingTag
+ m.BACnetConstructedData.ClosingTag = closingTag
+}
+
+func (m *BACnetConstructedDataMembers) GetParent() *BACnetConstructedData {
+ return m.BACnetConstructedData
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetConstructedDataMembers) GetMembers() []*BACnetDeviceObjectReference {
+ return m.Members
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetConstructedDataMembers factory function for BACnetConstructedDataMembers
+func NewBACnetConstructedDataMembers(members []*BACnetDeviceObjectReference, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag, tagNumber uint8) *BACnetConstructedDataMembers {
+ _result := &BACnetConstructedDataMembers{
+ Members: members,
+ BACnetConstructedData: NewBACnetConstructedData(openingTag, closingTag, tagNumber),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetConstructedDataMembers(structType interface{}) *BACnetConstructedDataMembers {
+ if casted, ok := structType.(BACnetConstructedDataMembers); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConstructedDataMembers); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConstructedData); ok {
+ return CastBACnetConstructedDataMembers(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConstructedData); ok {
+ return CastBACnetConstructedDataMembers(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetConstructedDataMembers) GetTypeName() string {
+ return "BACnetConstructedDataMembers"
+}
+
+func (m *BACnetConstructedDataMembers) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetConstructedDataMembers) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Array field
+ if len(m.Members) > 0 {
+ for _, element := range m.Members {
+ lengthInBits += element.GetLengthInBits()
+ }
+ }
+
+ return lengthInBits
+}
+
+func (m *BACnetConstructedDataMembers) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetConstructedDataMembersParse(readBuffer utils.ReadBuffer, tagNumber uint8, objectTypeArgument BACnetObjectType, propertyIdentifierArgument BACnetPropertyIdentifier) (*BACnetConstructedDataMembers, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetConstructedDataMembers"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Array field (members)
+ if pullErr := readBuffer.PullContext("members", utils.WithRenderAsList(true)); pullErr != nil {
+ return nil, pullErr
+ }
+ // Terminated array
+ members := make([]*BACnetDeviceObjectReference, 0)
+ {
+ for !bool(IsBACnetConstructedDataClosingTag(readBuffer, false, tagNumber)) {
+ _item, _err := BACnetDeviceObjectReferenceParse(readBuffer)
+ if _err != nil {
+ return nil, errors.Wrap(_err, "Error parsing 'members' field")
+ }
+ members = append(members, CastBACnetDeviceObjectReference(_item))
+
+ }
+ }
+ if closeErr := readBuffer.CloseContext("members", utils.WithRenderAsList(true)); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetConstructedDataMembers"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetConstructedDataMembers{
+ Members: members,
+ BACnetConstructedData: &BACnetConstructedData{},
+ }
+ _child.BACnetConstructedData.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetConstructedDataMembers) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetConstructedDataMembers"); pushErr != nil {
+ return pushErr
+ }
+
+ // Array Field (members)
+ if m.Members != nil {
+ if pushErr := writeBuffer.PushContext("members", utils.WithRenderAsList(true)); pushErr != nil {
+ return pushErr
+ }
+ for _, _element := range m.Members {
+ _elementErr := _element.Serialize(writeBuffer)
+ if _elementErr != nil {
+ return errors.Wrap(_elementErr, "Error serializing 'members' field")
+ }
+ }
+ if popErr := writeBuffer.PopContext("members", utils.WithRenderAsList(true)); popErr != nil {
+ return popErr
+ }
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetConstructedDataMembers"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetConstructedDataMembers) 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/BACnetConstructedDataUserExternalIdentifier.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataUserExternalIdentifier.go
new file mode 100644
index 0000000000..29990068d6
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataUserExternalIdentifier.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.
+
+// BACnetConstructedDataUserExternalIdentifier is the data-structure of this message
+type BACnetConstructedDataUserExternalIdentifier struct {
+ *BACnetConstructedData
+ UserExternalIdentifier *BACnetApplicationTagCharacterString
+
+ // Arguments.
+ TagNumber uint8
+}
+
+// IBACnetConstructedDataUserExternalIdentifier is the corresponding interface of BACnetConstructedDataUserExternalIdentifier
+type IBACnetConstructedDataUserExternalIdentifier interface {
+ IBACnetConstructedData
+ // GetUserExternalIdentifier returns UserExternalIdentifier (property field)
+ GetUserExternalIdentifier() *BACnetApplicationTagCharacterString
+ // GetLengthInBytes returns the length in bytes
+ GetLengthInBytes() uint16
+ // GetLengthInBits returns the length in bits
+ GetLengthInBits() uint16
+ // Serialize serializes this type
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for discriminator values.
+///////////////////////
+
+func (m *BACnetConstructedDataUserExternalIdentifier) GetObjectTypeArgument() BACnetObjectType {
+ return 0
+}
+
+func (m *BACnetConstructedDataUserExternalIdentifier) GetPropertyIdentifierArgument() BACnetPropertyIdentifier {
+ return BACnetPropertyIdentifier_USER_EXTERNAL_IDENTIFIER
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+func (m *BACnetConstructedDataUserExternalIdentifier) InitializeParent(parent *BACnetConstructedData, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag) {
+ m.BACnetConstructedData.OpeningTag = openingTag
+ m.BACnetConstructedData.ClosingTag = closingTag
+}
+
+func (m *BACnetConstructedDataUserExternalIdentifier) GetParent() *BACnetConstructedData {
+ return m.BACnetConstructedData
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetConstructedDataUserExternalIdentifier) GetUserExternalIdentifier() *BACnetApplicationTagCharacterString {
+ return m.UserExternalIdentifier
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetConstructedDataUserExternalIdentifier factory function for BACnetConstructedDataUserExternalIdentifier
+func NewBACnetConstructedDataUserExternalIdentifier(userExternalIdentifier *BACnetApplicationTagCharacterString, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag, tagNumber uint8) *BACnetConstructedDataUserExternalIdentifier {
+ _result := &BACnetConstructedDataUserExternalIdentifier{
+ UserExternalIdentifier: userExternalIdentifier,
+ BACnetConstructedData: NewBACnetConstructedData(openingTag, closingTag, tagNumber),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetConstructedDataUserExternalIdentifier(structType interface{}) *BACnetConstructedDataUserExternalIdentifier {
+ if casted, ok := structType.(BACnetConstructedDataUserExternalIdentifier); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConstructedDataUserExternalIdentifier); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConstructedData); ok {
+ return CastBACnetConstructedDataUserExternalIdentifier(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConstructedData); ok {
+ return CastBACnetConstructedDataUserExternalIdentifier(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetConstructedDataUserExternalIdentifier) GetTypeName() string {
+ return "BACnetConstructedDataUserExternalIdentifier"
+}
+
+func (m *BACnetConstructedDataUserExternalIdentifier) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetConstructedDataUserExternalIdentifier) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (userExternalIdentifier)
+ lengthInBits += m.UserExternalIdentifier.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetConstructedDataUserExternalIdentifier) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetConstructedDataUserExternalIdentifierParse(readBuffer utils.ReadBuffer, tagNumber uint8, objectTypeArgument BACnetObjectType, propertyIdentifierArgument BACnetPropertyIdentifier) (*BACnetConstructedDataUserExternalIdentifier, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetConstructedDataUserExternalIdentifier"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (userExternalIdentifier)
+ if pullErr := readBuffer.PullContext("userExternalIdentifier"); pullErr != nil {
+ return nil, pullErr
+ }
+ _userExternalIdentifier, _userExternalIdentifierErr := BACnetApplicationTagParse(readBuffer)
+ if _userExternalIdentifierErr != nil {
+ return nil, errors.Wrap(_userExternalIdentifierErr, "Error parsing 'userExternalIdentifier' field")
+ }
+ userExternalIdentifier := CastBACnetApplicationTagCharacterString(_userExternalIdentifier)
+ if closeErr := readBuffer.CloseContext("userExternalIdentifier"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetConstructedDataUserExternalIdentifier"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetConstructedDataUserExternalIdentifier{
+ UserExternalIdentifier: CastBACnetApplicationTagCharacterString(userExternalIdentifier),
+ BACnetConstructedData: &BACnetConstructedData{},
+ }
+ _child.BACnetConstructedData.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetConstructedDataUserExternalIdentifier) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetConstructedDataUserExternalIdentifier"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (userExternalIdentifier)
+ if pushErr := writeBuffer.PushContext("userExternalIdentifier"); pushErr != nil {
+ return pushErr
+ }
+ _userExternalIdentifierErr := m.UserExternalIdentifier.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("userExternalIdentifier"); popErr != nil {
+ return popErr
+ }
+ if _userExternalIdentifierErr != nil {
+ return errors.Wrap(_userExternalIdentifierErr, "Error serializing 'userExternalIdentifier' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetConstructedDataUserExternalIdentifier"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetConstructedDataUserExternalIdentifier) 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/BACnetConstructedDataUserInformationReference.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataUserInformationReference.go
new file mode 100644
index 0000000000..e5a8896d89
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataUserInformationReference.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.
+
+// BACnetConstructedDataUserInformationReference is the data-structure of this message
+type BACnetConstructedDataUserInformationReference struct {
+ *BACnetConstructedData
+ UserInformationReference *BACnetApplicationTagCharacterString
+
+ // Arguments.
+ TagNumber uint8
+}
+
+// IBACnetConstructedDataUserInformationReference is the corresponding interface of BACnetConstructedDataUserInformationReference
+type IBACnetConstructedDataUserInformationReference interface {
+ IBACnetConstructedData
+ // GetUserInformationReference returns UserInformationReference (property field)
+ GetUserInformationReference() *BACnetApplicationTagCharacterString
+ // GetLengthInBytes returns the length in bytes
+ GetLengthInBytes() uint16
+ // GetLengthInBits returns the length in bits
+ GetLengthInBits() uint16
+ // Serialize serializes this type
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for discriminator values.
+///////////////////////
+
+func (m *BACnetConstructedDataUserInformationReference) GetObjectTypeArgument() BACnetObjectType {
+ return 0
+}
+
+func (m *BACnetConstructedDataUserInformationReference) GetPropertyIdentifierArgument() BACnetPropertyIdentifier {
+ return BACnetPropertyIdentifier_USER_INFORMATION_REFERENCE
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+func (m *BACnetConstructedDataUserInformationReference) InitializeParent(parent *BACnetConstructedData, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag) {
+ m.BACnetConstructedData.OpeningTag = openingTag
+ m.BACnetConstructedData.ClosingTag = closingTag
+}
+
+func (m *BACnetConstructedDataUserInformationReference) GetParent() *BACnetConstructedData {
+ return m.BACnetConstructedData
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetConstructedDataUserInformationReference) GetUserInformationReference() *BACnetApplicationTagCharacterString {
+ return m.UserInformationReference
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetConstructedDataUserInformationReference factory function for BACnetConstructedDataUserInformationReference
+func NewBACnetConstructedDataUserInformationReference(userInformationReference *BACnetApplicationTagCharacterString, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag, tagNumber uint8) *BACnetConstructedDataUserInformationReference {
+ _result := &BACnetConstructedDataUserInformationReference{
+ UserInformationReference: userInformationReference,
+ BACnetConstructedData: NewBACnetConstructedData(openingTag, closingTag, tagNumber),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetConstructedDataUserInformationReference(structType interface{}) *BACnetConstructedDataUserInformationReference {
+ if casted, ok := structType.(BACnetConstructedDataUserInformationReference); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConstructedDataUserInformationReference); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConstructedData); ok {
+ return CastBACnetConstructedDataUserInformationReference(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConstructedData); ok {
+ return CastBACnetConstructedDataUserInformationReference(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetConstructedDataUserInformationReference) GetTypeName() string {
+ return "BACnetConstructedDataUserInformationReference"
+}
+
+func (m *BACnetConstructedDataUserInformationReference) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetConstructedDataUserInformationReference) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (userInformationReference)
+ lengthInBits += m.UserInformationReference.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetConstructedDataUserInformationReference) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetConstructedDataUserInformationReferenceParse(readBuffer utils.ReadBuffer, tagNumber uint8, objectTypeArgument BACnetObjectType, propertyIdentifierArgument BACnetPropertyIdentifier) (*BACnetConstructedDataUserInformationReference, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetConstructedDataUserInformationReference"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (userInformationReference)
+ if pullErr := readBuffer.PullContext("userInformationReference"); pullErr != nil {
+ return nil, pullErr
+ }
+ _userInformationReference, _userInformationReferenceErr := BACnetApplicationTagParse(readBuffer)
+ if _userInformationReferenceErr != nil {
+ return nil, errors.Wrap(_userInformationReferenceErr, "Error parsing 'userInformationReference' field")
+ }
+ userInformationReference := CastBACnetApplicationTagCharacterString(_userInformationReference)
+ if closeErr := readBuffer.CloseContext("userInformationReference"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetConstructedDataUserInformationReference"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetConstructedDataUserInformationReference{
+ UserInformationReference: CastBACnetApplicationTagCharacterString(userInformationReference),
+ BACnetConstructedData: &BACnetConstructedData{},
+ }
+ _child.BACnetConstructedData.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetConstructedDataUserInformationReference) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetConstructedDataUserInformationReference"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (userInformationReference)
+ if pushErr := writeBuffer.PushContext("userInformationReference"); pushErr != nil {
+ return pushErr
+ }
+ _userInformationReferenceErr := m.UserInformationReference.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("userInformationReference"); popErr != nil {
+ return popErr
+ }
+ if _userInformationReferenceErr != nil {
+ return errors.Wrap(_userInformationReferenceErr, "Error serializing 'userInformationReference' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetConstructedDataUserInformationReference"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetConstructedDataUserInformationReference) 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/BACnetConstructedDataUserName.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataUserName.go
new file mode 100644
index 0000000000..eeea59e812
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataUserName.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.
+
+// BACnetConstructedDataUserName is the data-structure of this message
+type BACnetConstructedDataUserName struct {
+ *BACnetConstructedData
+ UserName *BACnetApplicationTagCharacterString
+
+ // Arguments.
+ TagNumber uint8
+}
+
+// IBACnetConstructedDataUserName is the corresponding interface of BACnetConstructedDataUserName
+type IBACnetConstructedDataUserName interface {
+ IBACnetConstructedData
+ // GetUserName returns UserName (property field)
+ GetUserName() *BACnetApplicationTagCharacterString
+ // GetLengthInBytes returns the length in bytes
+ GetLengthInBytes() uint16
+ // GetLengthInBits returns the length in bits
+ GetLengthInBits() uint16
+ // Serialize serializes this type
+ Serialize(writeBuffer utils.WriteBuffer) error
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for discriminator values.
+///////////////////////
+
+func (m *BACnetConstructedDataUserName) GetObjectTypeArgument() BACnetObjectType {
+ return 0
+}
+
+func (m *BACnetConstructedDataUserName) GetPropertyIdentifierArgument() BACnetPropertyIdentifier {
+ return BACnetPropertyIdentifier_USER_NAME
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+func (m *BACnetConstructedDataUserName) InitializeParent(parent *BACnetConstructedData, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag) {
+ m.BACnetConstructedData.OpeningTag = openingTag
+ m.BACnetConstructedData.ClosingTag = closingTag
+}
+
+func (m *BACnetConstructedDataUserName) GetParent() *BACnetConstructedData {
+ return m.BACnetConstructedData
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetConstructedDataUserName) GetUserName() *BACnetApplicationTagCharacterString {
+ return m.UserName
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetConstructedDataUserName factory function for BACnetConstructedDataUserName
+func NewBACnetConstructedDataUserName(userName *BACnetApplicationTagCharacterString, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag, tagNumber uint8) *BACnetConstructedDataUserName {
+ _result := &BACnetConstructedDataUserName{
+ UserName: userName,
+ BACnetConstructedData: NewBACnetConstructedData(openingTag, closingTag, tagNumber),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetConstructedDataUserName(structType interface{}) *BACnetConstructedDataUserName {
+ if casted, ok := structType.(BACnetConstructedDataUserName); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConstructedDataUserName); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConstructedData); ok {
+ return CastBACnetConstructedDataUserName(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConstructedData); ok {
+ return CastBACnetConstructedDataUserName(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetConstructedDataUserName) GetTypeName() string {
+ return "BACnetConstructedDataUserName"
+}
+
+func (m *BACnetConstructedDataUserName) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetConstructedDataUserName) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (userName)
+ lengthInBits += m.UserName.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetConstructedDataUserName) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetConstructedDataUserNameParse(readBuffer utils.ReadBuffer, tagNumber uint8, objectTypeArgument BACnetObjectType, propertyIdentifierArgument BACnetPropertyIdentifier) (*BACnetConstructedDataUserName, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetConstructedDataUserName"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (userName)
+ if pullErr := readBuffer.PullContext("userName"); pullErr != nil {
+ return nil, pullErr
+ }
+ _userName, _userNameErr := BACnetApplicationTagParse(readBuffer)
+ if _userNameErr != nil {
+ return nil, errors.Wrap(_userNameErr, "Error parsing 'userName' field")
+ }
+ userName := CastBACnetApplicationTagCharacterString(_userName)
+ if closeErr := readBuffer.CloseContext("userName"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetConstructedDataUserName"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetConstructedDataUserName{
+ UserName: CastBACnetApplicationTagCharacterString(userName),
+ BACnetConstructedData: &BACnetConstructedData{},
+ }
+ _child.BACnetConstructedData.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetConstructedDataUserName) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetConstructedDataUserName"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (userName)
+ if pushErr := writeBuffer.PushContext("userName"); pushErr != nil {
+ return pushErr
+ }
+ _userNameErr := m.UserName.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("userName"); popErr != nil {
+ return popErr
+ }
+ if _userNameErr != nil {
+ return errors.Wrap(_userNameErr, "Error serializing 'userName' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetConstructedDataUserName"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetConstructedDataUserName) 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/BACnetConstructedDataUserType.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataUserType.go
new file mode 100644
index 0000000000..1dcc87b7aa
--- /dev/null
+++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetConstructedDataUserType.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.
+
+// BACnetConstructedDataUserType is the data-structure of this message
+type BACnetConstructedDataUserType struct {
+ *BACnetConstructedData
+ UserType *BACnetAccessUserTypeTagged
+
+ // Arguments.
+ TagNumber uint8
+}
+
+// IBACnetConstructedDataUserType is the corresponding interface of BACnetConstructedDataUserType
+type IBACnetConstructedDataUserType interface {
+ IBACnetConstructedData
+ // GetUserType returns UserType (property field)
+ GetUserType() *BACnetAccessUserTypeTagged
+ // 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 *BACnetConstructedDataUserType) GetObjectTypeArgument() BACnetObjectType {
+ return 0
+}
+
+func (m *BACnetConstructedDataUserType) GetPropertyIdentifierArgument() BACnetPropertyIdentifier {
+ return BACnetPropertyIdentifier_USER_TYPE
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+func (m *BACnetConstructedDataUserType) InitializeParent(parent *BACnetConstructedData, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag) {
+ m.BACnetConstructedData.OpeningTag = openingTag
+ m.BACnetConstructedData.ClosingTag = closingTag
+}
+
+func (m *BACnetConstructedDataUserType) GetParent() *BACnetConstructedData {
+ return m.BACnetConstructedData
+}
+
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+/////////////////////// Accessors for property fields.
+///////////////////////
+
+func (m *BACnetConstructedDataUserType) GetUserType() *BACnetAccessUserTypeTagged {
+ return m.UserType
+}
+
+///////////////////////
+///////////////////////
+///////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////
+
+// NewBACnetConstructedDataUserType factory function for BACnetConstructedDataUserType
+func NewBACnetConstructedDataUserType(userType *BACnetAccessUserTypeTagged, openingTag *BACnetOpeningTag, closingTag *BACnetClosingTag, tagNumber uint8) *BACnetConstructedDataUserType {
+ _result := &BACnetConstructedDataUserType{
+ UserType: userType,
+ BACnetConstructedData: NewBACnetConstructedData(openingTag, closingTag, tagNumber),
+ }
+ _result.Child = _result
+ return _result
+}
+
+func CastBACnetConstructedDataUserType(structType interface{}) *BACnetConstructedDataUserType {
+ if casted, ok := structType.(BACnetConstructedDataUserType); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConstructedDataUserType); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConstructedData); ok {
+ return CastBACnetConstructedDataUserType(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConstructedData); ok {
+ return CastBACnetConstructedDataUserType(casted.Child)
+ }
+ return nil
+}
+
+func (m *BACnetConstructedDataUserType) GetTypeName() string {
+ return "BACnetConstructedDataUserType"
+}
+
+func (m *BACnetConstructedDataUserType) GetLengthInBits() uint16 {
+ return m.GetLengthInBitsConditional(false)
+}
+
+func (m *BACnetConstructedDataUserType) GetLengthInBitsConditional(lastItem bool) uint16 {
+ lengthInBits := uint16(m.GetParentLengthInBits())
+
+ // Simple field (userType)
+ lengthInBits += m.UserType.GetLengthInBits()
+
+ return lengthInBits
+}
+
+func (m *BACnetConstructedDataUserType) GetLengthInBytes() uint16 {
+ return m.GetLengthInBits() / 8
+}
+
+func BACnetConstructedDataUserTypeParse(readBuffer utils.ReadBuffer, tagNumber uint8, objectTypeArgument BACnetObjectType, propertyIdentifierArgument BACnetPropertyIdentifier) (*BACnetConstructedDataUserType, error) {
+ positionAware := readBuffer
+ _ = positionAware
+ if pullErr := readBuffer.PullContext("BACnetConstructedDataUserType"); pullErr != nil {
+ return nil, pullErr
+ }
+ currentPos := positionAware.GetPos()
+ _ = currentPos
+
+ // Simple Field (userType)
+ if pullErr := readBuffer.PullContext("userType"); pullErr != nil {
+ return nil, pullErr
+ }
+ _userType, _userTypeErr := BACnetAccessUserTypeTaggedParse(readBuffer, uint8(uint8(0)), TagClass(TagClass_APPLICATION_TAGS))
+ if _userTypeErr != nil {
+ return nil, errors.Wrap(_userTypeErr, "Error parsing 'userType' field")
+ }
+ userType := CastBACnetAccessUserTypeTagged(_userType)
+ if closeErr := readBuffer.CloseContext("userType"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ if closeErr := readBuffer.CloseContext("BACnetConstructedDataUserType"); closeErr != nil {
+ return nil, closeErr
+ }
+
+ // Create a partially initialized instance
+ _child := &BACnetConstructedDataUserType{
+ UserType: CastBACnetAccessUserTypeTagged(userType),
+ BACnetConstructedData: &BACnetConstructedData{},
+ }
+ _child.BACnetConstructedData.Child = _child
+ return _child, nil
+}
+
+func (m *BACnetConstructedDataUserType) Serialize(writeBuffer utils.WriteBuffer) error {
+ positionAware := writeBuffer
+ _ = positionAware
+ ser := func() error {
+ if pushErr := writeBuffer.PushContext("BACnetConstructedDataUserType"); pushErr != nil {
+ return pushErr
+ }
+
+ // Simple Field (userType)
+ if pushErr := writeBuffer.PushContext("userType"); pushErr != nil {
+ return pushErr
+ }
+ _userTypeErr := m.UserType.Serialize(writeBuffer)
+ if popErr := writeBuffer.PopContext("userType"); popErr != nil {
+ return popErr
+ }
+ if _userTypeErr != nil {
+ return errors.Wrap(_userTypeErr, "Error serializing 'userType' field")
+ }
+
+ if popErr := writeBuffer.PopContext("BACnetConstructedDataUserType"); popErr != nil {
+ return popErr
+ }
+ return nil
+ }
+ return m.SerializeParent(writeBuffer, m, ser)
+}
+
+func (m *BACnetConstructedDataUserType) String() string {
+ if m == nil {
+ return "<nil>"
+ }
+ buffer := utils.NewBoxedWriteBufferWithOptions(true, true)
+ if err := m.Serialize(buffer); err != nil {
+ return err.Error()
+ }
+ return buffer.GetBox().String()
+}
diff --git a/protocols/bacnetip/src/main/resources/protocols/bacnetip/bacnetip.mspec b/protocols/bacnetip/src/main/resources/protocols/bacnetip/bacnetip.mspec
index f28edd8d55..2d7ba7ff35 100644
--- a/protocols/bacnetip/src/main/resources/protocols/bacnetip/bacnetip.mspec
+++ b/protocols/bacnetip/src/main/resources/protocols/bacnetip/bacnetip.mspec
@@ -2679,7 +2679,12 @@
[*, 'CREDENTIAL_STATUS' BACnetConstructedDataCredentialStatus
[simple BACnetBinaryPVTagged('0', 'TagClass.APPLICATION_TAGS') binaryPv ]
]
- //[*, 'CREDENTIALS' BACnetConstructedDataCredentials [validation '1 == 2' "TODO: implement me CREDENTIALS BACnetConstructedDataCredentials"]]
+ [*, 'CREDENTIALS' BACnetConstructedDataCredentials
+ [array BACnetDeviceObjectReference
+ credentials
+ terminated
+ 'STATIC_CALL("isBACnetConstructedDataClosingTag", readBuffer, false, tagNumber)' ]
+ ]
//[*, 'CREDENTIALS_IN_ZONE' BACnetConstructedDataCredentialsInZone [validation '1 == 2' "TODO: implement me CREDENTIALS_IN_ZONE BACnetConstructedDataCredentialsInZone"]]
//[*, 'CURRENT_COMMAND_PRIORITY' BACnetConstructedDataCurrentCommandPriority [validation '1 == 2' "TODO: implement me CURRENT_COMMAND_PRIORITY BACnetConstructedDataCurrentCommandPriority"]]
//[*, 'DATABASE_REVISION' BACnetConstructedDataDatabaseRevision [validation '1 == 2' "TODO: implement me DATABASE_REVISION BACnetConstructedDataDatabaseRevision"]]
@@ -2984,13 +2989,18 @@
'STATIC_CALL("isBACnetConstructedDataClosingTag", readBuffer, false, tagNumber)' ]
]
//[*, 'MEMBER_STATUS_FLAGS' BACnetConstructedDataMemberStatusFlags [validation '1 == 2' "TODO: implement me MEMBER_STATUS_FLAGS BACnetConstructedDataMemberStatusFlags"]]
- //[*, 'MEMBERS' BACnetConstructedDataMembers [validation '1 == 2' "TODO: implement me MEMBERS BACnetConstructedDataMembers"]]
+ [*, 'MEMBERS' BACnetConstructedDataMembers
+ [array BACnetDeviceObjectReference
+ members
+ terminated
+ 'STATIC_CALL("isBACnetConstructedDataClosingTag", readBuffer, false, tagNumber)']
+ ]
//[*, '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"]]
@@ -3003,13 +3013,13 @@
//[*, 'MODEL_NAME' BACnetConstructedDataModelName [validation '1 == 2' "TODO: implement me MODEL_NAME BACnetConstructedDataModelName"]]
//[*, 'MODIFICATION_DATE' BACnetConstructedDataModificationDate [validation '1 == 2' "TODO: implement me MODIFICATION_DATE BACnetConstructedDataModificationDate"]]
[*, 'MUSTER_POINT' BACnetConstructedDataMusterPoint
- [simple BACnetApplicationTagBoolean musterPoint ]
+ [simple BACnetApplicationTagBoolean musterPoint ]
]
[*, 'NEGATIVE_ACCESS_RULES' BACnetConstructedDataNegativeAccessRules
[array BACnetAccessRule
negativeAccessRules
terminated
- 'STATIC_CALL("isBACnetConstructedDataClosingTag", readBuffer, false, tagNumber)' ]
+ 'STATIC_CALL("isBACnetConstructedDataClosingTag", readBuffer, false, tagNumber)' ]
]
//[*, 'NETWORK_ACCESS_SECURITY_POLICIES' BACnetConstructedDataNetworkAccessSecurityPolicies [validation '1 == 2' "TODO: implement me NETWORK_ACCESS_SECURITY_POLICIES BACnetConstructedDataNetworkAccessSecurityPolicies"]]
//[*, 'NETWORK_INTERFACE_NAME' BACnetConstructedDataNetworkInterfaceName [validation '1 == 2' "TODO: implement me NETWORK_INTERFACE_NAME BACnetConstructedDataNetworkInterfaceName"]]
@@ -3044,17 +3054,17 @@
]
//[*, 'OCCUPANCY_COUNT' BACnetConstructedDataOccupancyCount [validation '1 == 2' "TODO: implement me OCCUPANCY_COUNT BACnetConstructedDataOccupancyCount"]]
[*, 'OCCUPANCY_COUNT_ADJUST' BACnetConstructedDataOccupancyCountAdjust
- [simple BACnetApplicationTagBoolean occupancyCountAdjust ]
+ [simple BACnetApplicationTagBoolean occupancyCountAdjust ]
]
//[*, 'OCCUPANCY_COUNT_ENABLE' BACnetConstructedDataOccupancyCountEnable [validation '1 == 2' "TODO: implement me OCCUPANCY_COUNT_ENABLE BACnetConstructedDataOccupancyCountEnable"]]
//[*, 'OCCUPANCY_LOWER_LIMIT' BACnetConstructedDataOccupancyLowerLimit [validation '1 == 2' "TODO: implement me OCCUPANCY_LOWER_LIMIT BACnetConstructedDataOccupancyLowerLimit"]]
[*, 'OCCUPANCY_LOWER_LIMIT_ENFORCED' BACnetConstructedDataOccupancyLowerLimitEnforced
- [simple BACnetApplicationTagBoolean occupancyLowerLimitEnforced ]
+ [simple BACnetApplicationTagBoolean occupancyLowerLimitEnforced ]
]
//[*, 'OCCUPANCY_STATE' BACnetConstructedDataOccupancyState [validation '1 == 2' "TODO: implement me OCCUPANCY_STATE BACnetConstructedDataOccupancyState"]]
//[*, 'OCCUPANCY_UPPER_LIMIT' BACnetConstructedDataOccupancyUpperLimit [validation '1 == 2' "TODO: implement me OCCUPANCY_UPPER_LIMIT BACnetConstructedDataOccupancyUpperLimit"]]
[*, 'OCCUPANCY_UPPER_LIMIT_ENFORCED' BACnetConstructedDataOccupancyUpperLimitEnforced
- [simple BACnetApplicationTagBoolean occupancyUpperLimitEnforced ]
+ [simple BACnetApplicationTagBoolean occupancyUpperLimitEnforced ]
]
//[*, 'OPERATION_DIRECTION' BACnetConstructedDataOperationDirection [validation '1 == 2' "TODO: implement me OPERATION_DIRECTION BACnetConstructedDataOperationDirection"]]
//[*, 'OPERATION_EXPECTED' BACnetConstructedDataOperationExpected [validation '1 == 2' "TODO: implement me OPERATION_EXPECTED BACnetConstructedDataOperationExpected"]]
@@ -3073,9 +3083,9 @@
//[*, 'PORT_FILTER' BACnetConstructedDataPortFilter [validation '1 == 2' "TODO: implement me PORT_FILTER BACnetConstructedDataPortFilter"]]
[*, 'POSITIVE_ACCESS_RULES' BACnetConstructedDataPositiveAccessRules
[array BACnetAccessRule
- positiveAccessRules
- terminated
- 'STATIC_CALL("isBACnetConstructedDataClosingTag", readBuffer, false, tagNumber)' ]
+ 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"]]
@@ -3104,7 +3114,7 @@
[array BACnetPropertyIdentifierTagged('0', 'TagClass.APPLICATION_TAGS')
propertyList
terminated
- 'STATIC_CALL("isBACnetConstructedDataClosingTag", readBuffer, false, tagNumber)' ]
+ 'STATIC_CALL("isBACnetConstructedDataClosingTag", readBuffer, false, tagNumber)']
]
//[*, 'PROPORTIONAL_CONSTANT' BACnetConstructedDataProportionalConstant [validation '1 == 2' "TODO: implement me PROPORTIONAL_CONSTANT BACnetConstructedDataProportionalConstant"]]
[*, 'PROPORTIONAL_CONSTANT_UNITS' BACnetConstructedDataProportionalConstantUnits
@@ -3239,10 +3249,18 @@
]
//[*, 'UPDATE_KEY_SET_TIMEOUT' BACnetConstructedDataUpdateKeySetTimeout [validation '1 == 2' "TODO: implement me UPDATE_KEY_SET_TIMEOUT BACnetConstructedDataUpdateKeySetTimeout"]]
//[*, 'UPDATE_TIME' BACnetConstructedDataUpdateTime [validation '1 == 2' "TODO: implement me UPDATE_TIME BACnetConstructedDataUpdateTime"]]
- //[*, 'USER_EXTERNAL_IDENTIFIER' BACnetConstructedDataUserExternalIdentifier [validation '1 == 2' "TODO: implement me USER_EXTERNAL_IDENTIFIER BACnetConstructedDataUserExternalIdentifier"]]
- //[*, 'USER_INFORMATION_REFERENCE' BACnetConstructedDataUserInformationReference [validation '1 == 2' "TODO: implement me USER_INFORMATION_REFERENCE BACnetConstructedDataUserInformationReference"]]
- //[*, 'USER_NAME' BACnetConstructedDataUserName [validation '1 == 2' "TODO: implement me USER_NAME BACnetConstructedDataUserName"]]
- //[*, 'USER_TYPE' BACnetConstructedDataUserType [validation '1 == 2' "TODO: implement me USER_TYPE BACnetConstructedDataUserType"]]
+ [*, 'USER_EXTERNAL_IDENTIFIER' BACnetConstructedDataUserExternalIdentifier
+ [simple BACnetApplicationTagCharacterString userExternalIdentifier ]
+ ]
+ [*, 'USER_INFORMATION_REFERENCE' BACnetConstructedDataUserInformationReference
+ [simple BACnetApplicationTagCharacterString userInformationReference ]
+ ]
+ [*, 'USER_NAME' BACnetConstructedDataUserName
+ [simple BACnetApplicationTagCharacterString userName ]
+ ]
+ [*, 'USER_TYPE' BACnetConstructedDataUserType
+ [simple BACnetAccessUserTypeTagged('0', 'TagClass.APPLICATION_TAGS') userType ]
+ ]
[*, 'USES_REMAINING' BACnetConstructedDataUsesRemaining
[simple BACnetApplicationTagSignedInteger usesRemaining ]
]