diff --git a/code-generation/language-go/src/main/resources/templates/go/complex-type-template.go.ftlh b/code-generation/language-go/src/main/resources/templates/go/complex-type-template.go.ftlh index d03ecbe5299..7ff53cc142f 100644 --- a/code-generation/language-go/src/main/resources/templates/go/complex-type-template.go.ftlh +++ b/code-generation/language-go/src/main/resources/templates/go/complex-type-template.go.ftlh @@ -837,13 +837,13 @@ func ${type.name}ParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffe <#-- If this is a count array, we can directly initialize an array with the given size --> <#if field.isCountArrayField()> // Count array - ${arrayField.name} := make(${helper.getLanguageTypeNameForField(field)}, utils.Max(${helper.toIntegerParseExpression(arrayField, 16, arrayField.loopExpression, parserArguments)}, 0)) + ${arrayField.name} := make(${helper.getLanguageTypeNameForField(field)}, max(${helper.toIntegerParseExpression(arrayField, 16, arrayField.loopExpression, parserArguments)}, 0)) // This happens when the size is set conditional to 0 if len(${arrayField.name}) == 0 { ${arrayField.name} = nil } { - _numItems := uint16(utils.Max(${helper.toIntegerParseExpression(arrayField, 16, arrayField.loopExpression, parserArguments)}, 0)) + _numItems := uint16(max(${helper.toIntegerParseExpression(arrayField, 16, arrayField.loopExpression, parserArguments)}, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) <#-- TODO: find a way to do this nicer --> diff --git a/plc4go/go.mod b/plc4go/go.mod index 09ba6e21c63..b7d15f9f349 100644 --- a/plc4go/go.mod +++ b/plc4go/go.mod @@ -19,7 +19,7 @@ module github.com/apache/plc4x/plc4go -go 1.20 +go 1.21 require ( github.com/IBM/netaddr v1.5.0 @@ -36,7 +36,6 @@ require ( github.com/stretchr/testify v1.9.0 github.com/subchen/go-xmldom v1.1.2 github.com/viney-shih/go-lock v1.1.2 - golang.org/x/exp v0.0.0-20230905200255-921286631fa9 golang.org/x/net v0.27.0 golang.org/x/text v0.16.0 golang.org/x/tools v0.23.0 diff --git a/plc4go/go.sum b/plc4go/go.sum index 75918ae8143..7a36700a561 100644 --- a/plc4go/go.sum +++ b/plc4go/go.sum @@ -60,8 +60,6 @@ github.com/viney-shih/go-lock v1.1.2 h1:3TdGTiHZCPqBdTvFbQZQN/TRZzKF3KWw2rFEyKz3 github.com/viney-shih/go-lock v1.1.2/go.mod h1:Yijm78Ljteb3kRiJrbLAxVntkUukGu5uzSxq/xV7OO8= github.com/vishvananda/netlink v1.1.0 h1:1iyaYNBLmP6L0220aDnYQpo1QEV4t4hJ+xEEhhJH8j0= github.com/vishvananda/netns v0.0.0-20211101163701-50045581ed74 h1:gga7acRE695APm9hlsSMoOoE65U4/TcqNj90mc69Rlg= -golang.org/x/exp v0.0.0-20230905200255-921286631fa9 h1:GoHiUyI/Tp2nVkLI2mCxVkOjsbSXD66ic0XW0js0R9g= -golang.org/x/exp v0.0.0-20230905200255-921286631fa9/go.mod h1:S2oDrQGGwySpoQPVqRShND87VCbxmc6bL1Yd2oYrm6k= golang.org/x/mod v0.19.0 h1:fEdghXQSo20giMthA7cd28ZC+jts4amQ3YMXiP5oMQ8= golang.org/x/mod v0.19.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= golang.org/x/net v0.27.0 h1:5K3Njcw06/l2y9vpGCSdcxWOYHOUk3dVNGDXN+FvAys= diff --git a/plc4go/internal/bacnetip/ApplicationLayer.go b/plc4go/internal/bacnetip/ApplicationLayer.go index 9c65341b340..27bde552be5 100644 --- a/plc4go/internal/bacnetip/ApplicationLayer.go +++ b/plc4go/internal/bacnetip/ApplicationLayer.go @@ -26,7 +26,6 @@ import ( "time" readWriteModel "github.com/apache/plc4x/plc4go/protocols/bacnetip/readwrite/model" - "github.com/apache/plc4x/plc4go/spi/utils" "github.com/pkg/errors" "github.com/rs/zerolog/log" ) @@ -471,7 +470,7 @@ func (c *ClientSSM) Indication(apdu _PDU) error { // if the max npdu length of the server isn't known, assume that it is the same as the max apdu length accepted c.segmentSize = uint(c.maxApduLengthAccepted.NumberOfOctets()) } else { - c.segmentSize = utils.Min(*c.deviceInfo.MaximumNpduLength, uint(c.maxApduLengthAccepted.NumberOfOctets())) + c.segmentSize = min(*c.deviceInfo.MaximumNpduLength, uint(c.maxApduLengthAccepted.NumberOfOctets())) } log.Debug().Uint("segmentSize", c.segmentSize).Msg("segment size") @@ -689,7 +688,7 @@ func (c *ClientSSM) segmentedRequest(apdu _PDU) error { } // minimum of what the server is proposing and this client proposes - minWindowSize := utils.Min(*_apdu.GetProposedWindowSize(), c.ssmSAP.GetProposedWindowSize()) + minWindowSize := min(*_apdu.GetProposedWindowSize(), c.ssmSAP.GetProposedWindowSize()) c.actualWindowSize = &minWindowSize c.lastSequenceNumber = 0 c.initialSequenceNumber = 0 @@ -1112,7 +1111,7 @@ func (s *ServerSSM) Confirmation(apdu _PDU) error { if s.deviceInfo == nil || s.deviceInfo.MaximumNpduLength == nil { s.segmentSize = uint(s.maxApduLengthAccepted.NumberOfOctets()) } else { - s.segmentSize = utils.Min(*s.deviceInfo.MaximumNpduLength, uint(s.maxApduLengthAccepted.NumberOfOctets())) + s.segmentSize = min(*s.deviceInfo.MaximumNpduLength, uint(s.maxApduLengthAccepted.NumberOfOctets())) } // compute the segment count @@ -1314,7 +1313,7 @@ func (s *ServerSSM) idle(apdu _PDU) error { // the window size is the minimum of what I would propose and what the device has proposed proposedWindowSize := *apduConfirmedRequest.GetProposedWindowSize() configuredWindowSize := s.ssmSAP.GetProposedWindowSize() - minWindowSize := utils.Min(proposedWindowSize, configuredWindowSize) + minWindowSize := min(proposedWindowSize, configuredWindowSize) s.actualWindowSize = &minWindowSize log.Debug(). Uint8("proposedWindowSize", proposedWindowSize). diff --git a/plc4go/internal/opcua/SecureChannel.go b/plc4go/internal/opcua/SecureChannel.go index 0a0258b3a7e..477a31c5ed1 100644 --- a/plc4go/internal/opcua/SecureChannel.go +++ b/plc4go/internal/opcua/SecureChannel.go @@ -30,6 +30,7 @@ import ( "net" "net/url" "regexp" + "slices" "strconv" "sync" "sync/atomic" @@ -42,7 +43,6 @@ import ( "github.com/dchest/uniuri" "github.com/pkg/errors" "github.com/rs/zerolog" - "golang.org/x/exp/slices" ) const ( diff --git a/plc4go/internal/opcua/SubscriptionHandle.go b/plc4go/internal/opcua/SubscriptionHandle.go index 74418b9e3b6..8e46b8bb510 100644 --- a/plc4go/internal/opcua/SubscriptionHandle.go +++ b/plc4go/internal/opcua/SubscriptionHandle.go @@ -22,17 +22,19 @@ package opcua import ( "context" "encoding/binary" + "slices" + "strconv" + "sync" + "sync/atomic" + "time" + apiModel "github.com/apache/plc4x/plc4go/pkg/api/model" readWriteModel "github.com/apache/plc4x/plc4go/protocols/opcua/readwrite/model" spiModel "github.com/apache/plc4x/plc4go/spi/model" + "github.com/apache/plc4x/plc4go/spi/utils" "github.com/pkg/errors" "github.com/rs/zerolog" - "golang.org/x/exp/slices" - "strconv" - "sync" - "sync/atomic" - "time" ) type SubscriptionHandle struct { diff --git a/plc4go/protocols/abeth/readwrite/model/CIPEncapsulationPacket.go b/plc4go/protocols/abeth/readwrite/model/CIPEncapsulationPacket.go index 383434a6b65..e5ad7c35816 100644 --- a/plc4go/protocols/abeth/readwrite/model/CIPEncapsulationPacket.go +++ b/plc4go/protocols/abeth/readwrite/model/CIPEncapsulationPacket.go @@ -210,13 +210,13 @@ func CIPEncapsulationPacketParseWithBuffer(ctx context.Context, readBuffer utils return nil, errors.Wrap(pullErr, "Error pulling for senderContext") } // Count array - senderContext := make([]uint8, utils.Max(uint16(8), 0)) + senderContext := make([]uint8, max(uint16(8), 0)) // This happens when the size is set conditional to 0 if len(senderContext) == 0 { senderContext = nil } { - _numItems := uint16(utils.Max(uint16(8), 0)) + _numItems := uint16(max(uint16(8), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/ads/discovery/readwrite/model/AdsDiscovery.go b/plc4go/protocols/ads/discovery/readwrite/model/AdsDiscovery.go index 5f7e2f041b2..f79e4a45c45 100644 --- a/plc4go/protocols/ads/discovery/readwrite/model/AdsDiscovery.go +++ b/plc4go/protocols/ads/discovery/readwrite/model/AdsDiscovery.go @@ -249,13 +249,13 @@ func AdsDiscoveryParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffe return nil, errors.Wrap(pullErr, "Error pulling for blocks") } // Count array - blocks := make([]AdsDiscoveryBlock, utils.Max(numBlocks, 0)) + blocks := make([]AdsDiscoveryBlock, max(numBlocks, 0)) // This happens when the size is set conditional to 0 if len(blocks) == 0 { blocks = nil } { - _numItems := uint16(utils.Max(numBlocks, 0)) + _numItems := uint16(max(numBlocks, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/ads/readwrite/model/AdsDataTypeTableChildEntry.go b/plc4go/protocols/ads/readwrite/model/AdsDataTypeTableChildEntry.go index 4646c4a3e4c..013b2768881 100644 --- a/plc4go/protocols/ads/readwrite/model/AdsDataTypeTableChildEntry.go +++ b/plc4go/protocols/ads/readwrite/model/AdsDataTypeTableChildEntry.go @@ -469,13 +469,13 @@ func AdsDataTypeTableChildEntryParseWithBuffer(ctx context.Context, readBuffer u return nil, errors.Wrap(pullErr, "Error pulling for arrayInfo") } // Count array - arrayInfo := make([]AdsDataTypeArrayInfo, utils.Max(arrayDimensions, 0)) + arrayInfo := make([]AdsDataTypeArrayInfo, max(arrayDimensions, 0)) // This happens when the size is set conditional to 0 if len(arrayInfo) == 0 { arrayInfo = nil } { - _numItems := uint16(utils.Max(arrayDimensions, 0)) + _numItems := uint16(max(arrayDimensions, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -496,13 +496,13 @@ func AdsDataTypeTableChildEntryParseWithBuffer(ctx context.Context, readBuffer u return nil, errors.Wrap(pullErr, "Error pulling for children") } // Count array - children := make([]AdsDataTypeTableEntry, utils.Max(numChildren, 0)) + children := make([]AdsDataTypeTableEntry, max(numChildren, 0)) // This happens when the size is set conditional to 0 if len(children) == 0 { children = nil } { - _numItems := uint16(utils.Max(numChildren, 0)) + _numItems := uint16(max(numChildren, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/ads/readwrite/model/AdsDataTypeTableEntry.go b/plc4go/protocols/ads/readwrite/model/AdsDataTypeTableEntry.go index 236af317992..591c0279827 100644 --- a/plc4go/protocols/ads/readwrite/model/AdsDataTypeTableEntry.go +++ b/plc4go/protocols/ads/readwrite/model/AdsDataTypeTableEntry.go @@ -469,13 +469,13 @@ func AdsDataTypeTableEntryParseWithBuffer(ctx context.Context, readBuffer utils. return nil, errors.Wrap(pullErr, "Error pulling for arrayInfo") } // Count array - arrayInfo := make([]AdsDataTypeArrayInfo, utils.Max(arrayDimensions, 0)) + arrayInfo := make([]AdsDataTypeArrayInfo, max(arrayDimensions, 0)) // This happens when the size is set conditional to 0 if len(arrayInfo) == 0 { arrayInfo = nil } { - _numItems := uint16(utils.Max(arrayDimensions, 0)) + _numItems := uint16(max(arrayDimensions, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -496,13 +496,13 @@ func AdsDataTypeTableEntryParseWithBuffer(ctx context.Context, readBuffer utils. return nil, errors.Wrap(pullErr, "Error pulling for children") } // Count array - children := make([]AdsDataTypeTableChildEntry, utils.Max(numChildren, 0)) + children := make([]AdsDataTypeTableChildEntry, max(numChildren, 0)) // This happens when the size is set conditional to 0 if len(children) == 0 { children = nil } { - _numItems := uint16(utils.Max(numChildren, 0)) + _numItems := uint16(max(numChildren, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/ads/readwrite/model/AdsDeviceNotificationRequest.go b/plc4go/protocols/ads/readwrite/model/AdsDeviceNotificationRequest.go index be8e0befb2c..f5cdb75cd1a 100644 --- a/plc4go/protocols/ads/readwrite/model/AdsDeviceNotificationRequest.go +++ b/plc4go/protocols/ads/readwrite/model/AdsDeviceNotificationRequest.go @@ -198,13 +198,13 @@ func AdsDeviceNotificationRequestParseWithBuffer(ctx context.Context, readBuffer return nil, errors.Wrap(pullErr, "Error pulling for adsStampHeaders") } // Count array - adsStampHeaders := make([]AdsStampHeader, utils.Max(stamps, 0)) + adsStampHeaders := make([]AdsStampHeader, max(stamps, 0)) // This happens when the size is set conditional to 0 if len(adsStampHeaders) == 0 { adsStampHeaders = nil } { - _numItems := uint16(utils.Max(stamps, 0)) + _numItems := uint16(max(stamps, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/ads/readwrite/model/AdsReadWriteRequest.go b/plc4go/protocols/ads/readwrite/model/AdsReadWriteRequest.go index a7426cba6a3..094540b0c93 100644 --- a/plc4go/protocols/ads/readwrite/model/AdsReadWriteRequest.go +++ b/plc4go/protocols/ads/readwrite/model/AdsReadWriteRequest.go @@ -239,13 +239,13 @@ func AdsReadWriteRequestParseWithBuffer(ctx context.Context, readBuffer utils.Re return nil, errors.Wrap(pullErr, "Error pulling for items") } // Count array - items := make([]AdsMultiRequestItem, utils.Max(utils.InlineIf((bool(bool((bool((indexGroup) == (61568)))) || bool((bool((indexGroup) == (61569))))) || bool((bool((indexGroup) == (61570))))), func() any { return uint16(indexOffset) }, func() any { return uint16(uint16(0)) }).(uint16), 0)) + items := make([]AdsMultiRequestItem, max(utils.InlineIf((bool(bool((bool((indexGroup) == (61568)))) || bool((bool((indexGroup) == (61569))))) || bool((bool((indexGroup) == (61570))))), func() any { return uint16(indexOffset) }, func() any { return uint16(uint16(0)) }).(uint16), 0)) // This happens when the size is set conditional to 0 if len(items) == 0 { items = nil } { - _numItems := uint16(utils.Max(utils.InlineIf((bool(bool((bool((indexGroup) == (61568)))) || bool((bool((indexGroup) == (61569))))) || bool((bool((indexGroup) == (61570))))), func() any { return uint16(indexOffset) }, func() any { return uint16(uint16(0)) }).(uint16), 0)) + _numItems := uint16(max(utils.InlineIf((bool(bool((bool((indexGroup) == (61568)))) || bool((bool((indexGroup) == (61569))))) || bool((bool((indexGroup) == (61570))))), func() any { return uint16(indexOffset) }, func() any { return uint16(uint16(0)) }).(uint16), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/ads/readwrite/model/AdsStampHeader.go b/plc4go/protocols/ads/readwrite/model/AdsStampHeader.go index f2713aa0fba..898fa291cea 100644 --- a/plc4go/protocols/ads/readwrite/model/AdsStampHeader.go +++ b/plc4go/protocols/ads/readwrite/model/AdsStampHeader.go @@ -158,13 +158,13 @@ func AdsStampHeaderParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuf return nil, errors.Wrap(pullErr, "Error pulling for adsNotificationSamples") } // Count array - adsNotificationSamples := make([]AdsNotificationSample, utils.Max(samples, 0)) + adsNotificationSamples := make([]AdsNotificationSample, max(samples, 0)) // This happens when the size is set conditional to 0 if len(adsNotificationSamples) == 0 { adsNotificationSamples = nil } { - _numItems := uint16(utils.Max(samples, 0)) + _numItems := uint16(max(samples, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetServiceAckAtomicReadFileRecord.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetServiceAckAtomicReadFileRecord.go index bd40b23974d..5cda1d772cf 100644 --- a/plc4go/protocols/bacnetip/readwrite/model/BACnetServiceAckAtomicReadFileRecord.go +++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetServiceAckAtomicReadFileRecord.go @@ -199,13 +199,13 @@ func BACnetServiceAckAtomicReadFileRecordParseWithBuffer(ctx context.Context, re return nil, errors.Wrap(pullErr, "Error pulling for fileRecordData") } // Count array - fileRecordData := make([]BACnetApplicationTagOctetString, utils.Max(returnedRecordCount.GetPayload().GetActualValue(), 0)) + fileRecordData := make([]BACnetApplicationTagOctetString, max(returnedRecordCount.GetPayload().GetActualValue(), 0)) // This happens when the size is set conditional to 0 if len(fileRecordData) == 0 { fileRecordData = nil } { - _numItems := uint16(utils.Max(returnedRecordCount.GetPayload().GetActualValue(), 0)) + _numItems := uint16(max(returnedRecordCount.GetPayload().GetActualValue(), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetTagPayloadBitString.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetTagPayloadBitString.go index 58eb66a892b..ad41517015b 100644 --- a/plc4go/protocols/bacnetip/readwrite/model/BACnetTagPayloadBitString.go +++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetTagPayloadBitString.go @@ -151,13 +151,13 @@ func BACnetTagPayloadBitStringParseWithBuffer(ctx context.Context, readBuffer ut return nil, errors.Wrap(pullErr, "Error pulling for data") } // Count array - data := make([]bool, utils.Max(uint16((uint16((uint16(actualLength)-uint16(uint16(1))))*uint16(uint16(8))))-uint16(unusedBits), 0)) + data := make([]bool, max(uint16((uint16((uint16(actualLength)-uint16(uint16(1))))*uint16(uint16(8))))-uint16(unusedBits), 0)) // This happens when the size is set conditional to 0 if len(data) == 0 { data = nil } { - _numItems := uint16(utils.Max(uint16((uint16((uint16(actualLength)-uint16(uint16(1))))*uint16(uint16(8))))-uint16(unusedBits), 0)) + _numItems := uint16(max(uint16((uint16((uint16(actualLength)-uint16(uint16(1))))*uint16(uint16(8))))-uint16(unusedBits), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -178,13 +178,13 @@ func BACnetTagPayloadBitStringParseWithBuffer(ctx context.Context, readBuffer ut return nil, errors.Wrap(pullErr, "Error pulling for unused") } // Count array - unused := make([]bool, utils.Max(unusedBits, 0)) + unused := make([]bool, max(unusedBits, 0)) // This happens when the size is set conditional to 0 if len(unused) == 0 { unused = nil } { - _numItems := uint16(utils.Max(unusedBits, 0)) + _numItems := uint16(max(unusedBits, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/bacnetip/readwrite/model/BACnetVendorId.go b/plc4go/protocols/bacnetip/readwrite/model/BACnetVendorId.go index 25b071e0dca..7f51e18f8a6 100644 --- a/plc4go/protocols/bacnetip/readwrite/model/BACnetVendorId.go +++ b/plc4go/protocols/bacnetip/readwrite/model/BACnetVendorId.go @@ -1515,6 +1515,18 @@ const ( BACnetVendorId_HORTENLOT_JIANGSU_CO_LTD BACnetVendorId = 1478 BACnetVendorId_PAXTON_CONTROLS_CORP BACnetVendorId = 1479 BACnetVendorId_FELL_TECHNOLOGYAS BACnetVendorId = 1480 + BACnetVendorId_SHLOK_INFORMATION_SYSTEMS_INDIA_PRIVATE_LIMITED BACnetVendorId = 1481 + BACnetVendorId_MICROGROPLC_LTD BACnetVendorId = 1482 + BACnetVendorId_CLOUDER_OY BACnetVendorId = 1483 + BACnetVendorId_GEBUDE_AUTOMATISIERUNG_GMBH BACnetVendorId = 1484 + BACnetVendorId_SOLVIMUS_GMBH BACnetVendorId = 1485 + BACnetVendorId_GUANG_ZHOU_WANGKONG_LTD BACnetVendorId = 1486 + BACnetVendorId_SAFE_SQUARE_GMBH BACnetVendorId = 1487 + BACnetVendorId_HEKLATECHAB BACnetVendorId = 1488 + BACnetVendorId_SILVAIR BACnetVendorId = 1489 + BACnetVendorId_ADVECO BACnetVendorId = 1490 + BACnetVendorId_EURA_DRIVES_ELECTRIC_CO_LTD BACnetVendorId = 1491 + BACnetVendorId_CALEB_CONTROLS BACnetVendorId = 1492 BACnetVendorId_UNKNOWN_VENDOR BACnetVendorId = 0xFFFF ) @@ -2995,6 +3007,18 @@ func init() { BACnetVendorId_HORTENLOT_JIANGSU_CO_LTD, BACnetVendorId_PAXTON_CONTROLS_CORP, BACnetVendorId_FELL_TECHNOLOGYAS, + BACnetVendorId_SHLOK_INFORMATION_SYSTEMS_INDIA_PRIVATE_LIMITED, + BACnetVendorId_MICROGROPLC_LTD, + BACnetVendorId_CLOUDER_OY, + BACnetVendorId_GEBUDE_AUTOMATISIERUNG_GMBH, + BACnetVendorId_SOLVIMUS_GMBH, + BACnetVendorId_GUANG_ZHOU_WANGKONG_LTD, + BACnetVendorId_SAFE_SQUARE_GMBH, + BACnetVendorId_HEKLATECHAB, + BACnetVendorId_SILVAIR, + BACnetVendorId_ADVECO, + BACnetVendorId_EURA_DRIVES_ELECTRIC_CO_LTD, + BACnetVendorId_CALEB_CONTROLS, BACnetVendorId_UNKNOWN_VENDOR, } } @@ -5141,10 +5165,58 @@ func (e BACnetVendorId) VendorId() uint16 { { /* '1480' */ return 1480 } + case 1481: + { /* '1481' */ + return 1481 + } + case 1482: + { /* '1482' */ + return 1482 + } + case 1483: + { /* '1483' */ + return 1483 + } + case 1484: + { /* '1484' */ + return 1484 + } + case 1485: + { /* '1485' */ + return 1485 + } + case 1486: + { /* '1486' */ + return 1486 + } + case 1487: + { /* '1487' */ + return 1487 + } + case 1488: + { /* '1488' */ + return 1488 + } + case 1489: + { /* '1489' */ + return 1489 + } case 149: { /* '149' */ return 149 } + case 1490: + { /* '1490' */ + return 1490 + } + case 1491: + { /* '1491' */ + return 1491 + } + case 1492: + { /* '1492' */ + return 1492 + } case 15: { /* '15' */ return 15 @@ -11051,10 +11123,58 @@ func (e BACnetVendorId) VendorName() string { { /* '1480' */ return "Fell Technology AS" } + case 1481: + { /* '1481' */ + return "SHLOK Information Systems India Private Limited" + } + case 1482: + { /* '1482' */ + return "Microgro PLC Ltd." + } + case 1483: + { /* '1483' */ + return "Clouder Oy" + } + case 1484: + { /* '1484' */ + return "Gebäude Automatisierung GmbH" + } + case 1485: + { /* '1485' */ + return "solvimus GmbH" + } + case 1486: + { /* '1486' */ + return "GuangZhou Wangkong Ltd." + } + case 1487: + { /* '1487' */ + return "SafeSquare GmbH" + } + case 1488: + { /* '1488' */ + return "Heklatech AB" + } + case 1489: + { /* '1489' */ + return "Silvair" + } case 149: { /* '149' */ return "Airtek International Inc." } + case 1490: + { /* '1490' */ + return "Adveco" + } + case 1491: + { /* '1491' */ + return "Eura Drives Electric Co., Ltd." + } + case 1492: + { /* '1492' */ + return "Caleb Controls" + } case 15: { /* '15' */ return "Cornell University" @@ -15890,8 +16010,32 @@ func BACnetVendorIdByValue(value uint16) (enum BACnetVendorId, ok bool) { return BACnetVendorId_TEMCO_CONTROLS_LTD, true case 1480: return BACnetVendorId_FELL_TECHNOLOGYAS, true + case 1481: + return BACnetVendorId_SHLOK_INFORMATION_SYSTEMS_INDIA_PRIVATE_LIMITED, true + case 1482: + return BACnetVendorId_MICROGROPLC_LTD, true + case 1483: + return BACnetVendorId_CLOUDER_OY, true + case 1484: + return BACnetVendorId_GEBUDE_AUTOMATISIERUNG_GMBH, true + case 1485: + return BACnetVendorId_SOLVIMUS_GMBH, true + case 1486: + return BACnetVendorId_GUANG_ZHOU_WANGKONG_LTD, true + case 1487: + return BACnetVendorId_SAFE_SQUARE_GMBH, true + case 1488: + return BACnetVendorId_HEKLATECHAB, true + case 1489: + return BACnetVendorId_SILVAIR, true case 149: return BACnetVendorId_AIRTEK_INTERNATIONAL_INC, true + case 1490: + return BACnetVendorId_ADVECO, true + case 1491: + return BACnetVendorId_EURA_DRIVES_ELECTRIC_CO_LTD, true + case 1492: + return BACnetVendorId_CALEB_CONTROLS, true case 15: return BACnetVendorId_CORNELL_UNIVERSITY, true case 150: @@ -18842,8 +18986,32 @@ func BACnetVendorIdByName(value string) (enum BACnetVendorId, ok bool) { return BACnetVendorId_TEMCO_CONTROLS_LTD, true case "FELL_TECHNOLOGYAS": return BACnetVendorId_FELL_TECHNOLOGYAS, true + case "SHLOK_INFORMATION_SYSTEMS_INDIA_PRIVATE_LIMITED": + return BACnetVendorId_SHLOK_INFORMATION_SYSTEMS_INDIA_PRIVATE_LIMITED, true + case "MICROGROPLC_LTD": + return BACnetVendorId_MICROGROPLC_LTD, true + case "CLOUDER_OY": + return BACnetVendorId_CLOUDER_OY, true + case "GEBUDE_AUTOMATISIERUNG_GMBH": + return BACnetVendorId_GEBUDE_AUTOMATISIERUNG_GMBH, true + case "SOLVIMUS_GMBH": + return BACnetVendorId_SOLVIMUS_GMBH, true + case "GUANG_ZHOU_WANGKONG_LTD": + return BACnetVendorId_GUANG_ZHOU_WANGKONG_LTD, true + case "SAFE_SQUARE_GMBH": + return BACnetVendorId_SAFE_SQUARE_GMBH, true + case "HEKLATECHAB": + return BACnetVendorId_HEKLATECHAB, true + case "SILVAIR": + return BACnetVendorId_SILVAIR, true case "AIRTEK_INTERNATIONAL_INC": return BACnetVendorId_AIRTEK_INTERNATIONAL_INC, true + case "ADVECO": + return BACnetVendorId_ADVECO, true + case "EURA_DRIVES_ELECTRIC_CO_LTD": + return BACnetVendorId_EURA_DRIVES_ELECTRIC_CO_LTD, true + case "CALEB_CONTROLS": + return BACnetVendorId_CALEB_CONTROLS, true case "CORNELL_UNIVERSITY": return BACnetVendorId_CORNELL_UNIVERSITY, true case "ADVANTECH_CORPORATION": @@ -21855,8 +22023,32 @@ func (e BACnetVendorId) PLC4XEnumName() string { return "TEMCO_CONTROLS_LTD" case BACnetVendorId_FELL_TECHNOLOGYAS: return "FELL_TECHNOLOGYAS" + case BACnetVendorId_SHLOK_INFORMATION_SYSTEMS_INDIA_PRIVATE_LIMITED: + return "SHLOK_INFORMATION_SYSTEMS_INDIA_PRIVATE_LIMITED" + case BACnetVendorId_MICROGROPLC_LTD: + return "MICROGROPLC_LTD" + case BACnetVendorId_CLOUDER_OY: + return "CLOUDER_OY" + case BACnetVendorId_GEBUDE_AUTOMATISIERUNG_GMBH: + return "GEBUDE_AUTOMATISIERUNG_GMBH" + case BACnetVendorId_SOLVIMUS_GMBH: + return "SOLVIMUS_GMBH" + case BACnetVendorId_GUANG_ZHOU_WANGKONG_LTD: + return "GUANG_ZHOU_WANGKONG_LTD" + case BACnetVendorId_SAFE_SQUARE_GMBH: + return "SAFE_SQUARE_GMBH" + case BACnetVendorId_HEKLATECHAB: + return "HEKLATECHAB" + case BACnetVendorId_SILVAIR: + return "SILVAIR" case BACnetVendorId_AIRTEK_INTERNATIONAL_INC: return "AIRTEK_INTERNATIONAL_INC" + case BACnetVendorId_ADVECO: + return "ADVECO" + case BACnetVendorId_EURA_DRIVES_ELECTRIC_CO_LTD: + return "EURA_DRIVES_ELECTRIC_CO_LTD" + case BACnetVendorId_CALEB_CONTROLS: + return "CALEB_CONTROLS" case BACnetVendorId_CORNELL_UNIVERSITY: return "CORNELL_UNIVERSITY" case BACnetVendorId_ADVANTECH_CORPORATION: diff --git a/plc4go/protocols/bacnetip/readwrite/model/BVLCBroadcastDistributionTableEntry.go b/plc4go/protocols/bacnetip/readwrite/model/BVLCBroadcastDistributionTableEntry.go index bf884b31696..850a21b5aee 100644 --- a/plc4go/protocols/bacnetip/readwrite/model/BVLCBroadcastDistributionTableEntry.go +++ b/plc4go/protocols/bacnetip/readwrite/model/BVLCBroadcastDistributionTableEntry.go @@ -141,13 +141,13 @@ func BVLCBroadcastDistributionTableEntryParseWithBuffer(ctx context.Context, rea return nil, errors.Wrap(pullErr, "Error pulling for ip") } // Count array - ip := make([]uint8, utils.Max(uint16(4), 0)) + ip := make([]uint8, max(uint16(4), 0)) // This happens when the size is set conditional to 0 if len(ip) == 0 { ip = nil } { - _numItems := uint16(utils.Max(uint16(4), 0)) + _numItems := uint16(max(uint16(4), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -175,13 +175,13 @@ func BVLCBroadcastDistributionTableEntryParseWithBuffer(ctx context.Context, rea return nil, errors.Wrap(pullErr, "Error pulling for broadcastDistributionMap") } // Count array - broadcastDistributionMap := make([]uint8, utils.Max(uint16(4), 0)) + broadcastDistributionMap := make([]uint8, max(uint16(4), 0)) // This happens when the size is set conditional to 0 if len(broadcastDistributionMap) == 0 { broadcastDistributionMap = nil } { - _numItems := uint16(utils.Max(uint16(4), 0)) + _numItems := uint16(max(uint16(4), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/bacnetip/readwrite/model/BVLCDeleteForeignDeviceTableEntry.go b/plc4go/protocols/bacnetip/readwrite/model/BVLCDeleteForeignDeviceTableEntry.go index 4b57d675427..0bd3168781f 100644 --- a/plc4go/protocols/bacnetip/readwrite/model/BVLCDeleteForeignDeviceTableEntry.go +++ b/plc4go/protocols/bacnetip/readwrite/model/BVLCDeleteForeignDeviceTableEntry.go @@ -158,13 +158,13 @@ func BVLCDeleteForeignDeviceTableEntryParseWithBuffer(ctx context.Context, readB return nil, errors.Wrap(pullErr, "Error pulling for ip") } // Count array - ip := make([]uint8, utils.Max(uint16(4), 0)) + ip := make([]uint8, max(uint16(4), 0)) // This happens when the size is set conditional to 0 if len(ip) == 0 { ip = nil } { - _numItems := uint16(utils.Max(uint16(4), 0)) + _numItems := uint16(max(uint16(4), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/bacnetip/readwrite/model/BVLCForeignDeviceTableEntry.go b/plc4go/protocols/bacnetip/readwrite/model/BVLCForeignDeviceTableEntry.go index 4628c8f27cb..0a6d8004a54 100644 --- a/plc4go/protocols/bacnetip/readwrite/model/BVLCForeignDeviceTableEntry.go +++ b/plc4go/protocols/bacnetip/readwrite/model/BVLCForeignDeviceTableEntry.go @@ -149,13 +149,13 @@ func BVLCForeignDeviceTableEntryParseWithBuffer(ctx context.Context, readBuffer return nil, errors.Wrap(pullErr, "Error pulling for ip") } // Count array - ip := make([]uint8, utils.Max(uint16(4), 0)) + ip := make([]uint8, max(uint16(4), 0)) // This happens when the size is set conditional to 0 if len(ip) == 0 { ip = nil } { - _numItems := uint16(utils.Max(uint16(4), 0)) + _numItems := uint16(max(uint16(4), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/bacnetip/readwrite/model/BVLCForwardedNPDU.go b/plc4go/protocols/bacnetip/readwrite/model/BVLCForwardedNPDU.go index da5e7457d89..0c4fa313c80 100644 --- a/plc4go/protocols/bacnetip/readwrite/model/BVLCForwardedNPDU.go +++ b/plc4go/protocols/bacnetip/readwrite/model/BVLCForwardedNPDU.go @@ -172,13 +172,13 @@ func BVLCForwardedNPDUParseWithBuffer(ctx context.Context, readBuffer utils.Read return nil, errors.Wrap(pullErr, "Error pulling for ip") } // Count array - ip := make([]uint8, utils.Max(uint16(4), 0)) + ip := make([]uint8, max(uint16(4), 0)) // This happens when the size is set conditional to 0 if len(ip) == 0 { ip = nil } { - _numItems := uint16(utils.Max(uint16(4), 0)) + _numItems := uint16(max(uint16(4), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/bacnetip/readwrite/model/NLMInitalizeRoutingTable.go b/plc4go/protocols/bacnetip/readwrite/model/NLMInitalizeRoutingTable.go index 27e1d04a6b7..7ae848cc14c 100644 --- a/plc4go/protocols/bacnetip/readwrite/model/NLMInitalizeRoutingTable.go +++ b/plc4go/protocols/bacnetip/readwrite/model/NLMInitalizeRoutingTable.go @@ -169,13 +169,13 @@ func NLMInitalizeRoutingTableParseWithBuffer(ctx context.Context, readBuffer uti return nil, errors.Wrap(pullErr, "Error pulling for portMappings") } // Count array - portMappings := make([]NLMInitalizeRoutingTablePortMapping, utils.Max(numberOfPorts, 0)) + portMappings := make([]NLMInitalizeRoutingTablePortMapping, max(numberOfPorts, 0)) // This happens when the size is set conditional to 0 if len(portMappings) == 0 { portMappings = nil } { - _numItems := uint16(utils.Max(numberOfPorts, 0)) + _numItems := uint16(max(numberOfPorts, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/bacnetip/readwrite/model/NLMInitalizeRoutingTableAck.go b/plc4go/protocols/bacnetip/readwrite/model/NLMInitalizeRoutingTableAck.go index f2d007c52a9..a73f558b737 100644 --- a/plc4go/protocols/bacnetip/readwrite/model/NLMInitalizeRoutingTableAck.go +++ b/plc4go/protocols/bacnetip/readwrite/model/NLMInitalizeRoutingTableAck.go @@ -169,13 +169,13 @@ func NLMInitalizeRoutingTableAckParseWithBuffer(ctx context.Context, readBuffer return nil, errors.Wrap(pullErr, "Error pulling for portMappings") } // Count array - portMappings := make([]NLMInitalizeRoutingTablePortMapping, utils.Max(numberOfPorts, 0)) + portMappings := make([]NLMInitalizeRoutingTablePortMapping, max(numberOfPorts, 0)) // This happens when the size is set conditional to 0 if len(portMappings) == 0 { portMappings = nil } { - _numItems := uint16(utils.Max(numberOfPorts, 0)) + _numItems := uint16(max(numberOfPorts, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/bacnetip/readwrite/model/NLMUpdateKeyUpdate.go b/plc4go/protocols/bacnetip/readwrite/model/NLMUpdateKeyUpdate.go index 3e7c514f3e9..93c0572edd8 100644 --- a/plc4go/protocols/bacnetip/readwrite/model/NLMUpdateKeyUpdate.go +++ b/plc4go/protocols/bacnetip/readwrite/model/NLMUpdateKeyUpdate.go @@ -337,13 +337,13 @@ func NLMUpdateKeyUpdateParseWithBuffer(ctx context.Context, readBuffer utils.Rea return nil, errors.Wrap(pullErr, "Error pulling for set1Keys") } // Count array - set1Keys := make([]NLMUpdateKeyUpdateKeyEntry, utils.Max(utils.InlineIf(bool((set1KeyCount) != (nil)), func() any { return uint16((*set1KeyCount)) }, func() any { return uint16(uint16(0)) }).(uint16), 0)) + set1Keys := make([]NLMUpdateKeyUpdateKeyEntry, max(utils.InlineIf(bool((set1KeyCount) != (nil)), func() any { return uint16((*set1KeyCount)) }, func() any { return uint16(uint16(0)) }).(uint16), 0)) // This happens when the size is set conditional to 0 if len(set1Keys) == 0 { set1Keys = nil } { - _numItems := uint16(utils.Max(utils.InlineIf(bool((set1KeyCount) != (nil)), func() any { return uint16((*set1KeyCount)) }, func() any { return uint16(uint16(0)) }).(uint16), 0)) + _numItems := uint16(max(utils.InlineIf(bool((set1KeyCount) != (nil)), func() any { return uint16((*set1KeyCount)) }, func() any { return uint16(uint16(0)) }).(uint16), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -404,13 +404,13 @@ func NLMUpdateKeyUpdateParseWithBuffer(ctx context.Context, readBuffer utils.Rea return nil, errors.Wrap(pullErr, "Error pulling for set2Keys") } // Count array - set2Keys := make([]NLMUpdateKeyUpdateKeyEntry, utils.Max(utils.InlineIf(bool((set1KeyCount) != (nil)), func() any { return uint16((*set1KeyCount)) }, func() any { return uint16(uint16(0)) }).(uint16), 0)) + set2Keys := make([]NLMUpdateKeyUpdateKeyEntry, max(utils.InlineIf(bool((set1KeyCount) != (nil)), func() any { return uint16((*set1KeyCount)) }, func() any { return uint16(uint16(0)) }).(uint16), 0)) // This happens when the size is set conditional to 0 if len(set2Keys) == 0 { set2Keys = nil } { - _numItems := uint16(utils.Max(utils.InlineIf(bool((set1KeyCount) != (nil)), func() any { return uint16((*set1KeyCount)) }, func() any { return uint16(uint16(0)) }).(uint16), 0)) + _numItems := uint16(max(utils.InlineIf(bool((set1KeyCount) != (nil)), func() any { return uint16((*set1KeyCount)) }, func() any { return uint16(uint16(0)) }).(uint16), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/bacnetip/readwrite/model/NPDU.go b/plc4go/protocols/bacnetip/readwrite/model/NPDU.go index 792dc94abcf..322898051cb 100644 --- a/plc4go/protocols/bacnetip/readwrite/model/NPDU.go +++ b/plc4go/protocols/bacnetip/readwrite/model/NPDU.go @@ -360,13 +360,13 @@ func NPDUParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, npduL return nil, errors.Wrap(pullErr, "Error pulling for destinationAddress") } // Count array - destinationAddress := make([]uint8, utils.Max(utils.InlineIf(control.GetDestinationSpecified(), func() any { return uint16((*destinationLength)) }, func() any { return uint16(uint16(0)) }).(uint16), 0)) + destinationAddress := make([]uint8, max(utils.InlineIf(control.GetDestinationSpecified(), func() any { return uint16((*destinationLength)) }, func() any { return uint16(uint16(0)) }).(uint16), 0)) // This happens when the size is set conditional to 0 if len(destinationAddress) == 0 { destinationAddress = nil } { - _numItems := uint16(utils.Max(utils.InlineIf(control.GetDestinationSpecified(), func() any { return uint16((*destinationLength)) }, func() any { return uint16(uint16(0)) }).(uint16), 0)) + _numItems := uint16(max(utils.InlineIf(control.GetDestinationSpecified(), func() any { return uint16((*destinationLength)) }, func() any { return uint16(uint16(0)) }).(uint16), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -412,13 +412,13 @@ func NPDUParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, npduL return nil, errors.Wrap(pullErr, "Error pulling for sourceAddress") } // Count array - sourceAddress := make([]uint8, utils.Max(utils.InlineIf(control.GetSourceSpecified(), func() any { return uint16((*sourceLength)) }, func() any { return uint16(uint16(0)) }).(uint16), 0)) + sourceAddress := make([]uint8, max(utils.InlineIf(control.GetSourceSpecified(), func() any { return uint16((*sourceLength)) }, func() any { return uint16(uint16(0)) }).(uint16), 0)) // This happens when the size is set conditional to 0 if len(sourceAddress) == 0 { sourceAddress = nil } { - _numItems := uint16(utils.Max(utils.InlineIf(control.GetSourceSpecified(), func() any { return uint16((*sourceLength)) }, func() any { return uint16(uint16(0)) }).(uint16), 0)) + _numItems := uint16(max(utils.InlineIf(control.GetSourceSpecified(), func() any { return uint16((*sourceLength)) }, func() any { return uint16(uint16(0)) }).(uint16), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/cbus/readwrite/model/CALDataStatus.go b/plc4go/protocols/cbus/readwrite/model/CALDataStatus.go index eb66455897a..74f9528f1a5 100644 --- a/plc4go/protocols/cbus/readwrite/model/CALDataStatus.go +++ b/plc4go/protocols/cbus/readwrite/model/CALDataStatus.go @@ -192,13 +192,13 @@ func CALDataStatusParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuff return nil, errors.Wrap(pullErr, "Error pulling for statusBytes") } // Count array - statusBytes := make([]StatusByte, utils.Max(uint16(commandTypeContainer.NumBytes())-uint16(uint16(2)), 0)) + statusBytes := make([]StatusByte, max(uint16(commandTypeContainer.NumBytes())-uint16(uint16(2)), 0)) // This happens when the size is set conditional to 0 if len(statusBytes) == 0 { statusBytes = nil } { - _numItems := uint16(utils.Max(uint16(commandTypeContainer.NumBytes())-uint16(uint16(2)), 0)) + _numItems := uint16(max(uint16(commandTypeContainer.NumBytes())-uint16(uint16(2)), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/cbus/readwrite/model/CALDataStatusExtended.go b/plc4go/protocols/cbus/readwrite/model/CALDataStatusExtended.go index a4480d77c17..41a7f138d7c 100644 --- a/plc4go/protocols/cbus/readwrite/model/CALDataStatusExtended.go +++ b/plc4go/protocols/cbus/readwrite/model/CALDataStatusExtended.go @@ -277,13 +277,13 @@ func CALDataStatusExtendedParseWithBuffer(ctx context.Context, readBuffer utils. return nil, errors.Wrap(pullErr, "Error pulling for statusBytes") } // Count array - statusBytes := make([]StatusByte, utils.Max(numberOfStatusBytes, 0)) + statusBytes := make([]StatusByte, max(numberOfStatusBytes, 0)) // This happens when the size is set conditional to 0 if len(statusBytes) == 0 { statusBytes = nil } { - _numItems := uint16(utils.Max(numberOfStatusBytes, 0)) + _numItems := uint16(max(numberOfStatusBytes, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -304,13 +304,13 @@ func CALDataStatusExtendedParseWithBuffer(ctx context.Context, readBuffer utils. return nil, errors.Wrap(pullErr, "Error pulling for levelInformation") } // Count array - levelInformation := make([]LevelInformation, utils.Max(numberOfLevelInformation, 0)) + levelInformation := make([]LevelInformation, max(numberOfLevelInformation, 0)) // This happens when the size is set conditional to 0 if len(levelInformation) == 0 { levelInformation = nil } { - _numItems := uint16(utils.Max(numberOfLevelInformation, 0)) + _numItems := uint16(max(numberOfLevelInformation, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/cbus/readwrite/model/IdentifyReplyCommandLogicalAssignment.go b/plc4go/protocols/cbus/readwrite/model/IdentifyReplyCommandLogicalAssignment.go index 55ebba2dbbf..8f37c57d734 100644 --- a/plc4go/protocols/cbus/readwrite/model/IdentifyReplyCommandLogicalAssignment.go +++ b/plc4go/protocols/cbus/readwrite/model/IdentifyReplyCommandLogicalAssignment.go @@ -151,13 +151,13 @@ func IdentifyReplyCommandLogicalAssignmentParseWithBuffer(ctx context.Context, r return nil, errors.Wrap(pullErr, "Error pulling for logicAssigment") } // Count array - logicAssigment := make([]LogicAssignment, utils.Max(numBytes, 0)) + logicAssigment := make([]LogicAssignment, max(numBytes, 0)) // This happens when the size is set conditional to 0 if len(logicAssigment) == 0 { logicAssigment = nil } { - _numItems := uint16(utils.Max(numBytes, 0)) + _numItems := uint16(max(numBytes, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/cbus/readwrite/model/NetworkRoute.go b/plc4go/protocols/cbus/readwrite/model/NetworkRoute.go index 98480aacc54..36f37fab7d3 100644 --- a/plc4go/protocols/cbus/readwrite/model/NetworkRoute.go +++ b/plc4go/protocols/cbus/readwrite/model/NetworkRoute.go @@ -147,13 +147,13 @@ func NetworkRouteParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffe return nil, errors.Wrap(pullErr, "Error pulling for additionalBridgeAddresses") } // Count array - additionalBridgeAddresses := make([]BridgeAddress, utils.Max(uint16(networkPCI.GetStackDepth())-uint16(uint16(1)), 0)) + additionalBridgeAddresses := make([]BridgeAddress, max(uint16(networkPCI.GetStackDepth())-uint16(uint16(1)), 0)) // This happens when the size is set conditional to 0 if len(additionalBridgeAddresses) == 0 { additionalBridgeAddresses = nil } { - _numItems := uint16(utils.Max(uint16(networkPCI.GetStackDepth())-uint16(uint16(1)), 0)) + _numItems := uint16(max(uint16(networkPCI.GetStackDepth())-uint16(uint16(1)), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/cbus/readwrite/model/SecurityDataStatusReport1.go b/plc4go/protocols/cbus/readwrite/model/SecurityDataStatusReport1.go index b8c05b8d6c5..a31720adf60 100644 --- a/plc4go/protocols/cbus/readwrite/model/SecurityDataStatusReport1.go +++ b/plc4go/protocols/cbus/readwrite/model/SecurityDataStatusReport1.go @@ -222,13 +222,13 @@ func SecurityDataStatusReport1ParseWithBuffer(ctx context.Context, readBuffer ut return nil, errors.Wrap(pullErr, "Error pulling for zoneStatus") } // Count array - zoneStatus := make([]ZoneStatus, utils.Max(uint16(32), 0)) + zoneStatus := make([]ZoneStatus, max(uint16(32), 0)) // This happens when the size is set conditional to 0 if len(zoneStatus) == 0 { zoneStatus = nil } { - _numItems := uint16(utils.Max(uint16(32), 0)) + _numItems := uint16(max(uint16(32), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/cbus/readwrite/model/SecurityDataStatusReport2.go b/plc4go/protocols/cbus/readwrite/model/SecurityDataStatusReport2.go index a757e11e778..03b256ad891 100644 --- a/plc4go/protocols/cbus/readwrite/model/SecurityDataStatusReport2.go +++ b/plc4go/protocols/cbus/readwrite/model/SecurityDataStatusReport2.go @@ -150,13 +150,13 @@ func SecurityDataStatusReport2ParseWithBuffer(ctx context.Context, readBuffer ut return nil, errors.Wrap(pullErr, "Error pulling for zoneStatus") } // Count array - zoneStatus := make([]ZoneStatus, utils.Max(uint16(48), 0)) + zoneStatus := make([]ZoneStatus, max(uint16(48), 0)) // This happens when the size is set conditional to 0 if len(zoneStatus) == 0 { zoneStatus = nil } { - _numItems := uint16(utils.Max(uint16(48), 0)) + _numItems := uint16(max(uint16(48), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/eip/readwrite/model/CIPAttributes.go b/plc4go/protocols/eip/readwrite/model/CIPAttributes.go index 046ed3d28d9..8f7c60c1f42 100644 --- a/plc4go/protocols/eip/readwrite/model/CIPAttributes.go +++ b/plc4go/protocols/eip/readwrite/model/CIPAttributes.go @@ -168,13 +168,13 @@ func CIPAttributesParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuff return nil, errors.Wrap(pullErr, "Error pulling for classId") } // Count array - classId := make([]uint16, utils.Max(numberOfClasses, 0)) + classId := make([]uint16, max(numberOfClasses, 0)) // This happens when the size is set conditional to 0 if len(classId) == 0 { classId = nil } { - _numItems := uint16(utils.Max(numberOfClasses, 0)) + _numItems := uint16(max(numberOfClasses, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/eip/readwrite/model/CipIdentity.go b/plc4go/protocols/eip/readwrite/model/CipIdentity.go index 848a50cebf1..ebd8f945184 100644 --- a/plc4go/protocols/eip/readwrite/model/CipIdentity.go +++ b/plc4go/protocols/eip/readwrite/model/CipIdentity.go @@ -339,13 +339,13 @@ func CipIdentityParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer return nil, errors.Wrap(pullErr, "Error pulling for socketAddressAddress") } // Count array - socketAddressAddress := make([]uint8, utils.Max(uint16(4), 0)) + socketAddressAddress := make([]uint8, max(uint16(4), 0)) // This happens when the size is set conditional to 0 if len(socketAddressAddress) == 0 { socketAddressAddress = nil } { - _numItems := uint16(utils.Max(uint16(4), 0)) + _numItems := uint16(max(uint16(4), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/eip/readwrite/model/CipRRData.go b/plc4go/protocols/eip/readwrite/model/CipRRData.go index 9ad8dfe5f22..2105641d6f2 100644 --- a/plc4go/protocols/eip/readwrite/model/CipRRData.go +++ b/plc4go/protocols/eip/readwrite/model/CipRRData.go @@ -210,13 +210,13 @@ func CipRRDataParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, return nil, errors.Wrap(pullErr, "Error pulling for typeIds") } // Count array - typeIds := make([]TypeId, utils.Max(typeIdCount, 0)) + typeIds := make([]TypeId, max(typeIdCount, 0)) // This happens when the size is set conditional to 0 if len(typeIds) == 0 { typeIds = nil } { - _numItems := uint16(utils.Max(typeIdCount, 0)) + _numItems := uint16(max(typeIdCount, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/eip/readwrite/model/CipSecurityInformation.go b/plc4go/protocols/eip/readwrite/model/CipSecurityInformation.go index ed6b4109a74..994e490f319 100644 --- a/plc4go/protocols/eip/readwrite/model/CipSecurityInformation.go +++ b/plc4go/protocols/eip/readwrite/model/CipSecurityInformation.go @@ -156,13 +156,13 @@ func CipSecurityInformationParseWithBuffer(ctx context.Context, readBuffer utils return nil, errors.Wrap(pullErr, "Error pulling for todoImplement") } // Count array - todoImplement := make([]uint8, utils.Max(itemLength, 0)) + todoImplement := make([]uint8, max(itemLength, 0)) // This happens when the size is set conditional to 0 if len(todoImplement) == 0 { todoImplement = nil } { - _numItems := uint16(utils.Max(itemLength, 0)) + _numItems := uint16(max(itemLength, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/eip/readwrite/model/EipListIdentityResponse.go b/plc4go/protocols/eip/readwrite/model/EipListIdentityResponse.go index cf3b967b493..2fc227b29e0 100644 --- a/plc4go/protocols/eip/readwrite/model/EipListIdentityResponse.go +++ b/plc4go/protocols/eip/readwrite/model/EipListIdentityResponse.go @@ -174,13 +174,13 @@ func EipListIdentityResponseParseWithBuffer(ctx context.Context, readBuffer util return nil, errors.Wrap(pullErr, "Error pulling for items") } // Count array - items := make([]CommandSpecificDataItem, utils.Max(itemCount, 0)) + items := make([]CommandSpecificDataItem, max(itemCount, 0)) // This happens when the size is set conditional to 0 if len(items) == 0 { items = nil } { - _numItems := uint16(utils.Max(itemCount, 0)) + _numItems := uint16(max(itemCount, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/eip/readwrite/model/ListServicesResponse.go b/plc4go/protocols/eip/readwrite/model/ListServicesResponse.go index 5a58cb8eb91..b938b54eefc 100644 --- a/plc4go/protocols/eip/readwrite/model/ListServicesResponse.go +++ b/plc4go/protocols/eip/readwrite/model/ListServicesResponse.go @@ -174,13 +174,13 @@ func ListServicesResponseParseWithBuffer(ctx context.Context, readBuffer utils.R return nil, errors.Wrap(pullErr, "Error pulling for typeIds") } // Count array - typeIds := make([]TypeId, utils.Max(typeIdCount, 0)) + typeIds := make([]TypeId, max(typeIdCount, 0)) // This happens when the size is set conditional to 0 if len(typeIds) == 0 { typeIds = nil } { - _numItems := uint16(utils.Max(typeIdCount, 0)) + _numItems := uint16(max(typeIdCount, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/eip/readwrite/model/MultipleServiceResponse.go b/plc4go/protocols/eip/readwrite/model/MultipleServiceResponse.go index 39c6a6f8651..30d428d7e6d 100644 --- a/plc4go/protocols/eip/readwrite/model/MultipleServiceResponse.go +++ b/plc4go/protocols/eip/readwrite/model/MultipleServiceResponse.go @@ -243,13 +243,13 @@ func MultipleServiceResponseParseWithBuffer(ctx context.Context, readBuffer util return nil, errors.Wrap(pullErr, "Error pulling for offsets") } // Count array - offsets := make([]uint16, utils.Max(serviceNb, 0)) + offsets := make([]uint16, max(serviceNb, 0)) // This happens when the size is set conditional to 0 if len(offsets) == 0 { offsets = nil } { - _numItems := uint16(utils.Max(serviceNb, 0)) + _numItems := uint16(max(serviceNb, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/eip/readwrite/model/SendUnitData.go b/plc4go/protocols/eip/readwrite/model/SendUnitData.go index 642eeb5d57a..73b23ba5456 100644 --- a/plc4go/protocols/eip/readwrite/model/SendUnitData.go +++ b/plc4go/protocols/eip/readwrite/model/SendUnitData.go @@ -220,13 +220,13 @@ func SendUnitDataParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffe return nil, errors.Wrap(pullErr, "Error pulling for typeIds") } // Count array - typeIds := make([]TypeId, utils.Max(typeIdCount, 0)) + typeIds := make([]TypeId, max(typeIdCount, 0)) // This happens when the size is set conditional to 0 if len(typeIds) == 0 { typeIds = nil } { - _numItems := uint16(utils.Max(typeIdCount, 0)) + _numItems := uint16(max(typeIdCount, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/eip/readwrite/model/Services.go b/plc4go/protocols/eip/readwrite/model/Services.go index 0f034ce2da4..5e99bde3efc 100644 --- a/plc4go/protocols/eip/readwrite/model/Services.go +++ b/plc4go/protocols/eip/readwrite/model/Services.go @@ -149,13 +149,13 @@ func ServicesParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, s return nil, errors.Wrap(pullErr, "Error pulling for offsets") } // Count array - offsets := make([]uint16, utils.Max(serviceNb, 0)) + offsets := make([]uint16, max(serviceNb, 0)) // This happens when the size is set conditional to 0 if len(offsets) == 0 { offsets = nil } { - _numItems := uint16(utils.Max(serviceNb, 0)) + _numItems := uint16(max(serviceNb, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -176,13 +176,13 @@ func ServicesParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, s return nil, errors.Wrap(pullErr, "Error pulling for services") } // Count array - services := make([]CipService, utils.Max(serviceNb, 0)) + services := make([]CipService, max(serviceNb, 0)) // This happens when the size is set conditional to 0 if len(services) == 0 { services = nil } { - _numItems := uint16(utils.Max(serviceNb, 0)) + _numItems := uint16(max(serviceNb, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/firmata/readwrite/model/FirmataMessageAnalogIO.go b/plc4go/protocols/firmata/readwrite/model/FirmataMessageAnalogIO.go index 89531ede63e..790911cada1 100644 --- a/plc4go/protocols/firmata/readwrite/model/FirmataMessageAnalogIO.go +++ b/plc4go/protocols/firmata/readwrite/model/FirmataMessageAnalogIO.go @@ -165,13 +165,13 @@ func FirmataMessageAnalogIOParseWithBuffer(ctx context.Context, readBuffer utils return nil, errors.Wrap(pullErr, "Error pulling for data") } // Count array - data := make([]int8, utils.Max(uint16(2), 0)) + data := make([]int8, max(uint16(2), 0)) // This happens when the size is set conditional to 0 if len(data) == 0 { data = nil } { - _numItems := uint16(utils.Max(uint16(2), 0)) + _numItems := uint16(max(uint16(2), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/firmata/readwrite/model/FirmataMessageDigitalIO.go b/plc4go/protocols/firmata/readwrite/model/FirmataMessageDigitalIO.go index e953daa34c0..093e8cb7eb5 100644 --- a/plc4go/protocols/firmata/readwrite/model/FirmataMessageDigitalIO.go +++ b/plc4go/protocols/firmata/readwrite/model/FirmataMessageDigitalIO.go @@ -165,13 +165,13 @@ func FirmataMessageDigitalIOParseWithBuffer(ctx context.Context, readBuffer util return nil, errors.Wrap(pullErr, "Error pulling for data") } // Count array - data := make([]int8, utils.Max(uint16(2), 0)) + data := make([]int8, max(uint16(2), 0)) // This happens when the size is set conditional to 0 if len(data) == 0 { data = nil } { - _numItems := uint16(utils.Max(uint16(2), 0)) + _numItems := uint16(max(uint16(2), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/firmata/readwrite/model/SysexCommandExtendedId.go b/plc4go/protocols/firmata/readwrite/model/SysexCommandExtendedId.go index 020486da4a0..51fde1ed93e 100644 --- a/plc4go/protocols/firmata/readwrite/model/SysexCommandExtendedId.go +++ b/plc4go/protocols/firmata/readwrite/model/SysexCommandExtendedId.go @@ -150,13 +150,13 @@ func SysexCommandExtendedIdParseWithBuffer(ctx context.Context, readBuffer utils return nil, errors.Wrap(pullErr, "Error pulling for id") } // Count array - id := make([]int8, utils.Max(uint16(2), 0)) + id := make([]int8, max(uint16(2), 0)) // This happens when the size is set conditional to 0 if len(id) == 0 { id = nil } { - _numItems := uint16(utils.Max(uint16(2), 0)) + _numItems := uint16(max(uint16(2), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/knxnetip/readwrite/model/ComObjectTableRealisationType1.go b/plc4go/protocols/knxnetip/readwrite/model/ComObjectTableRealisationType1.go index ed65f2f3226..99253be69f1 100644 --- a/plc4go/protocols/knxnetip/readwrite/model/ComObjectTableRealisationType1.go +++ b/plc4go/protocols/knxnetip/readwrite/model/ComObjectTableRealisationType1.go @@ -187,13 +187,13 @@ func ComObjectTableRealisationType1ParseWithBuffer(ctx context.Context, readBuff return nil, errors.Wrap(pullErr, "Error pulling for comObjectDescriptors") } // Count array - comObjectDescriptors := make([]GroupObjectDescriptorRealisationType1, utils.Max(numEntries, 0)) + comObjectDescriptors := make([]GroupObjectDescriptorRealisationType1, max(numEntries, 0)) // This happens when the size is set conditional to 0 if len(comObjectDescriptors) == 0 { comObjectDescriptors = nil } { - _numItems := uint16(utils.Max(numEntries, 0)) + _numItems := uint16(max(numEntries, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/knxnetip/readwrite/model/ComObjectTableRealisationType2.go b/plc4go/protocols/knxnetip/readwrite/model/ComObjectTableRealisationType2.go index 83c310a8a45..5860874a04e 100644 --- a/plc4go/protocols/knxnetip/readwrite/model/ComObjectTableRealisationType2.go +++ b/plc4go/protocols/knxnetip/readwrite/model/ComObjectTableRealisationType2.go @@ -187,13 +187,13 @@ func ComObjectTableRealisationType2ParseWithBuffer(ctx context.Context, readBuff return nil, errors.Wrap(pullErr, "Error pulling for comObjectDescriptors") } // Count array - comObjectDescriptors := make([]GroupObjectDescriptorRealisationType2, utils.Max(numEntries, 0)) + comObjectDescriptors := make([]GroupObjectDescriptorRealisationType2, max(numEntries, 0)) // This happens when the size is set conditional to 0 if len(comObjectDescriptors) == 0 { comObjectDescriptors = nil } { - _numItems := uint16(utils.Max(numEntries, 0)) + _numItems := uint16(max(numEntries, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/knxnetip/readwrite/model/KnxDatapoint.go b/plc4go/protocols/knxnetip/readwrite/model/KnxDatapoint.go index 48138b5c316..e5a36ea8633 100644 --- a/plc4go/protocols/knxnetip/readwrite/model/KnxDatapoint.go +++ b/plc4go/protocols/knxnetip/readwrite/model/KnxDatapoint.go @@ -4528,6 +4528,20 @@ func KnxDatapointParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffe return nil, errors.Wrap(_err, "Error parsing reserved field") } + // Simple Field (value) + value, _valueErr := readBuffer.ReadUint8("value", 8) + if _valueErr != nil { + return nil, errors.Wrap(_valueErr, "Error parsing 'value' field") + } + _ = value // TODO: temporary till we fix TIME stuff in golang (see above in the template) + readBuffer.CloseContext("KnxDatapoint") + return values.NewPlcUSINT(value), nil + case datapointType == KnxDatapointType_DPT_Converter_Control: // USINT + // Reserved Field (Just skip the bytes) + if _, _err := readBuffer.ReadUint8("reserved", 8); _err != nil { + return nil, errors.Wrap(_err, "Error parsing reserved field") + } + // Simple Field (value) value, _valueErr := readBuffer.ReadUint8("value", 8) if _valueErr != nil { @@ -11442,6 +11456,16 @@ func KnxDatapointSerializeWithWriteBuffer(ctx context.Context, writeBuffer utils return errors.Wrap(_err, "Error serializing reserved field") } + // Simple Field (value) + if _err := writeBuffer.WriteUint8("value", 8, uint8(value.GetUint8())); _err != nil { + return errors.Wrap(_err, "Error serializing 'value' field") + } + case datapointType == KnxDatapointType_DPT_Converter_Control: // USINT + // Reserved Field (Just skip the bytes) + if _err := writeBuffer.WriteUint8("reserved", 8, uint8(uint8(0x00))); _err != nil { + return errors.Wrap(_err, "Error serializing reserved field") + } + // Simple Field (value) if _err := writeBuffer.WriteUint8("value", 8, uint8(value.GetUint8())); _err != nil { return errors.Wrap(_err, "Error serializing 'value' field") diff --git a/plc4go/protocols/knxnetip/readwrite/model/KnxDatapointType.go b/plc4go/protocols/knxnetip/readwrite/model/KnxDatapointType.go index 246512cc994..844c70c703d 100644 --- a/plc4go/protocols/knxnetip/readwrite/model/KnxDatapointType.go +++ b/plc4go/protocols/knxnetip/readwrite/model/KnxDatapointType.go @@ -323,78 +323,79 @@ const ( KnxDatapointType_DPT_LoadTypeSet KnxDatapointType = 276 KnxDatapointType_DPT_LoadTypeDetected KnxDatapointType = 277 KnxDatapointType_DPT_Converter_Test_Control KnxDatapointType = 278 - KnxDatapointType_DPT_SABExcept_Behaviour KnxDatapointType = 279 - KnxDatapointType_DPT_SABBehaviour_Lock_Unlock KnxDatapointType = 280 - KnxDatapointType_DPT_SSSBMode KnxDatapointType = 281 - KnxDatapointType_DPT_BlindsControlMode KnxDatapointType = 282 - KnxDatapointType_DPT_CommMode KnxDatapointType = 283 - KnxDatapointType_DPT_AddInfoTypes KnxDatapointType = 284 - KnxDatapointType_DPT_RF_ModeSelect KnxDatapointType = 285 - KnxDatapointType_DPT_RF_FilterSelect KnxDatapointType = 286 - KnxDatapointType_DPT_StatusGen KnxDatapointType = 287 - KnxDatapointType_DPT_Device_Control KnxDatapointType = 288 - KnxDatapointType_DPT_ForceSign KnxDatapointType = 289 - KnxDatapointType_DPT_ForceSignCool KnxDatapointType = 290 - KnxDatapointType_DPT_StatusRHC KnxDatapointType = 291 - KnxDatapointType_DPT_StatusSDHWC KnxDatapointType = 292 - KnxDatapointType_DPT_FuelTypeSet KnxDatapointType = 293 - KnxDatapointType_DPT_StatusRCC KnxDatapointType = 294 - KnxDatapointType_DPT_StatusAHU KnxDatapointType = 295 - KnxDatapointType_DPT_CombinedStatus_RTSM KnxDatapointType = 296 - KnxDatapointType_DPT_LightActuatorErrorInfo KnxDatapointType = 297 - KnxDatapointType_DPT_RF_ModeInfo KnxDatapointType = 298 - KnxDatapointType_DPT_RF_FilterInfo KnxDatapointType = 299 - KnxDatapointType_DPT_Channel_Activation_8 KnxDatapointType = 300 - KnxDatapointType_DPT_StatusDHWC KnxDatapointType = 301 - KnxDatapointType_DPT_StatusRHCC KnxDatapointType = 302 - KnxDatapointType_DPT_CombinedStatus_HVA KnxDatapointType = 303 - KnxDatapointType_DPT_CombinedStatus_RTC KnxDatapointType = 304 - KnxDatapointType_DPT_Media KnxDatapointType = 305 - KnxDatapointType_DPT_Channel_Activation_16 KnxDatapointType = 306 - KnxDatapointType_DPT_OnOffAction KnxDatapointType = 307 - KnxDatapointType_DPT_Alarm_Reaction KnxDatapointType = 308 - KnxDatapointType_DPT_UpDown_Action KnxDatapointType = 309 - KnxDatapointType_DPT_HVAC_PB_Action KnxDatapointType = 310 - KnxDatapointType_DPT_DoubleNibble KnxDatapointType = 311 - KnxDatapointType_DPT_SceneInfo KnxDatapointType = 312 - KnxDatapointType_DPT_CombinedInfoOnOff KnxDatapointType = 313 - KnxDatapointType_DPT_ActiveEnergy_V64 KnxDatapointType = 314 - KnxDatapointType_DPT_ApparantEnergy_V64 KnxDatapointType = 315 - KnxDatapointType_DPT_ReactiveEnergy_V64 KnxDatapointType = 316 - KnxDatapointType_DPT_Channel_Activation_24 KnxDatapointType = 317 - KnxDatapointType_DPT_HVACModeNext KnxDatapointType = 318 - KnxDatapointType_DPT_DHWModeNext KnxDatapointType = 319 - KnxDatapointType_DPT_OccModeNext KnxDatapointType = 320 - KnxDatapointType_DPT_BuildingModeNext KnxDatapointType = 321 - KnxDatapointType_DPT_StatusLightingActuator KnxDatapointType = 322 - KnxDatapointType_DPT_Version KnxDatapointType = 323 - KnxDatapointType_DPT_AlarmInfo KnxDatapointType = 324 - KnxDatapointType_DPT_TempRoomSetpSetF16_3 KnxDatapointType = 325 - KnxDatapointType_DPT_TempRoomSetpSetShiftF16_3 KnxDatapointType = 326 - KnxDatapointType_DPT_Scaling_Speed KnxDatapointType = 327 - KnxDatapointType_DPT_Scaling_Step_Time KnxDatapointType = 328 - KnxDatapointType_DPT_MeteringValue KnxDatapointType = 329 - KnxDatapointType_DPT_MBus_Address KnxDatapointType = 330 - KnxDatapointType_DPT_Colour_RGB KnxDatapointType = 331 - KnxDatapointType_DPT_LanguageCodeAlpha2_ASCII KnxDatapointType = 332 - KnxDatapointType_DPT_Tariff_ActiveEnergy KnxDatapointType = 333 - KnxDatapointType_DPT_Prioritised_Mode_Control KnxDatapointType = 334 - KnxDatapointType_DPT_DALI_Control_Gear_Diagnostic KnxDatapointType = 335 - KnxDatapointType_DPT_DALI_Diagnostics KnxDatapointType = 336 - KnxDatapointType_DPT_CombinedPosition KnxDatapointType = 337 - KnxDatapointType_DPT_StatusSAB KnxDatapointType = 338 - KnxDatapointType_DPT_Colour_xyY KnxDatapointType = 339 - KnxDatapointType_DPT_Converter_Status KnxDatapointType = 340 - KnxDatapointType_DPT_Converter_Test_Result KnxDatapointType = 341 - KnxDatapointType_DPT_Battery_Info KnxDatapointType = 342 - KnxDatapointType_DPT_Brightness_Colour_Temperature_Transition KnxDatapointType = 343 - KnxDatapointType_DPT_Brightness_Colour_Temperature_Control KnxDatapointType = 344 - KnxDatapointType_DPT_Colour_RGBW KnxDatapointType = 345 - KnxDatapointType_DPT_Relative_Control_RGBW KnxDatapointType = 346 - KnxDatapointType_DPT_Relative_Control_RGB KnxDatapointType = 347 - KnxDatapointType_DPT_GeographicalLocation KnxDatapointType = 348 - KnxDatapointType_DPT_TempRoomSetpSetF16_4 KnxDatapointType = 349 - KnxDatapointType_DPT_TempRoomSetpSetShiftF16_4 KnxDatapointType = 350 + KnxDatapointType_DPT_Converter_Control KnxDatapointType = 279 + KnxDatapointType_DPT_SABExcept_Behaviour KnxDatapointType = 280 + KnxDatapointType_DPT_SABBehaviour_Lock_Unlock KnxDatapointType = 281 + KnxDatapointType_DPT_SSSBMode KnxDatapointType = 282 + KnxDatapointType_DPT_BlindsControlMode KnxDatapointType = 283 + KnxDatapointType_DPT_CommMode KnxDatapointType = 284 + KnxDatapointType_DPT_AddInfoTypes KnxDatapointType = 285 + KnxDatapointType_DPT_RF_ModeSelect KnxDatapointType = 286 + KnxDatapointType_DPT_RF_FilterSelect KnxDatapointType = 287 + KnxDatapointType_DPT_StatusGen KnxDatapointType = 288 + KnxDatapointType_DPT_Device_Control KnxDatapointType = 289 + KnxDatapointType_DPT_ForceSign KnxDatapointType = 290 + KnxDatapointType_DPT_ForceSignCool KnxDatapointType = 291 + KnxDatapointType_DPT_StatusRHC KnxDatapointType = 292 + KnxDatapointType_DPT_StatusSDHWC KnxDatapointType = 293 + KnxDatapointType_DPT_FuelTypeSet KnxDatapointType = 294 + KnxDatapointType_DPT_StatusRCC KnxDatapointType = 295 + KnxDatapointType_DPT_StatusAHU KnxDatapointType = 296 + KnxDatapointType_DPT_CombinedStatus_RTSM KnxDatapointType = 297 + KnxDatapointType_DPT_LightActuatorErrorInfo KnxDatapointType = 298 + KnxDatapointType_DPT_RF_ModeInfo KnxDatapointType = 299 + KnxDatapointType_DPT_RF_FilterInfo KnxDatapointType = 300 + KnxDatapointType_DPT_Channel_Activation_8 KnxDatapointType = 301 + KnxDatapointType_DPT_StatusDHWC KnxDatapointType = 302 + KnxDatapointType_DPT_StatusRHCC KnxDatapointType = 303 + KnxDatapointType_DPT_CombinedStatus_HVA KnxDatapointType = 304 + KnxDatapointType_DPT_CombinedStatus_RTC KnxDatapointType = 305 + KnxDatapointType_DPT_Media KnxDatapointType = 306 + KnxDatapointType_DPT_Channel_Activation_16 KnxDatapointType = 307 + KnxDatapointType_DPT_OnOffAction KnxDatapointType = 308 + KnxDatapointType_DPT_Alarm_Reaction KnxDatapointType = 309 + KnxDatapointType_DPT_UpDown_Action KnxDatapointType = 310 + KnxDatapointType_DPT_HVAC_PB_Action KnxDatapointType = 311 + KnxDatapointType_DPT_DoubleNibble KnxDatapointType = 312 + KnxDatapointType_DPT_SceneInfo KnxDatapointType = 313 + KnxDatapointType_DPT_CombinedInfoOnOff KnxDatapointType = 314 + KnxDatapointType_DPT_ActiveEnergy_V64 KnxDatapointType = 315 + KnxDatapointType_DPT_ApparantEnergy_V64 KnxDatapointType = 316 + KnxDatapointType_DPT_ReactiveEnergy_V64 KnxDatapointType = 317 + KnxDatapointType_DPT_Channel_Activation_24 KnxDatapointType = 318 + KnxDatapointType_DPT_HVACModeNext KnxDatapointType = 319 + KnxDatapointType_DPT_DHWModeNext KnxDatapointType = 320 + KnxDatapointType_DPT_OccModeNext KnxDatapointType = 321 + KnxDatapointType_DPT_BuildingModeNext KnxDatapointType = 322 + KnxDatapointType_DPT_StatusLightingActuator KnxDatapointType = 323 + KnxDatapointType_DPT_Version KnxDatapointType = 324 + KnxDatapointType_DPT_AlarmInfo KnxDatapointType = 325 + KnxDatapointType_DPT_TempRoomSetpSetF16_3 KnxDatapointType = 326 + KnxDatapointType_DPT_TempRoomSetpSetShiftF16_3 KnxDatapointType = 327 + KnxDatapointType_DPT_Scaling_Speed KnxDatapointType = 328 + KnxDatapointType_DPT_Scaling_Step_Time KnxDatapointType = 329 + KnxDatapointType_DPT_MeteringValue KnxDatapointType = 330 + KnxDatapointType_DPT_MBus_Address KnxDatapointType = 331 + KnxDatapointType_DPT_Colour_RGB KnxDatapointType = 332 + KnxDatapointType_DPT_LanguageCodeAlpha2_ASCII KnxDatapointType = 333 + KnxDatapointType_DPT_Tariff_ActiveEnergy KnxDatapointType = 334 + KnxDatapointType_DPT_Prioritised_Mode_Control KnxDatapointType = 335 + KnxDatapointType_DPT_DALI_Control_Gear_Diagnostic KnxDatapointType = 336 + KnxDatapointType_DPT_DALI_Diagnostics KnxDatapointType = 337 + KnxDatapointType_DPT_CombinedPosition KnxDatapointType = 338 + KnxDatapointType_DPT_StatusSAB KnxDatapointType = 339 + KnxDatapointType_DPT_Colour_xyY KnxDatapointType = 340 + KnxDatapointType_DPT_Converter_Status KnxDatapointType = 341 + KnxDatapointType_DPT_Converter_Test_Result KnxDatapointType = 342 + KnxDatapointType_DPT_Battery_Info KnxDatapointType = 343 + KnxDatapointType_DPT_Brightness_Colour_Temperature_Transition KnxDatapointType = 344 + KnxDatapointType_DPT_Brightness_Colour_Temperature_Control KnxDatapointType = 345 + KnxDatapointType_DPT_Colour_RGBW KnxDatapointType = 346 + KnxDatapointType_DPT_Relative_Control_RGBW KnxDatapointType = 347 + KnxDatapointType_DPT_Relative_Control_RGB KnxDatapointType = 348 + KnxDatapointType_DPT_GeographicalLocation KnxDatapointType = 349 + KnxDatapointType_DPT_TempRoomSetpSetF16_4 KnxDatapointType = 350 + KnxDatapointType_DPT_TempRoomSetpSetShiftF16_4 KnxDatapointType = 351 ) var KnxDatapointTypeValues []KnxDatapointType @@ -681,6 +682,7 @@ func init() { KnxDatapointType_DPT_LoadTypeSet, KnxDatapointType_DPT_LoadTypeDetected, KnxDatapointType_DPT_Converter_Test_Control, + KnxDatapointType_DPT_Converter_Control, KnxDatapointType_DPT_SABExcept_Behaviour, KnxDatapointType_DPT_SABBehaviour_Lock_Unlock, KnxDatapointType_DPT_SSSBMode, @@ -1560,7 +1562,7 @@ func (e KnxDatapointType) Number() uint16 { } case 279: { /* '279' */ - return 801 + return 612 } case 28: { /* '28' */ @@ -1568,43 +1570,43 @@ func (e KnxDatapointType) Number() uint16 { } case 280: { /* '280' */ - return 802 + return 801 } case 281: { /* '281' */ - return 803 + return 802 } case 282: { /* '282' */ - return 804 + return 803 } case 283: { /* '283' */ - return 1000 + return 804 } case 284: { /* '284' */ - return 1001 + return 1000 } case 285: { /* '285' */ - return 1002 + return 1001 } case 286: { /* '286' */ - return 1003 + return 1002 } case 287: { /* '287' */ - return 1 + return 1003 } case 288: { /* '288' */ - return 2 + return 1 } case 289: { /* '289' */ - return 100 + return 2 } case 29: { /* '29' */ @@ -1612,43 +1614,43 @@ func (e KnxDatapointType) Number() uint16 { } case 290: { /* '290' */ - return 101 + return 100 } case 291: { /* '291' */ - return 102 + return 101 } case 292: { /* '292' */ - return 103 + return 102 } case 293: { /* '293' */ - return 104 + return 103 } case 294: { /* '294' */ - return 105 + return 104 } case 295: { /* '295' */ - return 106 + return 105 } case 296: { /* '296' */ - return 107 + return 106 } case 297: { /* '297' */ - return 601 + return 107 } case 298: { /* '298' */ - return 1000 + return 601 } case 299: { /* '299' */ - return 1001 + return 1000 } case 3: { /* '3' */ @@ -1660,43 +1662,43 @@ func (e KnxDatapointType) Number() uint16 { } case 300: { /* '300' */ - return 1010 + return 1001 } case 301: { /* '301' */ - return 100 + return 1010 } case 302: { /* '302' */ - return 101 + return 100 } case 303: { /* '303' */ - return 102 + return 101 } case 304: { /* '304' */ - return 103 + return 102 } case 305: { /* '305' */ - return 1000 + return 103 } case 306: { /* '306' */ - return 1010 + return 1000 } case 307: { /* '307' */ - return 1 + return 1010 } case 308: { /* '308' */ - return 2 + return 1 } case 309: { /* '309' */ - return 3 + return 2 } case 31: { /* '31' */ @@ -1704,15 +1706,15 @@ func (e KnxDatapointType) Number() uint16 { } case 310: { /* '310' */ - return 102 + return 3 } case 311: { /* '311' */ - return 1000 + return 102 } case 312: { /* '312' */ - return 1 + return 1000 } case 313: { /* '313' */ @@ -1720,27 +1722,27 @@ func (e KnxDatapointType) Number() uint16 { } case 314: { /* '314' */ - return 10 + return 1 } case 315: { /* '315' */ - return 11 + return 10 } case 316: { /* '316' */ - return 12 + return 11 } case 317: { /* '317' */ - return 1010 + return 12 } case 318: { /* '318' */ - return 100 + return 1010 } case 319: { /* '319' */ - return 102 + return 100 } case 32: { /* '32' */ @@ -1748,19 +1750,19 @@ func (e KnxDatapointType) Number() uint16 { } case 320: { /* '320' */ - return 104 + return 102 } case 321: { /* '321' */ - return 105 + return 104 } case 322: { /* '322' */ - return 600 + return 105 } case 323: { /* '323' */ - return 1 + return 600 } case 324: { /* '324' */ @@ -1768,23 +1770,23 @@ func (e KnxDatapointType) Number() uint16 { } case 325: { /* '325' */ - return 100 + return 1 } case 326: { /* '326' */ - return 101 + return 100 } case 327: { /* '327' */ - return 1 + return 101 } case 328: { /* '328' */ - return 2 + return 1 } case 329: { /* '329' */ - return 1 + return 2 } case 33: { /* '33' */ @@ -1792,15 +1794,15 @@ func (e KnxDatapointType) Number() uint16 { } case 330: { /* '330' */ - return 1000 + return 1 } case 331: { /* '331' */ - return 600 + return 1000 } case 332: { /* '332' */ - return 1 + return 600 } case 333: { /* '333' */ @@ -1812,7 +1814,7 @@ func (e KnxDatapointType) Number() uint16 { } case 335: { /* '335' */ - return 600 + return 1 } case 336: { /* '336' */ @@ -1820,7 +1822,7 @@ func (e KnxDatapointType) Number() uint16 { } case 337: { /* '337' */ - return 800 + return 600 } case 338: { /* '338' */ @@ -1828,7 +1830,7 @@ func (e KnxDatapointType) Number() uint16 { } case 339: { /* '339' */ - return 600 + return 800 } case 34: { /* '34' */ @@ -1868,11 +1870,11 @@ func (e KnxDatapointType) Number() uint16 { } case 348: { /* '348' */ - return 1 + return 600 } case 349: { /* '349' */ - return 100 + return 1 } case 35: { /* '35' */ @@ -1880,6 +1882,10 @@ func (e KnxDatapointType) Number() uint16 { } case 350: { /* '350' */ + return 100 + } + case 351: + { /* '351' */ return 101 } case 36: @@ -2982,7 +2988,7 @@ func (e KnxDatapointType) Name() string { } case 279: { /* '279' */ - return "SAB except behavior" + return "converter control" } case 28: { /* '28' */ @@ -2990,43 +2996,43 @@ func (e KnxDatapointType) Name() string { } case 280: { /* '280' */ - return "SAB behavior on lock/unlock" + return "SAB except behavior" } case 281: { /* '281' */ - return "SSSB mode" + return "SAB behavior on lock/unlock" } case 282: { /* '282' */ - return "blinds control mode" + return "SSSB mode" } case 283: { /* '283' */ - return "communication mode" + return "blinds control mode" } case 284: { /* '284' */ - return "additional information type" + return "communication mode" } case 285: { /* '285' */ - return "RF mode selection" + return "additional information type" } case 286: { /* '286' */ - return "RF filter mode selection" + return "RF mode selection" } case 287: { /* '287' */ - return "general status" + return "RF filter mode selection" } case 288: { /* '288' */ - return "device control" + return "general status" } case 289: { /* '289' */ - return "forcing signal" + return "device control" } case 29: { /* '29' */ @@ -3034,43 +3040,43 @@ func (e KnxDatapointType) Name() string { } case 290: { /* '290' */ - return "forcing signal cool" + return "forcing signal" } case 291: { /* '291' */ - return "room heating controller status" + return "forcing signal cool" } case 292: { /* '292' */ - return "solar DHW controller status" + return "room heating controller status" } case 293: { /* '293' */ - return "fuel type set" + return "solar DHW controller status" } case 294: { /* '294' */ - return "room cooling controller status" + return "fuel type set" } case 295: { /* '295' */ - return "ventilation controller status" + return "room cooling controller status" } case 296: { /* '296' */ - return "combined status RTSM" + return "ventilation controller status" } case 297: { /* '297' */ - return "lighting actuator error information" + return "combined status RTSM" } case 298: { /* '298' */ - return "RF communication mode info" + return "lighting actuator error information" } case 299: { /* '299' */ - return "cEMI server supported RF filtering modes" + return "RF communication mode info" } case 3: { /* '3' */ @@ -3082,43 +3088,43 @@ func (e KnxDatapointType) Name() string { } case 300: { /* '300' */ - return "channel activation for 8 channels" + return "cEMI server supported RF filtering modes" } case 301: { /* '301' */ - return "DHW controller status" + return "channel activation for 8 channels" } case 302: { /* '302' */ - return "RHCC status" + return "DHW controller status" } case 303: { /* '303' */ - return "combined status HVA" + return "RHCC status" } case 304: { /* '304' */ - return "combined status RTC" + return "combined status HVA" } case 305: { /* '305' */ - return "media" + return "combined status RTC" } case 306: { /* '306' */ - return "channel activation for 16 channels" + return "media" } case 307: { /* '307' */ - return "on/off action" + return "channel activation for 16 channels" } case 308: { /* '308' */ - return "alarm reaction" + return "on/off action" } case 309: { /* '309' */ - return "up/down action" + return "alarm reaction" } case 31: { /* '31' */ @@ -3126,43 +3132,43 @@ func (e KnxDatapointType) Name() string { } case 310: { /* '310' */ - return "HVAC push button action" + return "up/down action" } case 311: { /* '311' */ - return "busy/nak repetitions" + return "HVAC push button action" } case 312: { /* '312' */ - return "scene information" + return "busy/nak repetitions" } case 313: { /* '313' */ - return "bit-combined info on/off" + return "scene information" } case 314: { /* '314' */ - return "active energy (Wh)" + return "bit-combined info on/off" } case 315: { /* '315' */ - return "apparant energy (VAh)" + return "active energy (Wh)" } case 316: { /* '316' */ - return "reactive energy (VARh)" + return "apparant energy (VAh)" } case 317: { /* '317' */ - return "activation state 0..23" + return "reactive energy (VARh)" } case 318: { /* '318' */ - return "time delay & HVAC mode" + return "activation state 0..23" } case 319: { /* '319' */ - return "time delay & DHW mode" + return "time delay & HVAC mode" } case 32: { /* '32' */ @@ -3170,43 +3176,43 @@ func (e KnxDatapointType) Name() string { } case 320: { /* '320' */ - return "time delay & occupancy mode" + return "time delay & DHW mode" } case 321: { /* '321' */ - return "time delay & building mode" + return "time delay & occupancy mode" } case 322: { /* '322' */ - return "Status Lighting Actuator" + return "time delay & building mode" } case 323: { /* '323' */ - return "DPT version" + return "Status Lighting Actuator" } case 324: { /* '324' */ - return "alarm info" + return "DPT version" } case 325: { /* '325' */ - return "room temperature setpoint" + return "alarm info" } case 326: { /* '326' */ - return "room temperature setpoint shift" + return "room temperature setpoint" } case 327: { /* '327' */ - return "scaling speed" + return "room temperature setpoint shift" } case 328: { /* '328' */ - return "scaling step time" + return "scaling speed" } case 329: { /* '329' */ - return "metering value (value,encoding,cmd)" + return "scaling step time" } case 33: { /* '33' */ @@ -3214,27 +3220,27 @@ func (e KnxDatapointType) Name() string { } case 330: { /* '330' */ - return "MBus address" + return "metering value (value,encoding,cmd)" } case 331: { /* '331' */ - return "RGB value 3x(0..255)" + return "MBus address" } case 332: { /* '332' */ - return "language code (ASCII)" + return "RGB value 3x(0..255)" } case 333: { /* '333' */ - return "electrical energy with tariff" + return "language code (ASCII)" } case 334: { /* '334' */ - return "priority control" + return "electrical energy with tariff" } case 335: { /* '335' */ - return "diagnostic value" + return "priority control" } case 336: { /* '336' */ @@ -3242,15 +3248,15 @@ func (e KnxDatapointType) Name() string { } case 337: { /* '337' */ - return "combined position" + return "diagnostic value" } case 338: { /* '338' */ - return "status sunblind & shutter actuator" + return "combined position" } case 339: { /* '339' */ - return "colour xyY" + return "status sunblind & shutter actuator" } case 34: { /* '34' */ @@ -3258,43 +3264,43 @@ func (e KnxDatapointType) Name() string { } case 340: { /* '340' */ - return "DALI converter status" + return "colour xyY" } case 341: { /* '341' */ - return "DALI converter test result" + return "DALI converter status" } case 342: { /* '342' */ - return "Battery Information" + return "DALI converter test result" } case 343: { /* '343' */ - return "brightness colour temperature transition" + return "Battery Information" } case 344: { /* '344' */ - return "brightness colour temperature control" + return "brightness colour temperature transition" } case 345: { /* '345' */ - return "RGBW value 4x(0..100%)" + return "brightness colour temperature control" } case 346: { /* '346' */ - return "RGBW relative control" + return "RGBW value 4x(0..100%)" } case 347: { /* '347' */ - return "RGB relative control" + return "RGBW relative control" } case 348: { /* '348' */ - return "geographical location (longitude and latitude) expressed in degrees" + return "RGB relative control" } case 349: { /* '349' */ - return "Temperature setpoint setting for 4 HVAC Modes" + return "geographical location (longitude and latitude) expressed in degrees" } case 35: { /* '35' */ @@ -3302,6 +3308,10 @@ func (e KnxDatapointType) Name() string { } case 350: { /* '350' */ + return "Temperature setpoint setting for 4 HVAC Modes" + } + case 351: + { /* '351' */ return "Temperature setpoint shift setting for 4 HVAC Modes" } case 36: @@ -4440,7 +4450,7 @@ func (e KnxDatapointType) DatapointMainType() KnxDatapointMainType { } case 287: { /* '287' */ - return KnxDatapointMainType_DPT_8_BIT_SET + return KnxDatapointMainType_DPT_1_BYTE } case 288: { /* '288' */ @@ -4508,7 +4518,7 @@ func (e KnxDatapointType) DatapointMainType() KnxDatapointMainType { } case 301: { /* '301' */ - return KnxDatapointMainType_DPT_16_BIT_SET + return KnxDatapointMainType_DPT_8_BIT_SET } case 302: { /* '302' */ @@ -4532,7 +4542,7 @@ func (e KnxDatapointType) DatapointMainType() KnxDatapointMainType { } case 307: { /* '307' */ - return KnxDatapointMainType_DPT_2_BIT_SET + return KnxDatapointMainType_DPT_16_BIT_SET } case 308: { /* '308' */ @@ -4552,19 +4562,19 @@ func (e KnxDatapointType) DatapointMainType() KnxDatapointMainType { } case 311: { /* '311' */ - return KnxDatapointMainType_DPT_2_NIBBLE_SET + return KnxDatapointMainType_DPT_2_BIT_SET } case 312: { /* '312' */ - return KnxDatapointMainType_DPT_8_BIT_SET_2 + return KnxDatapointMainType_DPT_2_NIBBLE_SET } case 313: { /* '313' */ - return KnxDatapointMainType_DPT_32_BIT_SET + return KnxDatapointMainType_DPT_8_BIT_SET_2 } case 314: { /* '314' */ - return KnxDatapointMainType_DPT_ELECTRICAL_ENERGY + return KnxDatapointMainType_DPT_32_BIT_SET } case 315: { /* '315' */ @@ -4576,11 +4586,11 @@ func (e KnxDatapointType) DatapointMainType() KnxDatapointMainType { } case 317: { /* '317' */ - return KnxDatapointMainType_DPT_24_TIMES_CHANNEL_ACTIVATION + return KnxDatapointMainType_DPT_ELECTRICAL_ENERGY } case 318: { /* '318' */ - return KnxDatapointMainType_DPT_16_BIT_UNSIGNED_VALUE_AND_8_BIT_ENUM + return KnxDatapointMainType_DPT_24_TIMES_CHANNEL_ACTIVATION } case 319: { /* '319' */ @@ -4600,19 +4610,19 @@ func (e KnxDatapointType) DatapointMainType() KnxDatapointMainType { } case 322: { /* '322' */ - return KnxDatapointMainType_DPT_8_BIT_UNSIGNED_VALUE_AND_8_BIT_ENUM + return KnxDatapointMainType_DPT_16_BIT_UNSIGNED_VALUE_AND_8_BIT_ENUM } case 323: { /* '323' */ - return KnxDatapointMainType_DPT_DATAPOINT_TYPE_VERSION + return KnxDatapointMainType_DPT_8_BIT_UNSIGNED_VALUE_AND_8_BIT_ENUM } case 324: { /* '324' */ - return KnxDatapointMainType_DPT_ALARM_INFO + return KnxDatapointMainType_DPT_DATAPOINT_TYPE_VERSION } case 325: { /* '325' */ - return KnxDatapointMainType_DPT_3X_2_BYTE_FLOAT_VALUE + return KnxDatapointMainType_DPT_ALARM_INFO } case 326: { /* '326' */ @@ -4620,7 +4630,7 @@ func (e KnxDatapointType) DatapointMainType() KnxDatapointMainType { } case 327: { /* '327' */ - return KnxDatapointMainType_DPT_SCALING_SPEED + return KnxDatapointMainType_DPT_3X_2_BYTE_FLOAT_VALUE } case 328: { /* '328' */ @@ -4628,7 +4638,7 @@ func (e KnxDatapointType) DatapointMainType() KnxDatapointMainType { } case 329: { /* '329' */ - return KnxDatapointMainType_DPT_4_1_1_BYTE_COMBINED_INFORMATION + return KnxDatapointMainType_DPT_SCALING_SPEED } case 33: { /* '33' */ @@ -4636,43 +4646,43 @@ func (e KnxDatapointType) DatapointMainType() KnxDatapointMainType { } case 330: { /* '330' */ - return KnxDatapointMainType_DPT_MBUS_ADDRESS + return KnxDatapointMainType_DPT_4_1_1_BYTE_COMBINED_INFORMATION } case 331: { /* '331' */ - return KnxDatapointMainType_DPT_3_BYTE_COLOUR_RGB + return KnxDatapointMainType_DPT_MBUS_ADDRESS } case 332: { /* '332' */ - return KnxDatapointMainType_DPT_LANGUAGE_CODE_ISO_639_1 + return KnxDatapointMainType_DPT_3_BYTE_COLOUR_RGB } case 333: { /* '333' */ - return KnxDatapointMainType_DPT_SIGNED_VALUE_WITH_CLASSIFICATION_AND_VALIDITY + return KnxDatapointMainType_DPT_LANGUAGE_CODE_ISO_639_1 } case 334: { /* '334' */ - return KnxDatapointMainType_DPT_PRIORITISED_MODE_CONTROL + return KnxDatapointMainType_DPT_SIGNED_VALUE_WITH_CLASSIFICATION_AND_VALIDITY } case 335: { /* '335' */ - return KnxDatapointMainType_DPT_CONFIGURATION_DIAGNOSTICS_16_BIT + return KnxDatapointMainType_DPT_PRIORITISED_MODE_CONTROL } case 336: { /* '336' */ - return KnxDatapointMainType_DPT_CONFIGURATION_DIAGNOSTICS_8_BIT + return KnxDatapointMainType_DPT_CONFIGURATION_DIAGNOSTICS_16_BIT } case 337: { /* '337' */ - return KnxDatapointMainType_DPT_POSITIONS + return KnxDatapointMainType_DPT_CONFIGURATION_DIAGNOSTICS_8_BIT } case 338: { /* '338' */ - return KnxDatapointMainType_DPT_STATUS_32_BIT + return KnxDatapointMainType_DPT_POSITIONS } case 339: { /* '339' */ - return KnxDatapointMainType_DPT_STATUS_48_BIT + return KnxDatapointMainType_DPT_STATUS_32_BIT } case 34: { /* '34' */ @@ -4680,43 +4690,43 @@ func (e KnxDatapointType) DatapointMainType() KnxDatapointMainType { } case 340: { /* '340' */ - return KnxDatapointMainType_DPT_CONVERTER_STATUS + return KnxDatapointMainType_DPT_STATUS_48_BIT } case 341: { /* '341' */ - return KnxDatapointMainType_DPT_CONVERTER_TEST_RESULT + return KnxDatapointMainType_DPT_CONVERTER_STATUS } case 342: { /* '342' */ - return KnxDatapointMainType_DPT_BATTERY_INFORMATION + return KnxDatapointMainType_DPT_CONVERTER_TEST_RESULT } case 343: { /* '343' */ - return KnxDatapointMainType_DPT_BRIGHTNESS_COLOUR_TEMPERATURE_TRANSITION + return KnxDatapointMainType_DPT_BATTERY_INFORMATION } case 344: { /* '344' */ - return KnxDatapointMainType_DPT_STATUS_24_BIT + return KnxDatapointMainType_DPT_BRIGHTNESS_COLOUR_TEMPERATURE_TRANSITION } case 345: { /* '345' */ - return KnxDatapointMainType_DPT_COLOUR_RGBW + return KnxDatapointMainType_DPT_STATUS_24_BIT } case 346: { /* '346' */ - return KnxDatapointMainType_DPT_RELATIVE_CONTROL_RGBW + return KnxDatapointMainType_DPT_COLOUR_RGBW } case 347: { /* '347' */ - return KnxDatapointMainType_DPT_RELATIVE_CONTROL_RGB + return KnxDatapointMainType_DPT_RELATIVE_CONTROL_RGBW } case 348: { /* '348' */ - return KnxDatapointMainType_DPT_F32F32 + return KnxDatapointMainType_DPT_RELATIVE_CONTROL_RGB } case 349: { /* '349' */ - return KnxDatapointMainType_DPT_F16F16F16F16 + return KnxDatapointMainType_DPT_F32F32 } case 35: { /* '35' */ @@ -4726,6 +4736,10 @@ func (e KnxDatapointType) DatapointMainType() KnxDatapointMainType { { /* '350' */ return KnxDatapointMainType_DPT_F16F16F16F16 } + case 351: + { /* '351' */ + return KnxDatapointMainType_DPT_F16F16F16F16 + } case 36: { /* '36' */ return KnxDatapointMainType_DPT_1_BIT @@ -5424,166 +5438,168 @@ func KnxDatapointTypeByValue(value uint32) (enum KnxDatapointType, ok bool) { case 278: return KnxDatapointType_DPT_Converter_Test_Control, true case 279: - return KnxDatapointType_DPT_SABExcept_Behaviour, true + return KnxDatapointType_DPT_Converter_Control, true case 28: return KnxDatapointType_DPT_Bool, true case 280: - return KnxDatapointType_DPT_SABBehaviour_Lock_Unlock, true + return KnxDatapointType_DPT_SABExcept_Behaviour, true case 281: - return KnxDatapointType_DPT_SSSBMode, true + return KnxDatapointType_DPT_SABBehaviour_Lock_Unlock, true case 282: - return KnxDatapointType_DPT_BlindsControlMode, true + return KnxDatapointType_DPT_SSSBMode, true case 283: - return KnxDatapointType_DPT_CommMode, true + return KnxDatapointType_DPT_BlindsControlMode, true case 284: - return KnxDatapointType_DPT_AddInfoTypes, true + return KnxDatapointType_DPT_CommMode, true case 285: - return KnxDatapointType_DPT_RF_ModeSelect, true + return KnxDatapointType_DPT_AddInfoTypes, true case 286: - return KnxDatapointType_DPT_RF_FilterSelect, true + return KnxDatapointType_DPT_RF_ModeSelect, true case 287: - return KnxDatapointType_DPT_StatusGen, true + return KnxDatapointType_DPT_RF_FilterSelect, true case 288: - return KnxDatapointType_DPT_Device_Control, true + return KnxDatapointType_DPT_StatusGen, true case 289: - return KnxDatapointType_DPT_ForceSign, true + return KnxDatapointType_DPT_Device_Control, true case 29: return KnxDatapointType_DPT_Enable, true case 290: - return KnxDatapointType_DPT_ForceSignCool, true + return KnxDatapointType_DPT_ForceSign, true case 291: - return KnxDatapointType_DPT_StatusRHC, true + return KnxDatapointType_DPT_ForceSignCool, true case 292: - return KnxDatapointType_DPT_StatusSDHWC, true + return KnxDatapointType_DPT_StatusRHC, true case 293: - return KnxDatapointType_DPT_FuelTypeSet, true + return KnxDatapointType_DPT_StatusSDHWC, true case 294: - return KnxDatapointType_DPT_StatusRCC, true + return KnxDatapointType_DPT_FuelTypeSet, true case 295: - return KnxDatapointType_DPT_StatusAHU, true + return KnxDatapointType_DPT_StatusRCC, true case 296: - return KnxDatapointType_DPT_CombinedStatus_RTSM, true + return KnxDatapointType_DPT_StatusAHU, true case 297: - return KnxDatapointType_DPT_LightActuatorErrorInfo, true + return KnxDatapointType_DPT_CombinedStatus_RTSM, true case 298: - return KnxDatapointType_DPT_RF_ModeInfo, true + return KnxDatapointType_DPT_LightActuatorErrorInfo, true case 299: - return KnxDatapointType_DPT_RF_FilterInfo, true + return KnxDatapointType_DPT_RF_ModeInfo, true case 3: return KnxDatapointType_WORD, true case 30: return KnxDatapointType_DPT_Ramp, true case 300: - return KnxDatapointType_DPT_Channel_Activation_8, true + return KnxDatapointType_DPT_RF_FilterInfo, true case 301: - return KnxDatapointType_DPT_StatusDHWC, true + return KnxDatapointType_DPT_Channel_Activation_8, true case 302: - return KnxDatapointType_DPT_StatusRHCC, true + return KnxDatapointType_DPT_StatusDHWC, true case 303: - return KnxDatapointType_DPT_CombinedStatus_HVA, true + return KnxDatapointType_DPT_StatusRHCC, true case 304: - return KnxDatapointType_DPT_CombinedStatus_RTC, true + return KnxDatapointType_DPT_CombinedStatus_HVA, true case 305: - return KnxDatapointType_DPT_Media, true + return KnxDatapointType_DPT_CombinedStatus_RTC, true case 306: - return KnxDatapointType_DPT_Channel_Activation_16, true + return KnxDatapointType_DPT_Media, true case 307: - return KnxDatapointType_DPT_OnOffAction, true + return KnxDatapointType_DPT_Channel_Activation_16, true case 308: - return KnxDatapointType_DPT_Alarm_Reaction, true + return KnxDatapointType_DPT_OnOffAction, true case 309: - return KnxDatapointType_DPT_UpDown_Action, true + return KnxDatapointType_DPT_Alarm_Reaction, true case 31: return KnxDatapointType_DPT_Alarm, true case 310: - return KnxDatapointType_DPT_HVAC_PB_Action, true + return KnxDatapointType_DPT_UpDown_Action, true case 311: - return KnxDatapointType_DPT_DoubleNibble, true + return KnxDatapointType_DPT_HVAC_PB_Action, true case 312: - return KnxDatapointType_DPT_SceneInfo, true + return KnxDatapointType_DPT_DoubleNibble, true case 313: - return KnxDatapointType_DPT_CombinedInfoOnOff, true + return KnxDatapointType_DPT_SceneInfo, true case 314: - return KnxDatapointType_DPT_ActiveEnergy_V64, true + return KnxDatapointType_DPT_CombinedInfoOnOff, true case 315: - return KnxDatapointType_DPT_ApparantEnergy_V64, true + return KnxDatapointType_DPT_ActiveEnergy_V64, true case 316: - return KnxDatapointType_DPT_ReactiveEnergy_V64, true + return KnxDatapointType_DPT_ApparantEnergy_V64, true case 317: - return KnxDatapointType_DPT_Channel_Activation_24, true + return KnxDatapointType_DPT_ReactiveEnergy_V64, true case 318: - return KnxDatapointType_DPT_HVACModeNext, true + return KnxDatapointType_DPT_Channel_Activation_24, true case 319: - return KnxDatapointType_DPT_DHWModeNext, true + return KnxDatapointType_DPT_HVACModeNext, true case 32: return KnxDatapointType_DPT_BinaryValue, true case 320: - return KnxDatapointType_DPT_OccModeNext, true + return KnxDatapointType_DPT_DHWModeNext, true case 321: - return KnxDatapointType_DPT_BuildingModeNext, true + return KnxDatapointType_DPT_OccModeNext, true case 322: - return KnxDatapointType_DPT_StatusLightingActuator, true + return KnxDatapointType_DPT_BuildingModeNext, true case 323: - return KnxDatapointType_DPT_Version, true + return KnxDatapointType_DPT_StatusLightingActuator, true case 324: - return KnxDatapointType_DPT_AlarmInfo, true + return KnxDatapointType_DPT_Version, true case 325: - return KnxDatapointType_DPT_TempRoomSetpSetF16_3, true + return KnxDatapointType_DPT_AlarmInfo, true case 326: - return KnxDatapointType_DPT_TempRoomSetpSetShiftF16_3, true + return KnxDatapointType_DPT_TempRoomSetpSetF16_3, true case 327: - return KnxDatapointType_DPT_Scaling_Speed, true + return KnxDatapointType_DPT_TempRoomSetpSetShiftF16_3, true case 328: - return KnxDatapointType_DPT_Scaling_Step_Time, true + return KnxDatapointType_DPT_Scaling_Speed, true case 329: - return KnxDatapointType_DPT_MeteringValue, true + return KnxDatapointType_DPT_Scaling_Step_Time, true case 33: return KnxDatapointType_DPT_Step, true case 330: - return KnxDatapointType_DPT_MBus_Address, true + return KnxDatapointType_DPT_MeteringValue, true case 331: - return KnxDatapointType_DPT_Colour_RGB, true + return KnxDatapointType_DPT_MBus_Address, true case 332: - return KnxDatapointType_DPT_LanguageCodeAlpha2_ASCII, true + return KnxDatapointType_DPT_Colour_RGB, true case 333: - return KnxDatapointType_DPT_Tariff_ActiveEnergy, true + return KnxDatapointType_DPT_LanguageCodeAlpha2_ASCII, true case 334: - return KnxDatapointType_DPT_Prioritised_Mode_Control, true + return KnxDatapointType_DPT_Tariff_ActiveEnergy, true case 335: - return KnxDatapointType_DPT_DALI_Control_Gear_Diagnostic, true + return KnxDatapointType_DPT_Prioritised_Mode_Control, true case 336: - return KnxDatapointType_DPT_DALI_Diagnostics, true + return KnxDatapointType_DPT_DALI_Control_Gear_Diagnostic, true case 337: - return KnxDatapointType_DPT_CombinedPosition, true + return KnxDatapointType_DPT_DALI_Diagnostics, true case 338: - return KnxDatapointType_DPT_StatusSAB, true + return KnxDatapointType_DPT_CombinedPosition, true case 339: - return KnxDatapointType_DPT_Colour_xyY, true + return KnxDatapointType_DPT_StatusSAB, true case 34: return KnxDatapointType_DPT_UpDown, true case 340: - return KnxDatapointType_DPT_Converter_Status, true + return KnxDatapointType_DPT_Colour_xyY, true case 341: - return KnxDatapointType_DPT_Converter_Test_Result, true + return KnxDatapointType_DPT_Converter_Status, true case 342: - return KnxDatapointType_DPT_Battery_Info, true + return KnxDatapointType_DPT_Converter_Test_Result, true case 343: - return KnxDatapointType_DPT_Brightness_Colour_Temperature_Transition, true + return KnxDatapointType_DPT_Battery_Info, true case 344: - return KnxDatapointType_DPT_Brightness_Colour_Temperature_Control, true + return KnxDatapointType_DPT_Brightness_Colour_Temperature_Transition, true case 345: - return KnxDatapointType_DPT_Colour_RGBW, true + return KnxDatapointType_DPT_Brightness_Colour_Temperature_Control, true case 346: - return KnxDatapointType_DPT_Relative_Control_RGBW, true + return KnxDatapointType_DPT_Colour_RGBW, true case 347: - return KnxDatapointType_DPT_Relative_Control_RGB, true + return KnxDatapointType_DPT_Relative_Control_RGBW, true case 348: - return KnxDatapointType_DPT_GeographicalLocation, true + return KnxDatapointType_DPT_Relative_Control_RGB, true case 349: - return KnxDatapointType_DPT_TempRoomSetpSetF16_4, true + return KnxDatapointType_DPT_GeographicalLocation, true case 35: return KnxDatapointType_DPT_OpenClose, true case 350: + return KnxDatapointType_DPT_TempRoomSetpSetF16_4, true + case 351: return KnxDatapointType_DPT_TempRoomSetpSetShiftF16_4, true case 36: return KnxDatapointType_DPT_Start, true @@ -6131,10 +6147,12 @@ func KnxDatapointTypeByName(value string) (enum KnxDatapointType, ok bool) { return KnxDatapointType_DPT_LoadTypeDetected, true case "DPT_Converter_Test_Control": return KnxDatapointType_DPT_Converter_Test_Control, true - case "DPT_SABExcept_Behaviour": - return KnxDatapointType_DPT_SABExcept_Behaviour, true + case "DPT_Converter_Control": + return KnxDatapointType_DPT_Converter_Control, true case "DPT_Bool": return KnxDatapointType_DPT_Bool, true + case "DPT_SABExcept_Behaviour": + return KnxDatapointType_DPT_SABExcept_Behaviour, true case "DPT_SABBehaviour_Lock_Unlock": return KnxDatapointType_DPT_SABBehaviour_Lock_Unlock, true case "DPT_SSSBMode": @@ -6153,10 +6171,10 @@ func KnxDatapointTypeByName(value string) (enum KnxDatapointType, ok bool) { return KnxDatapointType_DPT_StatusGen, true case "DPT_Device_Control": return KnxDatapointType_DPT_Device_Control, true - case "DPT_ForceSign": - return KnxDatapointType_DPT_ForceSign, true case "DPT_Enable": return KnxDatapointType_DPT_Enable, true + case "DPT_ForceSign": + return KnxDatapointType_DPT_ForceSign, true case "DPT_ForceSignCool": return KnxDatapointType_DPT_ForceSignCool, true case "DPT_StatusRHC": @@ -6175,12 +6193,12 @@ func KnxDatapointTypeByName(value string) (enum KnxDatapointType, ok bool) { return KnxDatapointType_DPT_LightActuatorErrorInfo, true case "DPT_RF_ModeInfo": return KnxDatapointType_DPT_RF_ModeInfo, true - case "DPT_RF_FilterInfo": - return KnxDatapointType_DPT_RF_FilterInfo, true case "WORD": return KnxDatapointType_WORD, true case "DPT_Ramp": return KnxDatapointType_DPT_Ramp, true + case "DPT_RF_FilterInfo": + return KnxDatapointType_DPT_RF_FilterInfo, true case "DPT_Channel_Activation_8": return KnxDatapointType_DPT_Channel_Activation_8, true case "DPT_StatusDHWC": @@ -6199,10 +6217,10 @@ func KnxDatapointTypeByName(value string) (enum KnxDatapointType, ok bool) { return KnxDatapointType_DPT_OnOffAction, true case "DPT_Alarm_Reaction": return KnxDatapointType_DPT_Alarm_Reaction, true - case "DPT_UpDown_Action": - return KnxDatapointType_DPT_UpDown_Action, true case "DPT_Alarm": return KnxDatapointType_DPT_Alarm, true + case "DPT_UpDown_Action": + return KnxDatapointType_DPT_UpDown_Action, true case "DPT_HVAC_PB_Action": return KnxDatapointType_DPT_HVAC_PB_Action, true case "DPT_DoubleNibble": @@ -6221,10 +6239,10 @@ func KnxDatapointTypeByName(value string) (enum KnxDatapointType, ok bool) { return KnxDatapointType_DPT_Channel_Activation_24, true case "DPT_HVACModeNext": return KnxDatapointType_DPT_HVACModeNext, true - case "DPT_DHWModeNext": - return KnxDatapointType_DPT_DHWModeNext, true case "DPT_BinaryValue": return KnxDatapointType_DPT_BinaryValue, true + case "DPT_DHWModeNext": + return KnxDatapointType_DPT_DHWModeNext, true case "DPT_OccModeNext": return KnxDatapointType_DPT_OccModeNext, true case "DPT_BuildingModeNext": @@ -6243,10 +6261,10 @@ func KnxDatapointTypeByName(value string) (enum KnxDatapointType, ok bool) { return KnxDatapointType_DPT_Scaling_Speed, true case "DPT_Scaling_Step_Time": return KnxDatapointType_DPT_Scaling_Step_Time, true - case "DPT_MeteringValue": - return KnxDatapointType_DPT_MeteringValue, true case "DPT_Step": return KnxDatapointType_DPT_Step, true + case "DPT_MeteringValue": + return KnxDatapointType_DPT_MeteringValue, true case "DPT_MBus_Address": return KnxDatapointType_DPT_MBus_Address, true case "DPT_Colour_RGB": @@ -6265,10 +6283,10 @@ func KnxDatapointTypeByName(value string) (enum KnxDatapointType, ok bool) { return KnxDatapointType_DPT_CombinedPosition, true case "DPT_StatusSAB": return KnxDatapointType_DPT_StatusSAB, true - case "DPT_Colour_xyY": - return KnxDatapointType_DPT_Colour_xyY, true case "DPT_UpDown": return KnxDatapointType_DPT_UpDown, true + case "DPT_Colour_xyY": + return KnxDatapointType_DPT_Colour_xyY, true case "DPT_Converter_Status": return KnxDatapointType_DPT_Converter_Status, true case "DPT_Converter_Test_Result": @@ -6287,10 +6305,10 @@ func KnxDatapointTypeByName(value string) (enum KnxDatapointType, ok bool) { return KnxDatapointType_DPT_Relative_Control_RGB, true case "DPT_GeographicalLocation": return KnxDatapointType_DPT_GeographicalLocation, true - case "DPT_TempRoomSetpSetF16_4": - return KnxDatapointType_DPT_TempRoomSetpSetF16_4, true case "DPT_OpenClose": return KnxDatapointType_DPT_OpenClose, true + case "DPT_TempRoomSetpSetF16_4": + return KnxDatapointType_DPT_TempRoomSetpSetF16_4, true case "DPT_TempRoomSetpSetShiftF16_4": return KnxDatapointType_DPT_TempRoomSetpSetShiftF16_4, true case "DPT_Start": @@ -6900,10 +6918,12 @@ func (e KnxDatapointType) PLC4XEnumName() string { return "DPT_LoadTypeDetected" case KnxDatapointType_DPT_Converter_Test_Control: return "DPT_Converter_Test_Control" - case KnxDatapointType_DPT_SABExcept_Behaviour: - return "DPT_SABExcept_Behaviour" + case KnxDatapointType_DPT_Converter_Control: + return "DPT_Converter_Control" case KnxDatapointType_DPT_Bool: return "DPT_Bool" + case KnxDatapointType_DPT_SABExcept_Behaviour: + return "DPT_SABExcept_Behaviour" case KnxDatapointType_DPT_SABBehaviour_Lock_Unlock: return "DPT_SABBehaviour_Lock_Unlock" case KnxDatapointType_DPT_SSSBMode: @@ -6922,10 +6942,10 @@ func (e KnxDatapointType) PLC4XEnumName() string { return "DPT_StatusGen" case KnxDatapointType_DPT_Device_Control: return "DPT_Device_Control" - case KnxDatapointType_DPT_ForceSign: - return "DPT_ForceSign" case KnxDatapointType_DPT_Enable: return "DPT_Enable" + case KnxDatapointType_DPT_ForceSign: + return "DPT_ForceSign" case KnxDatapointType_DPT_ForceSignCool: return "DPT_ForceSignCool" case KnxDatapointType_DPT_StatusRHC: @@ -6944,12 +6964,12 @@ func (e KnxDatapointType) PLC4XEnumName() string { return "DPT_LightActuatorErrorInfo" case KnxDatapointType_DPT_RF_ModeInfo: return "DPT_RF_ModeInfo" - case KnxDatapointType_DPT_RF_FilterInfo: - return "DPT_RF_FilterInfo" case KnxDatapointType_WORD: return "WORD" case KnxDatapointType_DPT_Ramp: return "DPT_Ramp" + case KnxDatapointType_DPT_RF_FilterInfo: + return "DPT_RF_FilterInfo" case KnxDatapointType_DPT_Channel_Activation_8: return "DPT_Channel_Activation_8" case KnxDatapointType_DPT_StatusDHWC: @@ -6968,10 +6988,10 @@ func (e KnxDatapointType) PLC4XEnumName() string { return "DPT_OnOffAction" case KnxDatapointType_DPT_Alarm_Reaction: return "DPT_Alarm_Reaction" - case KnxDatapointType_DPT_UpDown_Action: - return "DPT_UpDown_Action" case KnxDatapointType_DPT_Alarm: return "DPT_Alarm" + case KnxDatapointType_DPT_UpDown_Action: + return "DPT_UpDown_Action" case KnxDatapointType_DPT_HVAC_PB_Action: return "DPT_HVAC_PB_Action" case KnxDatapointType_DPT_DoubleNibble: @@ -6990,10 +7010,10 @@ func (e KnxDatapointType) PLC4XEnumName() string { return "DPT_Channel_Activation_24" case KnxDatapointType_DPT_HVACModeNext: return "DPT_HVACModeNext" - case KnxDatapointType_DPT_DHWModeNext: - return "DPT_DHWModeNext" case KnxDatapointType_DPT_BinaryValue: return "DPT_BinaryValue" + case KnxDatapointType_DPT_DHWModeNext: + return "DPT_DHWModeNext" case KnxDatapointType_DPT_OccModeNext: return "DPT_OccModeNext" case KnxDatapointType_DPT_BuildingModeNext: @@ -7012,10 +7032,10 @@ func (e KnxDatapointType) PLC4XEnumName() string { return "DPT_Scaling_Speed" case KnxDatapointType_DPT_Scaling_Step_Time: return "DPT_Scaling_Step_Time" - case KnxDatapointType_DPT_MeteringValue: - return "DPT_MeteringValue" case KnxDatapointType_DPT_Step: return "DPT_Step" + case KnxDatapointType_DPT_MeteringValue: + return "DPT_MeteringValue" case KnxDatapointType_DPT_MBus_Address: return "DPT_MBus_Address" case KnxDatapointType_DPT_Colour_RGB: @@ -7034,10 +7054,10 @@ func (e KnxDatapointType) PLC4XEnumName() string { return "DPT_CombinedPosition" case KnxDatapointType_DPT_StatusSAB: return "DPT_StatusSAB" - case KnxDatapointType_DPT_Colour_xyY: - return "DPT_Colour_xyY" case KnxDatapointType_DPT_UpDown: return "DPT_UpDown" + case KnxDatapointType_DPT_Colour_xyY: + return "DPT_Colour_xyY" case KnxDatapointType_DPT_Converter_Status: return "DPT_Converter_Status" case KnxDatapointType_DPT_Converter_Test_Result: @@ -7056,10 +7076,10 @@ func (e KnxDatapointType) PLC4XEnumName() string { return "DPT_Relative_Control_RGB" case KnxDatapointType_DPT_GeographicalLocation: return "DPT_GeographicalLocation" - case KnxDatapointType_DPT_TempRoomSetpSetF16_4: - return "DPT_TempRoomSetpSetF16_4" case KnxDatapointType_DPT_OpenClose: return "DPT_OpenClose" + case KnxDatapointType_DPT_TempRoomSetpSetF16_4: + return "DPT_TempRoomSetpSetF16_4" case KnxDatapointType_DPT_TempRoomSetpSetShiftF16_4: return "DPT_TempRoomSetpSetShiftF16_4" case KnxDatapointType_DPT_Start: diff --git a/plc4go/protocols/knxnetip/readwrite/model/KnxManufacturer.go b/plc4go/protocols/knxnetip/readwrite/model/KnxManufacturer.go index e32be764e28..9a979af79cb 100644 --- a/plc4go/protocols/knxnetip/readwrite/model/KnxManufacturer.go +++ b/plc4go/protocols/knxnetip/readwrite/model/KnxManufacturer.go @@ -720,8 +720,16 @@ const ( KnxManufacturer_M_ATIOS_AG KnxManufacturer = 674 KnxManufacturer_M_SMARTLICHT KnxManufacturer = 675 KnxManufacturer_M_BEIJING_BEVONE_ELECTRIC_CO__LTD_ KnxManufacturer = 676 - KnxManufacturer_M_ABB___RESERVED KnxManufacturer = 677 - KnxManufacturer_M_BUSCH_JAEGER_ELEKTRO___RESERVED KnxManufacturer = 678 + KnxManufacturer_M_ELSMART KnxManufacturer = 677 + KnxManufacturer_M_MIDDLE_EAST_SPECIALIZED_CABLES_CO__MESC KnxManufacturer = 678 + KnxManufacturer_M_HANGZHOU_SANYUAN_CABLE_CO___LTD KnxManufacturer = 679 + KnxManufacturer_M_BEIJING_HAILIN_CONTROL_TECHNOLOGY_INC_ KnxManufacturer = 680 + KnxManufacturer_M_HANGZHOU_SNOWYI_TECHNOLOGY_CO__LTD_ KnxManufacturer = 681 + KnxManufacturer_M_XIAMEN_E_TOP_CONTROLS_TECHNOLOGY_CO__LTD KnxManufacturer = 682 + KnxManufacturer_M_VITRUM_DESIGN KnxManufacturer = 683 + KnxManufacturer_M_DETRONS KnxManufacturer = 684 + KnxManufacturer_M_ABB___RESERVED KnxManufacturer = 685 + KnxManufacturer_M_BUSCH_JAEGER_ELEKTRO___RESERVED KnxManufacturer = 686 ) var KnxManufacturerValues []KnxManufacturer @@ -1406,6 +1414,14 @@ func init() { KnxManufacturer_M_ATIOS_AG, KnxManufacturer_M_SMARTLICHT, KnxManufacturer_M_BEIJING_BEVONE_ELECTRIC_CO__LTD_, + KnxManufacturer_M_ELSMART, + KnxManufacturer_M_MIDDLE_EAST_SPECIALIZED_CABLES_CO__MESC, + KnxManufacturer_M_HANGZHOU_SANYUAN_CABLE_CO___LTD, + KnxManufacturer_M_BEIJING_HAILIN_CONTROL_TECHNOLOGY_INC_, + KnxManufacturer_M_HANGZHOU_SNOWYI_TECHNOLOGY_CO__LTD_, + KnxManufacturer_M_XIAMEN_E_TOP_CONTROLS_TECHNOLOGY_CO__LTD, + KnxManufacturer_M_VITRUM_DESIGN, + KnxManufacturer_M_DETRONS, KnxManufacturer_M_ABB___RESERVED, KnxManufacturer_M_BUSCH_JAEGER_ELEKTRO___RESERVED, } @@ -3983,16 +3999,48 @@ func (e KnxManufacturer) Number() uint16 { } case 677: { /* '677' */ - return 43954 + return 735 } case 678: { /* '678' */ - return 43959 + return 736 + } + case 679: + { /* '679' */ + return 737 } case 68: { /* '68' */ return 107 } + case 680: + { /* '680' */ + return 738 + } + case 681: + { /* '681' */ + return 739 + } + case 682: + { /* '682' */ + return 740 + } + case 683: + { /* '683' */ + return 741 + } + case 684: + { /* '684' */ + return 742 + } + case 685: + { /* '685' */ + return 43954 + } + case 686: + { /* '686' */ + return 43959 + } case 69: { /* '69' */ return 108 @@ -6717,16 +6765,48 @@ func (e KnxManufacturer) Name() string { } case 677: { /* '677' */ - return "ABB - reserved" + return "ELSMART" } case 678: { /* '678' */ - return "Busch-Jaeger Elektro - reserved" + return "Middle East Specialized Cables Co. (MESC)" + } + case 679: + { /* '679' */ + return "HANGZHOU SANYUAN CABLE CO., LTD" } case 68: { /* '68' */ return "WAREMA Renkhoff SE" } + case 680: + { /* '680' */ + return "Beijing HaiLin Control Technology Inc." + } + case 681: + { /* '681' */ + return "HangZhou Snowyi Technology Co.,LTD." + } + case 682: + { /* '682' */ + return "Xiamen E-Top Controls Technology Co.,Ltd" + } + case 683: + { /* '683' */ + return "Vitrum Design" + } + case 684: + { /* '684' */ + return "DETRONS" + } + case 685: + { /* '685' */ + return "ABB - reserved" + } + case 686: + { /* '686' */ + return "Busch-Jaeger Elektro - reserved" + } case 69: { /* '69' */ return "Eelectron" @@ -8165,11 +8245,27 @@ func KnxManufacturerByValue(value uint16) (enum KnxManufacturer, ok bool) { case 676: return KnxManufacturer_M_BEIJING_BEVONE_ELECTRIC_CO__LTD_, true case 677: - return KnxManufacturer_M_ABB___RESERVED, true + return KnxManufacturer_M_ELSMART, true case 678: - return KnxManufacturer_M_BUSCH_JAEGER_ELEKTRO___RESERVED, true + return KnxManufacturer_M_MIDDLE_EAST_SPECIALIZED_CABLES_CO__MESC, true + case 679: + return KnxManufacturer_M_HANGZHOU_SANYUAN_CABLE_CO___LTD, true case 68: return KnxManufacturer_M_WAREMA_RENKHOFF_SE, true + case 680: + return KnxManufacturer_M_BEIJING_HAILIN_CONTROL_TECHNOLOGY_INC_, true + case 681: + return KnxManufacturer_M_HANGZHOU_SNOWYI_TECHNOLOGY_CO__LTD_, true + case 682: + return KnxManufacturer_M_XIAMEN_E_TOP_CONTROLS_TECHNOLOGY_CO__LTD, true + case 683: + return KnxManufacturer_M_VITRUM_DESIGN, true + case 684: + return KnxManufacturer_M_DETRONS, true + case 685: + return KnxManufacturer_M_ABB___RESERVED, true + case 686: + return KnxManufacturer_M_BUSCH_JAEGER_ELEKTRO___RESERVED, true case 69: return KnxManufacturer_M_EELECTRON, true case 7: @@ -9528,12 +9624,28 @@ func KnxManufacturerByName(value string) (enum KnxManufacturer, ok bool) { return KnxManufacturer_M_SMARTLICHT, true case "M_BEIJING_BEVONE_ELECTRIC_CO__LTD_": return KnxManufacturer_M_BEIJING_BEVONE_ELECTRIC_CO__LTD_, true + case "M_ELSMART": + return KnxManufacturer_M_ELSMART, true + case "M_MIDDLE_EAST_SPECIALIZED_CABLES_CO__MESC": + return KnxManufacturer_M_MIDDLE_EAST_SPECIALIZED_CABLES_CO__MESC, true + case "M_HANGZHOU_SANYUAN_CABLE_CO___LTD": + return KnxManufacturer_M_HANGZHOU_SANYUAN_CABLE_CO___LTD, true + case "M_WAREMA_RENKHOFF_SE": + return KnxManufacturer_M_WAREMA_RENKHOFF_SE, true + case "M_BEIJING_HAILIN_CONTROL_TECHNOLOGY_INC_": + return KnxManufacturer_M_BEIJING_HAILIN_CONTROL_TECHNOLOGY_INC_, true + case "M_HANGZHOU_SNOWYI_TECHNOLOGY_CO__LTD_": + return KnxManufacturer_M_HANGZHOU_SNOWYI_TECHNOLOGY_CO__LTD_, true + case "M_XIAMEN_E_TOP_CONTROLS_TECHNOLOGY_CO__LTD": + return KnxManufacturer_M_XIAMEN_E_TOP_CONTROLS_TECHNOLOGY_CO__LTD, true + case "M_VITRUM_DESIGN": + return KnxManufacturer_M_VITRUM_DESIGN, true + case "M_DETRONS": + return KnxManufacturer_M_DETRONS, true case "M_ABB___RESERVED": return KnxManufacturer_M_ABB___RESERVED, true case "M_BUSCH_JAEGER_ELEKTRO___RESERVED": return KnxManufacturer_M_BUSCH_JAEGER_ELEKTRO___RESERVED, true - case "M_WAREMA_RENKHOFF_SE": - return KnxManufacturer_M_WAREMA_RENKHOFF_SE, true case "M_EELECTRON": return KnxManufacturer_M_EELECTRON, true case "M_GIRA_GIERSIEPEN": @@ -10953,12 +11065,28 @@ func (e KnxManufacturer) PLC4XEnumName() string { return "M_SMARTLICHT" case KnxManufacturer_M_BEIJING_BEVONE_ELECTRIC_CO__LTD_: return "M_BEIJING_BEVONE_ELECTRIC_CO__LTD_" + case KnxManufacturer_M_ELSMART: + return "M_ELSMART" + case KnxManufacturer_M_MIDDLE_EAST_SPECIALIZED_CABLES_CO__MESC: + return "M_MIDDLE_EAST_SPECIALIZED_CABLES_CO__MESC" + case KnxManufacturer_M_HANGZHOU_SANYUAN_CABLE_CO___LTD: + return "M_HANGZHOU_SANYUAN_CABLE_CO___LTD" + case KnxManufacturer_M_WAREMA_RENKHOFF_SE: + return "M_WAREMA_RENKHOFF_SE" + case KnxManufacturer_M_BEIJING_HAILIN_CONTROL_TECHNOLOGY_INC_: + return "M_BEIJING_HAILIN_CONTROL_TECHNOLOGY_INC_" + case KnxManufacturer_M_HANGZHOU_SNOWYI_TECHNOLOGY_CO__LTD_: + return "M_HANGZHOU_SNOWYI_TECHNOLOGY_CO__LTD_" + case KnxManufacturer_M_XIAMEN_E_TOP_CONTROLS_TECHNOLOGY_CO__LTD: + return "M_XIAMEN_E_TOP_CONTROLS_TECHNOLOGY_CO__LTD" + case KnxManufacturer_M_VITRUM_DESIGN: + return "M_VITRUM_DESIGN" + case KnxManufacturer_M_DETRONS: + return "M_DETRONS" 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_WAREMA_RENKHOFF_SE: - return "M_WAREMA_RENKHOFF_SE" case KnxManufacturer_M_EELECTRON: return "M_EELECTRON" case KnxManufacturer_M_GIRA_GIERSIEPEN: diff --git a/plc4go/protocols/modbus/readwrite/model/ModbusPDUReadDeviceIdentificationResponse.go b/plc4go/protocols/modbus/readwrite/model/ModbusPDUReadDeviceIdentificationResponse.go index 7d699e09bf8..c3e6454150d 100644 --- a/plc4go/protocols/modbus/readwrite/model/ModbusPDUReadDeviceIdentificationResponse.go +++ b/plc4go/protocols/modbus/readwrite/model/ModbusPDUReadDeviceIdentificationResponse.go @@ -305,13 +305,13 @@ func ModbusPDUReadDeviceIdentificationResponseParseWithBuffer(ctx context.Contex return nil, errors.Wrap(pullErr, "Error pulling for objects") } // Count array - objects := make([]ModbusDeviceInformationObject, utils.Max(numberOfObjects, 0)) + objects := make([]ModbusDeviceInformationObject, max(numberOfObjects, 0)) // This happens when the size is set conditional to 0 if len(objects) == 0 { objects = nil } { - _numItems := uint16(utils.Max(numberOfObjects, 0)) + _numItems := uint16(max(numberOfObjects, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/modbus/readwrite/model/ModbusPDUReadFifoQueueResponse.go b/plc4go/protocols/modbus/readwrite/model/ModbusPDUReadFifoQueueResponse.go index b57c19f20f8..ea47968e57b 100644 --- a/plc4go/protocols/modbus/readwrite/model/ModbusPDUReadFifoQueueResponse.go +++ b/plc4go/protocols/modbus/readwrite/model/ModbusPDUReadFifoQueueResponse.go @@ -174,13 +174,13 @@ func ModbusPDUReadFifoQueueResponseParseWithBuffer(ctx context.Context, readBuff return nil, errors.Wrap(pullErr, "Error pulling for fifoValue") } // Count array - fifoValue := make([]uint16, utils.Max(fifoCount, 0)) + fifoValue := make([]uint16, max(fifoCount, 0)) // This happens when the size is set conditional to 0 if len(fifoValue) == 0 { fifoValue = nil } { - _numItems := uint16(utils.Max(fifoCount, 0)) + _numItems := uint16(max(fifoCount, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/ActivateSessionRequest.go b/plc4go/protocols/opcua/readwrite/model/ActivateSessionRequest.go index 81167361e4a..ecc417345a7 100644 --- a/plc4go/protocols/opcua/readwrite/model/ActivateSessionRequest.go +++ b/plc4go/protocols/opcua/readwrite/model/ActivateSessionRequest.go @@ -268,13 +268,13 @@ func ActivateSessionRequestParseWithBuffer(ctx context.Context, readBuffer utils return nil, errors.Wrap(pullErr, "Error pulling for clientSoftwareCertificates") } // Count array - clientSoftwareCertificates := make([]ExtensionObjectDefinition, utils.Max(noOfClientSoftwareCertificates, 0)) + clientSoftwareCertificates := make([]ExtensionObjectDefinition, max(noOfClientSoftwareCertificates, 0)) // This happens when the size is set conditional to 0 if len(clientSoftwareCertificates) == 0 { clientSoftwareCertificates = nil } { - _numItems := uint16(utils.Max(noOfClientSoftwareCertificates, 0)) + _numItems := uint16(max(noOfClientSoftwareCertificates, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -302,13 +302,13 @@ func ActivateSessionRequestParseWithBuffer(ctx context.Context, readBuffer utils return nil, errors.Wrap(pullErr, "Error pulling for localeIds") } // Count array - localeIds := make([]PascalString, utils.Max(noOfLocaleIds, 0)) + localeIds := make([]PascalString, max(noOfLocaleIds, 0)) // This happens when the size is set conditional to 0 if len(localeIds) == 0 { localeIds = nil } { - _numItems := uint16(utils.Max(noOfLocaleIds, 0)) + _numItems := uint16(max(noOfLocaleIds, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/ActivateSessionResponse.go b/plc4go/protocols/opcua/readwrite/model/ActivateSessionResponse.go index fa7e3e34037..a18509dfbce 100644 --- a/plc4go/protocols/opcua/readwrite/model/ActivateSessionResponse.go +++ b/plc4go/protocols/opcua/readwrite/model/ActivateSessionResponse.go @@ -246,13 +246,13 @@ func ActivateSessionResponseParseWithBuffer(ctx context.Context, readBuffer util return nil, errors.Wrap(pullErr, "Error pulling for results") } // Count array - results := make([]StatusCode, utils.Max(noOfResults, 0)) + results := make([]StatusCode, max(noOfResults, 0)) // This happens when the size is set conditional to 0 if len(results) == 0 { results = nil } { - _numItems := uint16(utils.Max(noOfResults, 0)) + _numItems := uint16(max(noOfResults, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -280,13 +280,13 @@ func ActivateSessionResponseParseWithBuffer(ctx context.Context, readBuffer util return nil, errors.Wrap(pullErr, "Error pulling for diagnosticInfos") } // Count array - diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0)) + diagnosticInfos := make([]DiagnosticInfo, max(noOfDiagnosticInfos, 0)) // This happens when the size is set conditional to 0 if len(diagnosticInfos) == 0 { diagnosticInfos = nil } { - _numItems := uint16(utils.Max(noOfDiagnosticInfos, 0)) + _numItems := uint16(max(noOfDiagnosticInfos, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/AddNodesRequest.go b/plc4go/protocols/opcua/readwrite/model/AddNodesRequest.go index d2dc31816eb..f055cd83450 100644 --- a/plc4go/protocols/opcua/readwrite/model/AddNodesRequest.go +++ b/plc4go/protocols/opcua/readwrite/model/AddNodesRequest.go @@ -193,13 +193,13 @@ func AddNodesRequestParseWithBuffer(ctx context.Context, readBuffer utils.ReadBu return nil, errors.Wrap(pullErr, "Error pulling for nodesToAdd") } // Count array - nodesToAdd := make([]ExtensionObjectDefinition, utils.Max(noOfNodesToAdd, 0)) + nodesToAdd := make([]ExtensionObjectDefinition, max(noOfNodesToAdd, 0)) // This happens when the size is set conditional to 0 if len(nodesToAdd) == 0 { nodesToAdd = nil } { - _numItems := uint16(utils.Max(noOfNodesToAdd, 0)) + _numItems := uint16(max(noOfNodesToAdd, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/AddNodesResponse.go b/plc4go/protocols/opcua/readwrite/model/AddNodesResponse.go index d0d040fa54b..5ba579733e3 100644 --- a/plc4go/protocols/opcua/readwrite/model/AddNodesResponse.go +++ b/plc4go/protocols/opcua/readwrite/model/AddNodesResponse.go @@ -222,13 +222,13 @@ func AddNodesResponseParseWithBuffer(ctx context.Context, readBuffer utils.ReadB return nil, errors.Wrap(pullErr, "Error pulling for results") } // Count array - results := make([]ExtensionObjectDefinition, utils.Max(noOfResults, 0)) + results := make([]ExtensionObjectDefinition, max(noOfResults, 0)) // This happens when the size is set conditional to 0 if len(results) == 0 { results = nil } { - _numItems := uint16(utils.Max(noOfResults, 0)) + _numItems := uint16(max(noOfResults, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -256,13 +256,13 @@ func AddNodesResponseParseWithBuffer(ctx context.Context, readBuffer utils.ReadB return nil, errors.Wrap(pullErr, "Error pulling for diagnosticInfos") } // Count array - diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0)) + diagnosticInfos := make([]DiagnosticInfo, max(noOfDiagnosticInfos, 0)) // This happens when the size is set conditional to 0 if len(diagnosticInfos) == 0 { diagnosticInfos = nil } { - _numItems := uint16(utils.Max(noOfDiagnosticInfos, 0)) + _numItems := uint16(max(noOfDiagnosticInfos, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/AddReferencesRequest.go b/plc4go/protocols/opcua/readwrite/model/AddReferencesRequest.go index 7c32c5f1d64..5596455f20d 100644 --- a/plc4go/protocols/opcua/readwrite/model/AddReferencesRequest.go +++ b/plc4go/protocols/opcua/readwrite/model/AddReferencesRequest.go @@ -193,13 +193,13 @@ func AddReferencesRequestParseWithBuffer(ctx context.Context, readBuffer utils.R return nil, errors.Wrap(pullErr, "Error pulling for referencesToAdd") } // Count array - referencesToAdd := make([]ExtensionObjectDefinition, utils.Max(noOfReferencesToAdd, 0)) + referencesToAdd := make([]ExtensionObjectDefinition, max(noOfReferencesToAdd, 0)) // This happens when the size is set conditional to 0 if len(referencesToAdd) == 0 { referencesToAdd = nil } { - _numItems := uint16(utils.Max(noOfReferencesToAdd, 0)) + _numItems := uint16(max(noOfReferencesToAdd, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/AddReferencesResponse.go b/plc4go/protocols/opcua/readwrite/model/AddReferencesResponse.go index 2e97b0eb53a..fc60701b155 100644 --- a/plc4go/protocols/opcua/readwrite/model/AddReferencesResponse.go +++ b/plc4go/protocols/opcua/readwrite/model/AddReferencesResponse.go @@ -222,13 +222,13 @@ func AddReferencesResponseParseWithBuffer(ctx context.Context, readBuffer utils. return nil, errors.Wrap(pullErr, "Error pulling for results") } // Count array - results := make([]StatusCode, utils.Max(noOfResults, 0)) + results := make([]StatusCode, max(noOfResults, 0)) // This happens when the size is set conditional to 0 if len(results) == 0 { results = nil } { - _numItems := uint16(utils.Max(noOfResults, 0)) + _numItems := uint16(max(noOfResults, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -256,13 +256,13 @@ func AddReferencesResponseParseWithBuffer(ctx context.Context, readBuffer utils. return nil, errors.Wrap(pullErr, "Error pulling for diagnosticInfos") } // Count array - diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0)) + diagnosticInfos := make([]DiagnosticInfo, max(noOfDiagnosticInfos, 0)) // This happens when the size is set conditional to 0 if len(diagnosticInfos) == 0 { diagnosticInfos = nil } { - _numItems := uint16(utils.Max(noOfDiagnosticInfos, 0)) + _numItems := uint16(max(noOfDiagnosticInfos, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/AdditionalParametersType.go b/plc4go/protocols/opcua/readwrite/model/AdditionalParametersType.go index 317f247f716..bec3a5dbe20 100644 --- a/plc4go/protocols/opcua/readwrite/model/AdditionalParametersType.go +++ b/plc4go/protocols/opcua/readwrite/model/AdditionalParametersType.go @@ -169,13 +169,13 @@ func AdditionalParametersTypeParseWithBuffer(ctx context.Context, readBuffer uti return nil, errors.Wrap(pullErr, "Error pulling for parameters") } // Count array - parameters := make([]ExtensionObjectDefinition, utils.Max(noOfParameters, 0)) + parameters := make([]ExtensionObjectDefinition, max(noOfParameters, 0)) // This happens when the size is set conditional to 0 if len(parameters) == 0 { parameters = nil } { - _numItems := uint16(utils.Max(noOfParameters, 0)) + _numItems := uint16(max(noOfParameters, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/AliasNameDataType.go b/plc4go/protocols/opcua/readwrite/model/AliasNameDataType.go index 69b057f917e..b744a2c72b0 100644 --- a/plc4go/protocols/opcua/readwrite/model/AliasNameDataType.go +++ b/plc4go/protocols/opcua/readwrite/model/AliasNameDataType.go @@ -193,13 +193,13 @@ func AliasNameDataTypeParseWithBuffer(ctx context.Context, readBuffer utils.Read return nil, errors.Wrap(pullErr, "Error pulling for referencedNodes") } // Count array - referencedNodes := make([]ExpandedNodeId, utils.Max(noOfReferencedNodes, 0)) + referencedNodes := make([]ExpandedNodeId, max(noOfReferencedNodes, 0)) // This happens when the size is set conditional to 0 if len(referencedNodes) == 0 { referencedNodes = nil } { - _numItems := uint16(utils.Max(noOfReferencedNodes, 0)) + _numItems := uint16(max(noOfReferencedNodes, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/ApplicationDescription.go b/plc4go/protocols/opcua/readwrite/model/ApplicationDescription.go index ec58d896a3f..76404b32226 100644 --- a/plc4go/protocols/opcua/readwrite/model/ApplicationDescription.go +++ b/plc4go/protocols/opcua/readwrite/model/ApplicationDescription.go @@ -313,13 +313,13 @@ func ApplicationDescriptionParseWithBuffer(ctx context.Context, readBuffer utils return nil, errors.Wrap(pullErr, "Error pulling for discoveryUrls") } // Count array - discoveryUrls := make([]PascalString, utils.Max(noOfDiscoveryUrls, 0)) + discoveryUrls := make([]PascalString, max(noOfDiscoveryUrls, 0)) // This happens when the size is set conditional to 0 if len(discoveryUrls) == 0 { discoveryUrls = nil } { - _numItems := uint16(utils.Max(noOfDiscoveryUrls, 0)) + _numItems := uint16(max(noOfDiscoveryUrls, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/Argument.go b/plc4go/protocols/opcua/readwrite/model/Argument.go index b706c827080..9400f70473b 100644 --- a/plc4go/protocols/opcua/readwrite/model/Argument.go +++ b/plc4go/protocols/opcua/readwrite/model/Argument.go @@ -241,13 +241,13 @@ func ArgumentParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, i return nil, errors.Wrap(pullErr, "Error pulling for arrayDimensions") } // Count array - arrayDimensions := make([]uint32, utils.Max(noOfArrayDimensions, 0)) + arrayDimensions := make([]uint32, max(noOfArrayDimensions, 0)) // This happens when the size is set conditional to 0 if len(arrayDimensions) == 0 { arrayDimensions = nil } { - _numItems := uint16(utils.Max(noOfArrayDimensions, 0)) + _numItems := uint16(max(noOfArrayDimensions, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/AxisInformation.go b/plc4go/protocols/opcua/readwrite/model/AxisInformation.go index 930d65c1236..d1fdb066883 100644 --- a/plc4go/protocols/opcua/readwrite/model/AxisInformation.go +++ b/plc4go/protocols/opcua/readwrite/model/AxisInformation.go @@ -260,13 +260,13 @@ func AxisInformationParseWithBuffer(ctx context.Context, readBuffer utils.ReadBu return nil, errors.Wrap(pullErr, "Error pulling for axisSteps") } // Count array - axisSteps := make([]float64, utils.Max(noOfAxisSteps, 0)) + axisSteps := make([]float64, max(noOfAxisSteps, 0)) // This happens when the size is set conditional to 0 if len(axisSteps) == 0 { axisSteps = nil } { - _numItems := uint16(utils.Max(noOfAxisSteps, 0)) + _numItems := uint16(max(noOfAxisSteps, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/BrowseNextRequest.go b/plc4go/protocols/opcua/readwrite/model/BrowseNextRequest.go index d5865c2ef95..34dece16615 100644 --- a/plc4go/protocols/opcua/readwrite/model/BrowseNextRequest.go +++ b/plc4go/protocols/opcua/readwrite/model/BrowseNextRequest.go @@ -233,13 +233,13 @@ func BrowseNextRequestParseWithBuffer(ctx context.Context, readBuffer utils.Read return nil, errors.Wrap(pullErr, "Error pulling for continuationPoints") } // Count array - continuationPoints := make([]PascalByteString, utils.Max(noOfContinuationPoints, 0)) + continuationPoints := make([]PascalByteString, max(noOfContinuationPoints, 0)) // This happens when the size is set conditional to 0 if len(continuationPoints) == 0 { continuationPoints = nil } { - _numItems := uint16(utils.Max(noOfContinuationPoints, 0)) + _numItems := uint16(max(noOfContinuationPoints, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/BrowseNextResponse.go b/plc4go/protocols/opcua/readwrite/model/BrowseNextResponse.go index 8dade5ddd90..6c410ee2d4e 100644 --- a/plc4go/protocols/opcua/readwrite/model/BrowseNextResponse.go +++ b/plc4go/protocols/opcua/readwrite/model/BrowseNextResponse.go @@ -222,13 +222,13 @@ func BrowseNextResponseParseWithBuffer(ctx context.Context, readBuffer utils.Rea return nil, errors.Wrap(pullErr, "Error pulling for results") } // Count array - results := make([]ExtensionObjectDefinition, utils.Max(noOfResults, 0)) + results := make([]ExtensionObjectDefinition, max(noOfResults, 0)) // This happens when the size is set conditional to 0 if len(results) == 0 { results = nil } { - _numItems := uint16(utils.Max(noOfResults, 0)) + _numItems := uint16(max(noOfResults, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -256,13 +256,13 @@ func BrowseNextResponseParseWithBuffer(ctx context.Context, readBuffer utils.Rea return nil, errors.Wrap(pullErr, "Error pulling for diagnosticInfos") } // Count array - diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0)) + diagnosticInfos := make([]DiagnosticInfo, max(noOfDiagnosticInfos, 0)) // This happens when the size is set conditional to 0 if len(diagnosticInfos) == 0 { diagnosticInfos = nil } { - _numItems := uint16(utils.Max(noOfDiagnosticInfos, 0)) + _numItems := uint16(max(noOfDiagnosticInfos, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/BrowsePathResult.go b/plc4go/protocols/opcua/readwrite/model/BrowsePathResult.go index 53bd43802ab..c98d2fa06ae 100644 --- a/plc4go/protocols/opcua/readwrite/model/BrowsePathResult.go +++ b/plc4go/protocols/opcua/readwrite/model/BrowsePathResult.go @@ -193,13 +193,13 @@ func BrowsePathResultParseWithBuffer(ctx context.Context, readBuffer utils.ReadB return nil, errors.Wrap(pullErr, "Error pulling for targets") } // Count array - targets := make([]ExtensionObjectDefinition, utils.Max(noOfTargets, 0)) + targets := make([]ExtensionObjectDefinition, max(noOfTargets, 0)) // This happens when the size is set conditional to 0 if len(targets) == 0 { targets = nil } { - _numItems := uint16(utils.Max(noOfTargets, 0)) + _numItems := uint16(max(noOfTargets, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/BrowseRequest.go b/plc4go/protocols/opcua/readwrite/model/BrowseRequest.go index 4e7cb4f84fe..ff4e7c8252b 100644 --- a/plc4go/protocols/opcua/readwrite/model/BrowseRequest.go +++ b/plc4go/protocols/opcua/readwrite/model/BrowseRequest.go @@ -235,13 +235,13 @@ func BrowseRequestParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuff return nil, errors.Wrap(pullErr, "Error pulling for nodesToBrowse") } // Count array - nodesToBrowse := make([]ExtensionObjectDefinition, utils.Max(noOfNodesToBrowse, 0)) + nodesToBrowse := make([]ExtensionObjectDefinition, max(noOfNodesToBrowse, 0)) // This happens when the size is set conditional to 0 if len(nodesToBrowse) == 0 { nodesToBrowse = nil } { - _numItems := uint16(utils.Max(noOfNodesToBrowse, 0)) + _numItems := uint16(max(noOfNodesToBrowse, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/BrowseResponse.go b/plc4go/protocols/opcua/readwrite/model/BrowseResponse.go index c05ece94aa9..4b19293f383 100644 --- a/plc4go/protocols/opcua/readwrite/model/BrowseResponse.go +++ b/plc4go/protocols/opcua/readwrite/model/BrowseResponse.go @@ -222,13 +222,13 @@ func BrowseResponseParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuf return nil, errors.Wrap(pullErr, "Error pulling for results") } // Count array - results := make([]ExtensionObjectDefinition, utils.Max(noOfResults, 0)) + results := make([]ExtensionObjectDefinition, max(noOfResults, 0)) // This happens when the size is set conditional to 0 if len(results) == 0 { results = nil } { - _numItems := uint16(utils.Max(noOfResults, 0)) + _numItems := uint16(max(noOfResults, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -256,13 +256,13 @@ func BrowseResponseParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuf return nil, errors.Wrap(pullErr, "Error pulling for diagnosticInfos") } // Count array - diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0)) + diagnosticInfos := make([]DiagnosticInfo, max(noOfDiagnosticInfos, 0)) // This happens when the size is set conditional to 0 if len(diagnosticInfos) == 0 { diagnosticInfos = nil } { - _numItems := uint16(utils.Max(noOfDiagnosticInfos, 0)) + _numItems := uint16(max(noOfDiagnosticInfos, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/BrowseResult.go b/plc4go/protocols/opcua/readwrite/model/BrowseResult.go index 64bca8fd8ce..73ee78c75db 100644 --- a/plc4go/protocols/opcua/readwrite/model/BrowseResult.go +++ b/plc4go/protocols/opcua/readwrite/model/BrowseResult.go @@ -217,13 +217,13 @@ func BrowseResultParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffe return nil, errors.Wrap(pullErr, "Error pulling for references") } // Count array - references := make([]ExtensionObjectDefinition, utils.Max(noOfReferences, 0)) + references := make([]ExtensionObjectDefinition, max(noOfReferences, 0)) // This happens when the size is set conditional to 0 if len(references) == 0 { references = nil } { - _numItems := uint16(utils.Max(noOfReferences, 0)) + _numItems := uint16(max(noOfReferences, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/ByteStringArray.go b/plc4go/protocols/opcua/readwrite/model/ByteStringArray.go index 37a4daad2d7..5d39438a092 100644 --- a/plc4go/protocols/opcua/readwrite/model/ByteStringArray.go +++ b/plc4go/protocols/opcua/readwrite/model/ByteStringArray.go @@ -136,13 +136,13 @@ func ByteStringArrayParseWithBuffer(ctx context.Context, readBuffer utils.ReadBu return nil, errors.Wrap(pullErr, "Error pulling for value") } // Count array - value := make([]uint8, utils.Max(arrayLength, 0)) + value := make([]uint8, max(arrayLength, 0)) // This happens when the size is set conditional to 0 if len(value) == 0 { value = nil } { - _numItems := uint16(utils.Max(arrayLength, 0)) + _numItems := uint16(max(arrayLength, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/CallMethodRequest.go b/plc4go/protocols/opcua/readwrite/model/CallMethodRequest.go index 4869d94772f..b24cdd704d3 100644 --- a/plc4go/protocols/opcua/readwrite/model/CallMethodRequest.go +++ b/plc4go/protocols/opcua/readwrite/model/CallMethodRequest.go @@ -217,13 +217,13 @@ func CallMethodRequestParseWithBuffer(ctx context.Context, readBuffer utils.Read return nil, errors.Wrap(pullErr, "Error pulling for inputArguments") } // Count array - inputArguments := make([]Variant, utils.Max(noOfInputArguments, 0)) + inputArguments := make([]Variant, max(noOfInputArguments, 0)) // This happens when the size is set conditional to 0 if len(inputArguments) == 0 { inputArguments = nil } { - _numItems := uint16(utils.Max(noOfInputArguments, 0)) + _numItems := uint16(max(noOfInputArguments, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/CallMethodResult.go b/plc4go/protocols/opcua/readwrite/model/CallMethodResult.go index 4754a8d1dc8..d803e2483d8 100644 --- a/plc4go/protocols/opcua/readwrite/model/CallMethodResult.go +++ b/plc4go/protocols/opcua/readwrite/model/CallMethodResult.go @@ -251,13 +251,13 @@ func CallMethodResultParseWithBuffer(ctx context.Context, readBuffer utils.ReadB return nil, errors.Wrap(pullErr, "Error pulling for inputArgumentResults") } // Count array - inputArgumentResults := make([]StatusCode, utils.Max(noOfInputArgumentResults, 0)) + inputArgumentResults := make([]StatusCode, max(noOfInputArgumentResults, 0)) // This happens when the size is set conditional to 0 if len(inputArgumentResults) == 0 { inputArgumentResults = nil } { - _numItems := uint16(utils.Max(noOfInputArgumentResults, 0)) + _numItems := uint16(max(noOfInputArgumentResults, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -285,13 +285,13 @@ func CallMethodResultParseWithBuffer(ctx context.Context, readBuffer utils.ReadB return nil, errors.Wrap(pullErr, "Error pulling for inputArgumentDiagnosticInfos") } // Count array - inputArgumentDiagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfInputArgumentDiagnosticInfos, 0)) + inputArgumentDiagnosticInfos := make([]DiagnosticInfo, max(noOfInputArgumentDiagnosticInfos, 0)) // This happens when the size is set conditional to 0 if len(inputArgumentDiagnosticInfos) == 0 { inputArgumentDiagnosticInfos = nil } { - _numItems := uint16(utils.Max(noOfInputArgumentDiagnosticInfos, 0)) + _numItems := uint16(max(noOfInputArgumentDiagnosticInfos, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -319,13 +319,13 @@ func CallMethodResultParseWithBuffer(ctx context.Context, readBuffer utils.ReadB return nil, errors.Wrap(pullErr, "Error pulling for outputArguments") } // Count array - outputArguments := make([]Variant, utils.Max(noOfOutputArguments, 0)) + outputArguments := make([]Variant, max(noOfOutputArguments, 0)) // This happens when the size is set conditional to 0 if len(outputArguments) == 0 { outputArguments = nil } { - _numItems := uint16(utils.Max(noOfOutputArguments, 0)) + _numItems := uint16(max(noOfOutputArguments, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/CallRequest.go b/plc4go/protocols/opcua/readwrite/model/CallRequest.go index 3934dfad124..2e41bdc7a88 100644 --- a/plc4go/protocols/opcua/readwrite/model/CallRequest.go +++ b/plc4go/protocols/opcua/readwrite/model/CallRequest.go @@ -193,13 +193,13 @@ func CallRequestParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer return nil, errors.Wrap(pullErr, "Error pulling for methodsToCall") } // Count array - methodsToCall := make([]ExtensionObjectDefinition, utils.Max(noOfMethodsToCall, 0)) + methodsToCall := make([]ExtensionObjectDefinition, max(noOfMethodsToCall, 0)) // This happens when the size is set conditional to 0 if len(methodsToCall) == 0 { methodsToCall = nil } { - _numItems := uint16(utils.Max(noOfMethodsToCall, 0)) + _numItems := uint16(max(noOfMethodsToCall, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/CallResponse.go b/plc4go/protocols/opcua/readwrite/model/CallResponse.go index 15cc0d4001c..660479a5121 100644 --- a/plc4go/protocols/opcua/readwrite/model/CallResponse.go +++ b/plc4go/protocols/opcua/readwrite/model/CallResponse.go @@ -222,13 +222,13 @@ func CallResponseParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffe return nil, errors.Wrap(pullErr, "Error pulling for results") } // Count array - results := make([]ExtensionObjectDefinition, utils.Max(noOfResults, 0)) + results := make([]ExtensionObjectDefinition, max(noOfResults, 0)) // This happens when the size is set conditional to 0 if len(results) == 0 { results = nil } { - _numItems := uint16(utils.Max(noOfResults, 0)) + _numItems := uint16(max(noOfResults, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -256,13 +256,13 @@ func CallResponseParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffe return nil, errors.Wrap(pullErr, "Error pulling for diagnosticInfos") } // Count array - diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0)) + diagnosticInfos := make([]DiagnosticInfo, max(noOfDiagnosticInfos, 0)) // This happens when the size is set conditional to 0 if len(diagnosticInfos) == 0 { diagnosticInfos = nil } { - _numItems := uint16(utils.Max(noOfDiagnosticInfos, 0)) + _numItems := uint16(max(noOfDiagnosticInfos, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/ContentFilter.go b/plc4go/protocols/opcua/readwrite/model/ContentFilter.go index b083d70a0b7..f3a0d968bbe 100644 --- a/plc4go/protocols/opcua/readwrite/model/ContentFilter.go +++ b/plc4go/protocols/opcua/readwrite/model/ContentFilter.go @@ -169,13 +169,13 @@ func ContentFilterParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuff return nil, errors.Wrap(pullErr, "Error pulling for elements") } // Count array - elements := make([]ExtensionObjectDefinition, utils.Max(noOfElements, 0)) + elements := make([]ExtensionObjectDefinition, max(noOfElements, 0)) // This happens when the size is set conditional to 0 if len(elements) == 0 { elements = nil } { - _numItems := uint16(utils.Max(noOfElements, 0)) + _numItems := uint16(max(noOfElements, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/ContentFilterElement.go b/plc4go/protocols/opcua/readwrite/model/ContentFilterElement.go index 5a1a67a0caf..90f72fc46d3 100644 --- a/plc4go/protocols/opcua/readwrite/model/ContentFilterElement.go +++ b/plc4go/protocols/opcua/readwrite/model/ContentFilterElement.go @@ -193,13 +193,13 @@ func ContentFilterElementParseWithBuffer(ctx context.Context, readBuffer utils.R return nil, errors.Wrap(pullErr, "Error pulling for filterOperands") } // Count array - filterOperands := make([]ExtensionObject, utils.Max(noOfFilterOperands, 0)) + filterOperands := make([]ExtensionObject, max(noOfFilterOperands, 0)) // This happens when the size is set conditional to 0 if len(filterOperands) == 0 { filterOperands = nil } { - _numItems := uint16(utils.Max(noOfFilterOperands, 0)) + _numItems := uint16(max(noOfFilterOperands, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/ContentFilterElementResult.go b/plc4go/protocols/opcua/readwrite/model/ContentFilterElementResult.go index 1d5ed9a8c29..fe257491992 100644 --- a/plc4go/protocols/opcua/readwrite/model/ContentFilterElementResult.go +++ b/plc4go/protocols/opcua/readwrite/model/ContentFilterElementResult.go @@ -222,13 +222,13 @@ func ContentFilterElementResultParseWithBuffer(ctx context.Context, readBuffer u return nil, errors.Wrap(pullErr, "Error pulling for operandStatusCodes") } // Count array - operandStatusCodes := make([]StatusCode, utils.Max(noOfOperandStatusCodes, 0)) + operandStatusCodes := make([]StatusCode, max(noOfOperandStatusCodes, 0)) // This happens when the size is set conditional to 0 if len(operandStatusCodes) == 0 { operandStatusCodes = nil } { - _numItems := uint16(utils.Max(noOfOperandStatusCodes, 0)) + _numItems := uint16(max(noOfOperandStatusCodes, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -256,13 +256,13 @@ func ContentFilterElementResultParseWithBuffer(ctx context.Context, readBuffer u return nil, errors.Wrap(pullErr, "Error pulling for operandDiagnosticInfos") } // Count array - operandDiagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfOperandDiagnosticInfos, 0)) + operandDiagnosticInfos := make([]DiagnosticInfo, max(noOfOperandDiagnosticInfos, 0)) // This happens when the size is set conditional to 0 if len(operandDiagnosticInfos) == 0 { operandDiagnosticInfos = nil } { - _numItems := uint16(utils.Max(noOfOperandDiagnosticInfos, 0)) + _numItems := uint16(max(noOfOperandDiagnosticInfos, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/ContentFilterResult.go b/plc4go/protocols/opcua/readwrite/model/ContentFilterResult.go index cf62555b249..dd49af4d828 100644 --- a/plc4go/protocols/opcua/readwrite/model/ContentFilterResult.go +++ b/plc4go/protocols/opcua/readwrite/model/ContentFilterResult.go @@ -198,13 +198,13 @@ func ContentFilterResultParseWithBuffer(ctx context.Context, readBuffer utils.Re return nil, errors.Wrap(pullErr, "Error pulling for elementResults") } // Count array - elementResults := make([]ExtensionObjectDefinition, utils.Max(noOfElementResults, 0)) + elementResults := make([]ExtensionObjectDefinition, max(noOfElementResults, 0)) // This happens when the size is set conditional to 0 if len(elementResults) == 0 { elementResults = nil } { - _numItems := uint16(utils.Max(noOfElementResults, 0)) + _numItems := uint16(max(noOfElementResults, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -232,13 +232,13 @@ func ContentFilterResultParseWithBuffer(ctx context.Context, readBuffer utils.Re return nil, errors.Wrap(pullErr, "Error pulling for elementDiagnosticInfos") } // Count array - elementDiagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfElementDiagnosticInfos, 0)) + elementDiagnosticInfos := make([]DiagnosticInfo, max(noOfElementDiagnosticInfos, 0)) // This happens when the size is set conditional to 0 if len(elementDiagnosticInfos) == 0 { elementDiagnosticInfos = nil } { - _numItems := uint16(utils.Max(noOfElementDiagnosticInfos, 0)) + _numItems := uint16(max(noOfElementDiagnosticInfos, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/CreateMonitoredItemsRequest.go b/plc4go/protocols/opcua/readwrite/model/CreateMonitoredItemsRequest.go index e507a028158..856a0500357 100644 --- a/plc4go/protocols/opcua/readwrite/model/CreateMonitoredItemsRequest.go +++ b/plc4go/protocols/opcua/readwrite/model/CreateMonitoredItemsRequest.go @@ -235,13 +235,13 @@ func CreateMonitoredItemsRequestParseWithBuffer(ctx context.Context, readBuffer return nil, errors.Wrap(pullErr, "Error pulling for itemsToCreate") } // Count array - itemsToCreate := make([]ExtensionObjectDefinition, utils.Max(noOfItemsToCreate, 0)) + itemsToCreate := make([]ExtensionObjectDefinition, max(noOfItemsToCreate, 0)) // This happens when the size is set conditional to 0 if len(itemsToCreate) == 0 { itemsToCreate = nil } { - _numItems := uint16(utils.Max(noOfItemsToCreate, 0)) + _numItems := uint16(max(noOfItemsToCreate, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/CreateMonitoredItemsResponse.go b/plc4go/protocols/opcua/readwrite/model/CreateMonitoredItemsResponse.go index c9ededd42d7..f4a22521d90 100644 --- a/plc4go/protocols/opcua/readwrite/model/CreateMonitoredItemsResponse.go +++ b/plc4go/protocols/opcua/readwrite/model/CreateMonitoredItemsResponse.go @@ -222,13 +222,13 @@ func CreateMonitoredItemsResponseParseWithBuffer(ctx context.Context, readBuffer return nil, errors.Wrap(pullErr, "Error pulling for results") } // Count array - results := make([]ExtensionObjectDefinition, utils.Max(noOfResults, 0)) + results := make([]ExtensionObjectDefinition, max(noOfResults, 0)) // This happens when the size is set conditional to 0 if len(results) == 0 { results = nil } { - _numItems := uint16(utils.Max(noOfResults, 0)) + _numItems := uint16(max(noOfResults, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -256,13 +256,13 @@ func CreateMonitoredItemsResponseParseWithBuffer(ctx context.Context, readBuffer return nil, errors.Wrap(pullErr, "Error pulling for diagnosticInfos") } // Count array - diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0)) + diagnosticInfos := make([]DiagnosticInfo, max(noOfDiagnosticInfos, 0)) // This happens when the size is set conditional to 0 if len(diagnosticInfos) == 0 { diagnosticInfos = nil } { - _numItems := uint16(utils.Max(noOfDiagnosticInfos, 0)) + _numItems := uint16(max(noOfDiagnosticInfos, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/CreateSessionResponse.go b/plc4go/protocols/opcua/readwrite/model/CreateSessionResponse.go index 93fcdf88f1f..a3c92d08053 100644 --- a/plc4go/protocols/opcua/readwrite/model/CreateSessionResponse.go +++ b/plc4go/protocols/opcua/readwrite/model/CreateSessionResponse.go @@ -358,13 +358,13 @@ func CreateSessionResponseParseWithBuffer(ctx context.Context, readBuffer utils. return nil, errors.Wrap(pullErr, "Error pulling for serverEndpoints") } // Count array - serverEndpoints := make([]ExtensionObjectDefinition, utils.Max(noOfServerEndpoints, 0)) + serverEndpoints := make([]ExtensionObjectDefinition, max(noOfServerEndpoints, 0)) // This happens when the size is set conditional to 0 if len(serverEndpoints) == 0 { serverEndpoints = nil } { - _numItems := uint16(utils.Max(noOfServerEndpoints, 0)) + _numItems := uint16(max(noOfServerEndpoints, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -392,13 +392,13 @@ func CreateSessionResponseParseWithBuffer(ctx context.Context, readBuffer utils. return nil, errors.Wrap(pullErr, "Error pulling for serverSoftwareCertificates") } // Count array - serverSoftwareCertificates := make([]ExtensionObjectDefinition, utils.Max(noOfServerSoftwareCertificates, 0)) + serverSoftwareCertificates := make([]ExtensionObjectDefinition, max(noOfServerSoftwareCertificates, 0)) // This happens when the size is set conditional to 0 if len(serverSoftwareCertificates) == 0 { serverSoftwareCertificates = nil } { - _numItems := uint16(utils.Max(noOfServerSoftwareCertificates, 0)) + _numItems := uint16(max(noOfServerSoftwareCertificates, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/DataChangeNotification.go b/plc4go/protocols/opcua/readwrite/model/DataChangeNotification.go index c718807334a..8569725c44c 100644 --- a/plc4go/protocols/opcua/readwrite/model/DataChangeNotification.go +++ b/plc4go/protocols/opcua/readwrite/model/DataChangeNotification.go @@ -208,13 +208,13 @@ func DataChangeNotificationParseWithBuffer(ctx context.Context, readBuffer utils return nil, errors.Wrap(pullErr, "Error pulling for monitoredItems") } // Count array - monitoredItems := make([]ExtensionObjectDefinition, utils.Max(noOfMonitoredItems, 0)) + monitoredItems := make([]ExtensionObjectDefinition, max(noOfMonitoredItems, 0)) // This happens when the size is set conditional to 0 if len(monitoredItems) == 0 { monitoredItems = nil } { - _numItems := uint16(utils.Max(noOfMonitoredItems, 0)) + _numItems := uint16(max(noOfMonitoredItems, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -242,13 +242,13 @@ func DataChangeNotificationParseWithBuffer(ctx context.Context, readBuffer utils return nil, errors.Wrap(pullErr, "Error pulling for diagnosticInfos") } // Count array - diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0)) + diagnosticInfos := make([]DiagnosticInfo, max(noOfDiagnosticInfos, 0)) // This happens when the size is set conditional to 0 if len(diagnosticInfos) == 0 { diagnosticInfos = nil } { - _numItems := uint16(utils.Max(noOfDiagnosticInfos, 0)) + _numItems := uint16(max(noOfDiagnosticInfos, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/DataSetWriterDataType.go b/plc4go/protocols/opcua/readwrite/model/DataSetWriterDataType.go index 2d387a5307c..8eb37a9fae9 100644 --- a/plc4go/protocols/opcua/readwrite/model/DataSetWriterDataType.go +++ b/plc4go/protocols/opcua/readwrite/model/DataSetWriterDataType.go @@ -339,13 +339,13 @@ func DataSetWriterDataTypeParseWithBuffer(ctx context.Context, readBuffer utils. return nil, errors.Wrap(pullErr, "Error pulling for dataSetWriterProperties") } // Count array - dataSetWriterProperties := make([]ExtensionObjectDefinition, utils.Max(noOfDataSetWriterProperties, 0)) + dataSetWriterProperties := make([]ExtensionObjectDefinition, max(noOfDataSetWriterProperties, 0)) // This happens when the size is set conditional to 0 if len(dataSetWriterProperties) == 0 { dataSetWriterProperties = nil } { - _numItems := uint16(utils.Max(noOfDataSetWriterProperties, 0)) + _numItems := uint16(max(noOfDataSetWriterProperties, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/DataTypeSchemaHeader.go b/plc4go/protocols/opcua/readwrite/model/DataTypeSchemaHeader.go index 0579486e355..3626b19c100 100644 --- a/plc4go/protocols/opcua/readwrite/model/DataTypeSchemaHeader.go +++ b/plc4go/protocols/opcua/readwrite/model/DataTypeSchemaHeader.go @@ -256,13 +256,13 @@ func DataTypeSchemaHeaderParseWithBuffer(ctx context.Context, readBuffer utils.R return nil, errors.Wrap(pullErr, "Error pulling for namespaces") } // Count array - namespaces := make([]PascalString, utils.Max(noOfNamespaces, 0)) + namespaces := make([]PascalString, max(noOfNamespaces, 0)) // This happens when the size is set conditional to 0 if len(namespaces) == 0 { namespaces = nil } { - _numItems := uint16(utils.Max(noOfNamespaces, 0)) + _numItems := uint16(max(noOfNamespaces, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -290,13 +290,13 @@ func DataTypeSchemaHeaderParseWithBuffer(ctx context.Context, readBuffer utils.R return nil, errors.Wrap(pullErr, "Error pulling for structureDataTypes") } // Count array - structureDataTypes := make([]DataTypeDescription, utils.Max(noOfStructureDataTypes, 0)) + structureDataTypes := make([]DataTypeDescription, max(noOfStructureDataTypes, 0)) // This happens when the size is set conditional to 0 if len(structureDataTypes) == 0 { structureDataTypes = nil } { - _numItems := uint16(utils.Max(noOfStructureDataTypes, 0)) + _numItems := uint16(max(noOfStructureDataTypes, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -324,13 +324,13 @@ func DataTypeSchemaHeaderParseWithBuffer(ctx context.Context, readBuffer utils.R return nil, errors.Wrap(pullErr, "Error pulling for enumDataTypes") } // Count array - enumDataTypes := make([]DataTypeDescription, utils.Max(noOfEnumDataTypes, 0)) + enumDataTypes := make([]DataTypeDescription, max(noOfEnumDataTypes, 0)) // This happens when the size is set conditional to 0 if len(enumDataTypes) == 0 { enumDataTypes = nil } { - _numItems := uint16(utils.Max(noOfEnumDataTypes, 0)) + _numItems := uint16(max(noOfEnumDataTypes, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -358,13 +358,13 @@ func DataTypeSchemaHeaderParseWithBuffer(ctx context.Context, readBuffer utils.R return nil, errors.Wrap(pullErr, "Error pulling for simpleDataTypes") } // Count array - simpleDataTypes := make([]DataTypeDescription, utils.Max(noOfSimpleDataTypes, 0)) + simpleDataTypes := make([]DataTypeDescription, max(noOfSimpleDataTypes, 0)) // This happens when the size is set conditional to 0 if len(simpleDataTypes) == 0 { simpleDataTypes = nil } { - _numItems := uint16(utils.Max(noOfSimpleDataTypes, 0)) + _numItems := uint16(max(noOfSimpleDataTypes, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/DeleteMonitoredItemsRequest.go b/plc4go/protocols/opcua/readwrite/model/DeleteMonitoredItemsRequest.go index d53e48be146..8ee6cdd7a1d 100644 --- a/plc4go/protocols/opcua/readwrite/model/DeleteMonitoredItemsRequest.go +++ b/plc4go/protocols/opcua/readwrite/model/DeleteMonitoredItemsRequest.go @@ -206,13 +206,13 @@ func DeleteMonitoredItemsRequestParseWithBuffer(ctx context.Context, readBuffer return nil, errors.Wrap(pullErr, "Error pulling for monitoredItemIds") } // Count array - monitoredItemIds := make([]uint32, utils.Max(noOfMonitoredItemIds, 0)) + monitoredItemIds := make([]uint32, max(noOfMonitoredItemIds, 0)) // This happens when the size is set conditional to 0 if len(monitoredItemIds) == 0 { monitoredItemIds = nil } { - _numItems := uint16(utils.Max(noOfMonitoredItemIds, 0)) + _numItems := uint16(max(noOfMonitoredItemIds, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/DeleteMonitoredItemsResponse.go b/plc4go/protocols/opcua/readwrite/model/DeleteMonitoredItemsResponse.go index fc04ff8608c..bdc4f4cc7e3 100644 --- a/plc4go/protocols/opcua/readwrite/model/DeleteMonitoredItemsResponse.go +++ b/plc4go/protocols/opcua/readwrite/model/DeleteMonitoredItemsResponse.go @@ -222,13 +222,13 @@ func DeleteMonitoredItemsResponseParseWithBuffer(ctx context.Context, readBuffer return nil, errors.Wrap(pullErr, "Error pulling for results") } // Count array - results := make([]StatusCode, utils.Max(noOfResults, 0)) + results := make([]StatusCode, max(noOfResults, 0)) // This happens when the size is set conditional to 0 if len(results) == 0 { results = nil } { - _numItems := uint16(utils.Max(noOfResults, 0)) + _numItems := uint16(max(noOfResults, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -256,13 +256,13 @@ func DeleteMonitoredItemsResponseParseWithBuffer(ctx context.Context, readBuffer return nil, errors.Wrap(pullErr, "Error pulling for diagnosticInfos") } // Count array - diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0)) + diagnosticInfos := make([]DiagnosticInfo, max(noOfDiagnosticInfos, 0)) // This happens when the size is set conditional to 0 if len(diagnosticInfos) == 0 { diagnosticInfos = nil } { - _numItems := uint16(utils.Max(noOfDiagnosticInfos, 0)) + _numItems := uint16(max(noOfDiagnosticInfos, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/DeleteNodesRequest.go b/plc4go/protocols/opcua/readwrite/model/DeleteNodesRequest.go index 229bca07d9f..bda708759e5 100644 --- a/plc4go/protocols/opcua/readwrite/model/DeleteNodesRequest.go +++ b/plc4go/protocols/opcua/readwrite/model/DeleteNodesRequest.go @@ -193,13 +193,13 @@ func DeleteNodesRequestParseWithBuffer(ctx context.Context, readBuffer utils.Rea return nil, errors.Wrap(pullErr, "Error pulling for nodesToDelete") } // Count array - nodesToDelete := make([]ExtensionObjectDefinition, utils.Max(noOfNodesToDelete, 0)) + nodesToDelete := make([]ExtensionObjectDefinition, max(noOfNodesToDelete, 0)) // This happens when the size is set conditional to 0 if len(nodesToDelete) == 0 { nodesToDelete = nil } { - _numItems := uint16(utils.Max(noOfNodesToDelete, 0)) + _numItems := uint16(max(noOfNodesToDelete, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/DeleteNodesResponse.go b/plc4go/protocols/opcua/readwrite/model/DeleteNodesResponse.go index 365f1a85ef7..25e31d70698 100644 --- a/plc4go/protocols/opcua/readwrite/model/DeleteNodesResponse.go +++ b/plc4go/protocols/opcua/readwrite/model/DeleteNodesResponse.go @@ -222,13 +222,13 @@ func DeleteNodesResponseParseWithBuffer(ctx context.Context, readBuffer utils.Re return nil, errors.Wrap(pullErr, "Error pulling for results") } // Count array - results := make([]StatusCode, utils.Max(noOfResults, 0)) + results := make([]StatusCode, max(noOfResults, 0)) // This happens when the size is set conditional to 0 if len(results) == 0 { results = nil } { - _numItems := uint16(utils.Max(noOfResults, 0)) + _numItems := uint16(max(noOfResults, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -256,13 +256,13 @@ func DeleteNodesResponseParseWithBuffer(ctx context.Context, readBuffer utils.Re return nil, errors.Wrap(pullErr, "Error pulling for diagnosticInfos") } // Count array - diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0)) + diagnosticInfos := make([]DiagnosticInfo, max(noOfDiagnosticInfos, 0)) // This happens when the size is set conditional to 0 if len(diagnosticInfos) == 0 { diagnosticInfos = nil } { - _numItems := uint16(utils.Max(noOfDiagnosticInfos, 0)) + _numItems := uint16(max(noOfDiagnosticInfos, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/DeleteReferencesRequest.go b/plc4go/protocols/opcua/readwrite/model/DeleteReferencesRequest.go index faaccef912c..4f18efdf7c7 100644 --- a/plc4go/protocols/opcua/readwrite/model/DeleteReferencesRequest.go +++ b/plc4go/protocols/opcua/readwrite/model/DeleteReferencesRequest.go @@ -193,13 +193,13 @@ func DeleteReferencesRequestParseWithBuffer(ctx context.Context, readBuffer util return nil, errors.Wrap(pullErr, "Error pulling for referencesToDelete") } // Count array - referencesToDelete := make([]ExtensionObjectDefinition, utils.Max(noOfReferencesToDelete, 0)) + referencesToDelete := make([]ExtensionObjectDefinition, max(noOfReferencesToDelete, 0)) // This happens when the size is set conditional to 0 if len(referencesToDelete) == 0 { referencesToDelete = nil } { - _numItems := uint16(utils.Max(noOfReferencesToDelete, 0)) + _numItems := uint16(max(noOfReferencesToDelete, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/DeleteReferencesResponse.go b/plc4go/protocols/opcua/readwrite/model/DeleteReferencesResponse.go index 62bada2c63c..b5880f0b0b6 100644 --- a/plc4go/protocols/opcua/readwrite/model/DeleteReferencesResponse.go +++ b/plc4go/protocols/opcua/readwrite/model/DeleteReferencesResponse.go @@ -222,13 +222,13 @@ func DeleteReferencesResponseParseWithBuffer(ctx context.Context, readBuffer uti return nil, errors.Wrap(pullErr, "Error pulling for results") } // Count array - results := make([]StatusCode, utils.Max(noOfResults, 0)) + results := make([]StatusCode, max(noOfResults, 0)) // This happens when the size is set conditional to 0 if len(results) == 0 { results = nil } { - _numItems := uint16(utils.Max(noOfResults, 0)) + _numItems := uint16(max(noOfResults, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -256,13 +256,13 @@ func DeleteReferencesResponseParseWithBuffer(ctx context.Context, readBuffer uti return nil, errors.Wrap(pullErr, "Error pulling for diagnosticInfos") } // Count array - diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0)) + diagnosticInfos := make([]DiagnosticInfo, max(noOfDiagnosticInfos, 0)) // This happens when the size is set conditional to 0 if len(diagnosticInfos) == 0 { diagnosticInfos = nil } { - _numItems := uint16(utils.Max(noOfDiagnosticInfos, 0)) + _numItems := uint16(max(noOfDiagnosticInfos, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/DeleteSubscriptionsRequest.go b/plc4go/protocols/opcua/readwrite/model/DeleteSubscriptionsRequest.go index afd733c00f3..940f6f6d318 100644 --- a/plc4go/protocols/opcua/readwrite/model/DeleteSubscriptionsRequest.go +++ b/plc4go/protocols/opcua/readwrite/model/DeleteSubscriptionsRequest.go @@ -188,13 +188,13 @@ func DeleteSubscriptionsRequestParseWithBuffer(ctx context.Context, readBuffer u return nil, errors.Wrap(pullErr, "Error pulling for subscriptionIds") } // Count array - subscriptionIds := make([]uint32, utils.Max(noOfSubscriptionIds, 0)) + subscriptionIds := make([]uint32, max(noOfSubscriptionIds, 0)) // This happens when the size is set conditional to 0 if len(subscriptionIds) == 0 { subscriptionIds = nil } { - _numItems := uint16(utils.Max(noOfSubscriptionIds, 0)) + _numItems := uint16(max(noOfSubscriptionIds, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/DeleteSubscriptionsResponse.go b/plc4go/protocols/opcua/readwrite/model/DeleteSubscriptionsResponse.go index 1b0ab65572a..495bfbd84bd 100644 --- a/plc4go/protocols/opcua/readwrite/model/DeleteSubscriptionsResponse.go +++ b/plc4go/protocols/opcua/readwrite/model/DeleteSubscriptionsResponse.go @@ -222,13 +222,13 @@ func DeleteSubscriptionsResponseParseWithBuffer(ctx context.Context, readBuffer return nil, errors.Wrap(pullErr, "Error pulling for results") } // Count array - results := make([]StatusCode, utils.Max(noOfResults, 0)) + results := make([]StatusCode, max(noOfResults, 0)) // This happens when the size is set conditional to 0 if len(results) == 0 { results = nil } { - _numItems := uint16(utils.Max(noOfResults, 0)) + _numItems := uint16(max(noOfResults, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -256,13 +256,13 @@ func DeleteSubscriptionsResponseParseWithBuffer(ctx context.Context, readBuffer return nil, errors.Wrap(pullErr, "Error pulling for diagnosticInfos") } // Count array - diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0)) + diagnosticInfos := make([]DiagnosticInfo, max(noOfDiagnosticInfos, 0)) // This happens when the size is set conditional to 0 if len(diagnosticInfos) == 0 { diagnosticInfos = nil } { - _numItems := uint16(utils.Max(noOfDiagnosticInfos, 0)) + _numItems := uint16(max(noOfDiagnosticInfos, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/EndpointDescription.go b/plc4go/protocols/opcua/readwrite/model/EndpointDescription.go index 38cf224cf21..7262e2af1eb 100644 --- a/plc4go/protocols/opcua/readwrite/model/EndpointDescription.go +++ b/plc4go/protocols/opcua/readwrite/model/EndpointDescription.go @@ -311,13 +311,13 @@ func EndpointDescriptionParseWithBuffer(ctx context.Context, readBuffer utils.Re return nil, errors.Wrap(pullErr, "Error pulling for userIdentityTokens") } // Count array - userIdentityTokens := make([]ExtensionObjectDefinition, utils.Max(noOfUserIdentityTokens, 0)) + userIdentityTokens := make([]ExtensionObjectDefinition, max(noOfUserIdentityTokens, 0)) // This happens when the size is set conditional to 0 if len(userIdentityTokens) == 0 { userIdentityTokens = nil } { - _numItems := uint16(utils.Max(noOfUserIdentityTokens, 0)) + _numItems := uint16(max(noOfUserIdentityTokens, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/EndpointUrlListDataType.go b/plc4go/protocols/opcua/readwrite/model/EndpointUrlListDataType.go index 46f57266551..8feee79a81b 100644 --- a/plc4go/protocols/opcua/readwrite/model/EndpointUrlListDataType.go +++ b/plc4go/protocols/opcua/readwrite/model/EndpointUrlListDataType.go @@ -169,13 +169,13 @@ func EndpointUrlListDataTypeParseWithBuffer(ctx context.Context, readBuffer util return nil, errors.Wrap(pullErr, "Error pulling for endpointUrlList") } // Count array - endpointUrlList := make([]PascalString, utils.Max(noOfEndpointUrlList, 0)) + endpointUrlList := make([]PascalString, max(noOfEndpointUrlList, 0)) // This happens when the size is set conditional to 0 if len(endpointUrlList) == 0 { endpointUrlList = nil } { - _numItems := uint16(utils.Max(noOfEndpointUrlList, 0)) + _numItems := uint16(max(noOfEndpointUrlList, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/EventFieldList.go b/plc4go/protocols/opcua/readwrite/model/EventFieldList.go index 2ccbea70f9f..0db7fae0610 100644 --- a/plc4go/protocols/opcua/readwrite/model/EventFieldList.go +++ b/plc4go/protocols/opcua/readwrite/model/EventFieldList.go @@ -187,13 +187,13 @@ func EventFieldListParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuf return nil, errors.Wrap(pullErr, "Error pulling for eventFields") } // Count array - eventFields := make([]Variant, utils.Max(noOfEventFields, 0)) + eventFields := make([]Variant, max(noOfEventFields, 0)) // This happens when the size is set conditional to 0 if len(eventFields) == 0 { eventFields = nil } { - _numItems := uint16(utils.Max(noOfEventFields, 0)) + _numItems := uint16(max(noOfEventFields, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/EventNotificationList.go b/plc4go/protocols/opcua/readwrite/model/EventNotificationList.go index a88a6b94ecf..4db602a228d 100644 --- a/plc4go/protocols/opcua/readwrite/model/EventNotificationList.go +++ b/plc4go/protocols/opcua/readwrite/model/EventNotificationList.go @@ -179,13 +179,13 @@ func EventNotificationListParseWithBuffer(ctx context.Context, readBuffer utils. return nil, errors.Wrap(pullErr, "Error pulling for events") } // Count array - events := make([]ExtensionObjectDefinition, utils.Max(noOfEvents, 0)) + events := make([]ExtensionObjectDefinition, max(noOfEvents, 0)) // This happens when the size is set conditional to 0 if len(events) == 0 { events = nil } { - _numItems := uint16(utils.Max(noOfEvents, 0)) + _numItems := uint16(max(noOfEvents, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/FieldMetaData.go b/plc4go/protocols/opcua/readwrite/model/FieldMetaData.go index c672e911892..881e5873c13 100644 --- a/plc4go/protocols/opcua/readwrite/model/FieldMetaData.go +++ b/plc4go/protocols/opcua/readwrite/model/FieldMetaData.go @@ -347,13 +347,13 @@ func FieldMetaDataParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuff return nil, errors.Wrap(pullErr, "Error pulling for arrayDimensions") } // Count array - arrayDimensions := make([]uint32, utils.Max(noOfArrayDimensions, 0)) + arrayDimensions := make([]uint32, max(noOfArrayDimensions, 0)) // This happens when the size is set conditional to 0 if len(arrayDimensions) == 0 { arrayDimensions = nil } { - _numItems := uint16(utils.Max(noOfArrayDimensions, 0)) + _numItems := uint16(max(noOfArrayDimensions, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -401,13 +401,13 @@ func FieldMetaDataParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuff return nil, errors.Wrap(pullErr, "Error pulling for properties") } // Count array - properties := make([]ExtensionObjectDefinition, utils.Max(noOfProperties, 0)) + properties := make([]ExtensionObjectDefinition, max(noOfProperties, 0)) // This happens when the size is set conditional to 0 if len(properties) == 0 { properties = nil } { - _numItems := uint16(utils.Max(noOfProperties, 0)) + _numItems := uint16(max(noOfProperties, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/FindServersOnNetworkRequest.go b/plc4go/protocols/opcua/readwrite/model/FindServersOnNetworkRequest.go index 57d2656cb0c..f4c2618d989 100644 --- a/plc4go/protocols/opcua/readwrite/model/FindServersOnNetworkRequest.go +++ b/plc4go/protocols/opcua/readwrite/model/FindServersOnNetworkRequest.go @@ -229,13 +229,13 @@ func FindServersOnNetworkRequestParseWithBuffer(ctx context.Context, readBuffer return nil, errors.Wrap(pullErr, "Error pulling for serverCapabilityFilter") } // Count array - serverCapabilityFilter := make([]PascalString, utils.Max(noOfServerCapabilityFilter, 0)) + serverCapabilityFilter := make([]PascalString, max(noOfServerCapabilityFilter, 0)) // This happens when the size is set conditional to 0 if len(serverCapabilityFilter) == 0 { serverCapabilityFilter = nil } { - _numItems := uint16(utils.Max(noOfServerCapabilityFilter, 0)) + _numItems := uint16(max(noOfServerCapabilityFilter, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/FindServersOnNetworkResponse.go b/plc4go/protocols/opcua/readwrite/model/FindServersOnNetworkResponse.go index 673a1b9d572..6aee65145b6 100644 --- a/plc4go/protocols/opcua/readwrite/model/FindServersOnNetworkResponse.go +++ b/plc4go/protocols/opcua/readwrite/model/FindServersOnNetworkResponse.go @@ -211,13 +211,13 @@ func FindServersOnNetworkResponseParseWithBuffer(ctx context.Context, readBuffer return nil, errors.Wrap(pullErr, "Error pulling for servers") } // Count array - servers := make([]ExtensionObjectDefinition, utils.Max(noOfServers, 0)) + servers := make([]ExtensionObjectDefinition, max(noOfServers, 0)) // This happens when the size is set conditional to 0 if len(servers) == 0 { servers = nil } { - _numItems := uint16(utils.Max(noOfServers, 0)) + _numItems := uint16(max(noOfServers, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/FindServersRequest.go b/plc4go/protocols/opcua/readwrite/model/FindServersRequest.go index 629382913f0..8eabf9152d9 100644 --- a/plc4go/protocols/opcua/readwrite/model/FindServersRequest.go +++ b/plc4go/protocols/opcua/readwrite/model/FindServersRequest.go @@ -246,13 +246,13 @@ func FindServersRequestParseWithBuffer(ctx context.Context, readBuffer utils.Rea return nil, errors.Wrap(pullErr, "Error pulling for localeIds") } // Count array - localeIds := make([]PascalString, utils.Max(noOfLocaleIds, 0)) + localeIds := make([]PascalString, max(noOfLocaleIds, 0)) // This happens when the size is set conditional to 0 if len(localeIds) == 0 { localeIds = nil } { - _numItems := uint16(utils.Max(noOfLocaleIds, 0)) + _numItems := uint16(max(noOfLocaleIds, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -280,13 +280,13 @@ func FindServersRequestParseWithBuffer(ctx context.Context, readBuffer utils.Rea return nil, errors.Wrap(pullErr, "Error pulling for serverUris") } // Count array - serverUris := make([]PascalString, utils.Max(noOfServerUris, 0)) + serverUris := make([]PascalString, max(noOfServerUris, 0)) // This happens when the size is set conditional to 0 if len(serverUris) == 0 { serverUris = nil } { - _numItems := uint16(utils.Max(noOfServerUris, 0)) + _numItems := uint16(max(noOfServerUris, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/FindServersResponse.go b/plc4go/protocols/opcua/readwrite/model/FindServersResponse.go index 07b3babd951..0d41d9568db 100644 --- a/plc4go/protocols/opcua/readwrite/model/FindServersResponse.go +++ b/plc4go/protocols/opcua/readwrite/model/FindServersResponse.go @@ -193,13 +193,13 @@ func FindServersResponseParseWithBuffer(ctx context.Context, readBuffer utils.Re return nil, errors.Wrap(pullErr, "Error pulling for servers") } // Count array - servers := make([]ExtensionObjectDefinition, utils.Max(noOfServers, 0)) + servers := make([]ExtensionObjectDefinition, max(noOfServers, 0)) // This happens when the size is set conditional to 0 if len(servers) == 0 { servers = nil } { - _numItems := uint16(utils.Max(noOfServers, 0)) + _numItems := uint16(max(noOfServers, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/GetEndpointsRequest.go b/plc4go/protocols/opcua/readwrite/model/GetEndpointsRequest.go index 778819ac61e..4d440aa726b 100644 --- a/plc4go/protocols/opcua/readwrite/model/GetEndpointsRequest.go +++ b/plc4go/protocols/opcua/readwrite/model/GetEndpointsRequest.go @@ -246,13 +246,13 @@ func GetEndpointsRequestParseWithBuffer(ctx context.Context, readBuffer utils.Re return nil, errors.Wrap(pullErr, "Error pulling for localeIds") } // Count array - localeIds := make([]PascalString, utils.Max(noOfLocaleIds, 0)) + localeIds := make([]PascalString, max(noOfLocaleIds, 0)) // This happens when the size is set conditional to 0 if len(localeIds) == 0 { localeIds = nil } { - _numItems := uint16(utils.Max(noOfLocaleIds, 0)) + _numItems := uint16(max(noOfLocaleIds, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -280,13 +280,13 @@ func GetEndpointsRequestParseWithBuffer(ctx context.Context, readBuffer utils.Re return nil, errors.Wrap(pullErr, "Error pulling for profileUris") } // Count array - profileUris := make([]PascalString, utils.Max(noOfProfileUris, 0)) + profileUris := make([]PascalString, max(noOfProfileUris, 0)) // This happens when the size is set conditional to 0 if len(profileUris) == 0 { profileUris = nil } { - _numItems := uint16(utils.Max(noOfProfileUris, 0)) + _numItems := uint16(max(noOfProfileUris, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/GetEndpointsResponse.go b/plc4go/protocols/opcua/readwrite/model/GetEndpointsResponse.go index 542ed76e71e..87e0cd19bec 100644 --- a/plc4go/protocols/opcua/readwrite/model/GetEndpointsResponse.go +++ b/plc4go/protocols/opcua/readwrite/model/GetEndpointsResponse.go @@ -193,13 +193,13 @@ func GetEndpointsResponseParseWithBuffer(ctx context.Context, readBuffer utils.R return nil, errors.Wrap(pullErr, "Error pulling for endpoints") } // Count array - endpoints := make([]ExtensionObjectDefinition, utils.Max(noOfEndpoints, 0)) + endpoints := make([]ExtensionObjectDefinition, max(noOfEndpoints, 0)) // This happens when the size is set conditional to 0 if len(endpoints) == 0 { endpoints = nil } { - _numItems := uint16(utils.Max(noOfEndpoints, 0)) + _numItems := uint16(max(noOfEndpoints, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/HistoryData.go b/plc4go/protocols/opcua/readwrite/model/HistoryData.go index 5a3bc964a6f..658fc0d2059 100644 --- a/plc4go/protocols/opcua/readwrite/model/HistoryData.go +++ b/plc4go/protocols/opcua/readwrite/model/HistoryData.go @@ -169,13 +169,13 @@ func HistoryDataParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer return nil, errors.Wrap(pullErr, "Error pulling for dataValues") } // Count array - dataValues := make([]DataValue, utils.Max(noOfDataValues, 0)) + dataValues := make([]DataValue, max(noOfDataValues, 0)) // This happens when the size is set conditional to 0 if len(dataValues) == 0 { dataValues = nil } { - _numItems := uint16(utils.Max(noOfDataValues, 0)) + _numItems := uint16(max(noOfDataValues, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/HistoryEvent.go b/plc4go/protocols/opcua/readwrite/model/HistoryEvent.go index de9c103fc7c..b56deb6245d 100644 --- a/plc4go/protocols/opcua/readwrite/model/HistoryEvent.go +++ b/plc4go/protocols/opcua/readwrite/model/HistoryEvent.go @@ -169,13 +169,13 @@ func HistoryEventParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffe return nil, errors.Wrap(pullErr, "Error pulling for events") } // Count array - events := make([]ExtensionObjectDefinition, utils.Max(noOfEvents, 0)) + events := make([]ExtensionObjectDefinition, max(noOfEvents, 0)) // This happens when the size is set conditional to 0 if len(events) == 0 { events = nil } { - _numItems := uint16(utils.Max(noOfEvents, 0)) + _numItems := uint16(max(noOfEvents, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/HistoryEventFieldList.go b/plc4go/protocols/opcua/readwrite/model/HistoryEventFieldList.go index 59f6d935e86..22d3d742fa3 100644 --- a/plc4go/protocols/opcua/readwrite/model/HistoryEventFieldList.go +++ b/plc4go/protocols/opcua/readwrite/model/HistoryEventFieldList.go @@ -169,13 +169,13 @@ func HistoryEventFieldListParseWithBuffer(ctx context.Context, readBuffer utils. return nil, errors.Wrap(pullErr, "Error pulling for eventFields") } // Count array - eventFields := make([]Variant, utils.Max(noOfEventFields, 0)) + eventFields := make([]Variant, max(noOfEventFields, 0)) // This happens when the size is set conditional to 0 if len(eventFields) == 0 { eventFields = nil } { - _numItems := uint16(utils.Max(noOfEventFields, 0)) + _numItems := uint16(max(noOfEventFields, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/HistoryReadRequest.go b/plc4go/protocols/opcua/readwrite/model/HistoryReadRequest.go index 84849a996d8..7af13ca28f9 100644 --- a/plc4go/protocols/opcua/readwrite/model/HistoryReadRequest.go +++ b/plc4go/protocols/opcua/readwrite/model/HistoryReadRequest.go @@ -281,13 +281,13 @@ func HistoryReadRequestParseWithBuffer(ctx context.Context, readBuffer utils.Rea return nil, errors.Wrap(pullErr, "Error pulling for nodesToRead") } // Count array - nodesToRead := make([]ExtensionObjectDefinition, utils.Max(noOfNodesToRead, 0)) + nodesToRead := make([]ExtensionObjectDefinition, max(noOfNodesToRead, 0)) // This happens when the size is set conditional to 0 if len(nodesToRead) == 0 { nodesToRead = nil } { - _numItems := uint16(utils.Max(noOfNodesToRead, 0)) + _numItems := uint16(max(noOfNodesToRead, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/HistoryReadResponse.go b/plc4go/protocols/opcua/readwrite/model/HistoryReadResponse.go index 013911acf16..6151bf9bf36 100644 --- a/plc4go/protocols/opcua/readwrite/model/HistoryReadResponse.go +++ b/plc4go/protocols/opcua/readwrite/model/HistoryReadResponse.go @@ -222,13 +222,13 @@ func HistoryReadResponseParseWithBuffer(ctx context.Context, readBuffer utils.Re return nil, errors.Wrap(pullErr, "Error pulling for results") } // Count array - results := make([]ExtensionObjectDefinition, utils.Max(noOfResults, 0)) + results := make([]ExtensionObjectDefinition, max(noOfResults, 0)) // This happens when the size is set conditional to 0 if len(results) == 0 { results = nil } { - _numItems := uint16(utils.Max(noOfResults, 0)) + _numItems := uint16(max(noOfResults, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -256,13 +256,13 @@ func HistoryReadResponseParseWithBuffer(ctx context.Context, readBuffer utils.Re return nil, errors.Wrap(pullErr, "Error pulling for diagnosticInfos") } // Count array - diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0)) + diagnosticInfos := make([]DiagnosticInfo, max(noOfDiagnosticInfos, 0)) // This happens when the size is set conditional to 0 if len(diagnosticInfos) == 0 { diagnosticInfos = nil } { - _numItems := uint16(utils.Max(noOfDiagnosticInfos, 0)) + _numItems := uint16(max(noOfDiagnosticInfos, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/HistoryUpdateRequest.go b/plc4go/protocols/opcua/readwrite/model/HistoryUpdateRequest.go index 86bce6ba812..c6d77187170 100644 --- a/plc4go/protocols/opcua/readwrite/model/HistoryUpdateRequest.go +++ b/plc4go/protocols/opcua/readwrite/model/HistoryUpdateRequest.go @@ -193,13 +193,13 @@ func HistoryUpdateRequestParseWithBuffer(ctx context.Context, readBuffer utils.R return nil, errors.Wrap(pullErr, "Error pulling for historyUpdateDetails") } // Count array - historyUpdateDetails := make([]ExtensionObject, utils.Max(noOfHistoryUpdateDetails, 0)) + historyUpdateDetails := make([]ExtensionObject, max(noOfHistoryUpdateDetails, 0)) // This happens when the size is set conditional to 0 if len(historyUpdateDetails) == 0 { historyUpdateDetails = nil } { - _numItems := uint16(utils.Max(noOfHistoryUpdateDetails, 0)) + _numItems := uint16(max(noOfHistoryUpdateDetails, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/HistoryUpdateResponse.go b/plc4go/protocols/opcua/readwrite/model/HistoryUpdateResponse.go index 6bf33f0b314..4a9a2d4c5f3 100644 --- a/plc4go/protocols/opcua/readwrite/model/HistoryUpdateResponse.go +++ b/plc4go/protocols/opcua/readwrite/model/HistoryUpdateResponse.go @@ -222,13 +222,13 @@ func HistoryUpdateResponseParseWithBuffer(ctx context.Context, readBuffer utils. return nil, errors.Wrap(pullErr, "Error pulling for results") } // Count array - results := make([]ExtensionObjectDefinition, utils.Max(noOfResults, 0)) + results := make([]ExtensionObjectDefinition, max(noOfResults, 0)) // This happens when the size is set conditional to 0 if len(results) == 0 { results = nil } { - _numItems := uint16(utils.Max(noOfResults, 0)) + _numItems := uint16(max(noOfResults, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -256,13 +256,13 @@ func HistoryUpdateResponseParseWithBuffer(ctx context.Context, readBuffer utils. return nil, errors.Wrap(pullErr, "Error pulling for diagnosticInfos") } // Count array - diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0)) + diagnosticInfos := make([]DiagnosticInfo, max(noOfDiagnosticInfos, 0)) // This happens when the size is set conditional to 0 if len(diagnosticInfos) == 0 { diagnosticInfos = nil } { - _numItems := uint16(utils.Max(noOfDiagnosticInfos, 0)) + _numItems := uint16(max(noOfDiagnosticInfos, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/HistoryUpdateResult.go b/plc4go/protocols/opcua/readwrite/model/HistoryUpdateResult.go index d405c8e1780..bb2b49be66c 100644 --- a/plc4go/protocols/opcua/readwrite/model/HistoryUpdateResult.go +++ b/plc4go/protocols/opcua/readwrite/model/HistoryUpdateResult.go @@ -222,13 +222,13 @@ func HistoryUpdateResultParseWithBuffer(ctx context.Context, readBuffer utils.Re return nil, errors.Wrap(pullErr, "Error pulling for operationResults") } // Count array - operationResults := make([]StatusCode, utils.Max(noOfOperationResults, 0)) + operationResults := make([]StatusCode, max(noOfOperationResults, 0)) // This happens when the size is set conditional to 0 if len(operationResults) == 0 { operationResults = nil } { - _numItems := uint16(utils.Max(noOfOperationResults, 0)) + _numItems := uint16(max(noOfOperationResults, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -256,13 +256,13 @@ func HistoryUpdateResultParseWithBuffer(ctx context.Context, readBuffer utils.Re return nil, errors.Wrap(pullErr, "Error pulling for diagnosticInfos") } // Count array - diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0)) + diagnosticInfos := make([]DiagnosticInfo, max(noOfDiagnosticInfos, 0)) // This happens when the size is set conditional to 0 if len(diagnosticInfos) == 0 { diagnosticInfos = nil } { - _numItems := uint16(utils.Max(noOfDiagnosticInfos, 0)) + _numItems := uint16(max(noOfDiagnosticInfos, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/ModifyMonitoredItemsRequest.go b/plc4go/protocols/opcua/readwrite/model/ModifyMonitoredItemsRequest.go index 72ef86d11f8..8c8d093cdf7 100644 --- a/plc4go/protocols/opcua/readwrite/model/ModifyMonitoredItemsRequest.go +++ b/plc4go/protocols/opcua/readwrite/model/ModifyMonitoredItemsRequest.go @@ -235,13 +235,13 @@ func ModifyMonitoredItemsRequestParseWithBuffer(ctx context.Context, readBuffer return nil, errors.Wrap(pullErr, "Error pulling for itemsToModify") } // Count array - itemsToModify := make([]ExtensionObjectDefinition, utils.Max(noOfItemsToModify, 0)) + itemsToModify := make([]ExtensionObjectDefinition, max(noOfItemsToModify, 0)) // This happens when the size is set conditional to 0 if len(itemsToModify) == 0 { itemsToModify = nil } { - _numItems := uint16(utils.Max(noOfItemsToModify, 0)) + _numItems := uint16(max(noOfItemsToModify, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/ModifyMonitoredItemsResponse.go b/plc4go/protocols/opcua/readwrite/model/ModifyMonitoredItemsResponse.go index 0606d852192..aac142a9743 100644 --- a/plc4go/protocols/opcua/readwrite/model/ModifyMonitoredItemsResponse.go +++ b/plc4go/protocols/opcua/readwrite/model/ModifyMonitoredItemsResponse.go @@ -222,13 +222,13 @@ func ModifyMonitoredItemsResponseParseWithBuffer(ctx context.Context, readBuffer return nil, errors.Wrap(pullErr, "Error pulling for results") } // Count array - results := make([]ExtensionObjectDefinition, utils.Max(noOfResults, 0)) + results := make([]ExtensionObjectDefinition, max(noOfResults, 0)) // This happens when the size is set conditional to 0 if len(results) == 0 { results = nil } { - _numItems := uint16(utils.Max(noOfResults, 0)) + _numItems := uint16(max(noOfResults, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -256,13 +256,13 @@ func ModifyMonitoredItemsResponseParseWithBuffer(ctx context.Context, readBuffer return nil, errors.Wrap(pullErr, "Error pulling for diagnosticInfos") } // Count array - diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0)) + diagnosticInfos := make([]DiagnosticInfo, max(noOfDiagnosticInfos, 0)) // This happens when the size is set conditional to 0 if len(diagnosticInfos) == 0 { diagnosticInfos = nil } { - _numItems := uint16(utils.Max(noOfDiagnosticInfos, 0)) + _numItems := uint16(max(noOfDiagnosticInfos, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/NetworkGroupDataType.go b/plc4go/protocols/opcua/readwrite/model/NetworkGroupDataType.go index e830a504fe8..3a3593b92a1 100644 --- a/plc4go/protocols/opcua/readwrite/model/NetworkGroupDataType.go +++ b/plc4go/protocols/opcua/readwrite/model/NetworkGroupDataType.go @@ -193,13 +193,13 @@ func NetworkGroupDataTypeParseWithBuffer(ctx context.Context, readBuffer utils.R return nil, errors.Wrap(pullErr, "Error pulling for networkPaths") } // Count array - networkPaths := make([]ExtensionObjectDefinition, utils.Max(noOfNetworkPaths, 0)) + networkPaths := make([]ExtensionObjectDefinition, max(noOfNetworkPaths, 0)) // This happens when the size is set conditional to 0 if len(networkPaths) == 0 { networkPaths = nil } { - _numItems := uint16(utils.Max(noOfNetworkPaths, 0)) + _numItems := uint16(max(noOfNetworkPaths, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/Node.go b/plc4go/protocols/opcua/readwrite/model/Node.go deleted file mode 100644 index 663f87ccb13..00000000000 --- a/plc4go/protocols/opcua/readwrite/model/Node.go +++ /dev/null @@ -1,508 +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 - * - * https://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 ( - "context" - "fmt" - "github.com/apache/plc4x/plc4go/spi/utils" - "github.com/pkg/errors" - "github.com/rs/zerolog" -) - -// Code generated by code-generation. DO NOT EDIT. - -// Node is the corresponding interface of Node -type Node interface { - fmt.Stringer - utils.LengthAware - utils.Serializable - ExtensionObjectDefinition - // GetNodeId returns NodeId (property field) - GetNodeId() NodeId - // GetNodeClass returns NodeClass (property field) - GetNodeClass() NodeClass - // GetBrowseName returns BrowseName (property field) - GetBrowseName() QualifiedName - // GetDisplayName returns DisplayName (property field) - GetDisplayName() LocalizedText - // GetDescription returns Description (property field) - GetDescription() LocalizedText - // GetWriteMask returns WriteMask (property field) - GetWriteMask() uint32 - // GetUserWriteMask returns UserWriteMask (property field) - GetUserWriteMask() uint32 - // GetNoOfReferences returns NoOfReferences (property field) - GetNoOfReferences() int32 - // GetReferences returns References (property field) - GetReferences() []ExtensionObjectDefinition -} - -// NodeExactly can be used when we want exactly this type and not a type which fulfills Node. -// This is useful for switch cases. -type NodeExactly interface { - Node - isNode() bool -} - -// _Node is the data-structure of this message -type _Node struct { - *_ExtensionObjectDefinition - NodeId NodeId - NodeClass NodeClass - BrowseName QualifiedName - DisplayName LocalizedText - Description LocalizedText - WriteMask uint32 - UserWriteMask uint32 - NoOfReferences int32 - References []ExtensionObjectDefinition -} - -/////////////////////////////////////////////////////////// -/////////////////////////////////////////////////////////// -/////////////////////// Accessors for discriminator values. -/////////////////////// - -func (m *_Node) GetIdentifier() string { - return "260" -} - -/////////////////////// -/////////////////////// -/////////////////////////////////////////////////////////// -/////////////////////////////////////////////////////////// - -func (m *_Node) InitializeParent(parent ExtensionObjectDefinition) {} - -func (m *_Node) GetParent() ExtensionObjectDefinition { - return m._ExtensionObjectDefinition -} - -/////////////////////////////////////////////////////////// -/////////////////////////////////////////////////////////// -/////////////////////// Accessors for property fields. -/////////////////////// - -func (m *_Node) GetNodeId() NodeId { - return m.NodeId -} - -func (m *_Node) GetNodeClass() NodeClass { - return m.NodeClass -} - -func (m *_Node) GetBrowseName() QualifiedName { - return m.BrowseName -} - -func (m *_Node) GetDisplayName() LocalizedText { - return m.DisplayName -} - -func (m *_Node) GetDescription() LocalizedText { - return m.Description -} - -func (m *_Node) GetWriteMask() uint32 { - return m.WriteMask -} - -func (m *_Node) GetUserWriteMask() uint32 { - return m.UserWriteMask -} - -func (m *_Node) GetNoOfReferences() int32 { - return m.NoOfReferences -} - -func (m *_Node) GetReferences() []ExtensionObjectDefinition { - return m.References -} - -/////////////////////// -/////////////////////// -/////////////////////////////////////////////////////////// -/////////////////////////////////////////////////////////// - -// NewNode factory function for _Node -func NewNode(nodeId NodeId, nodeClass NodeClass, browseName QualifiedName, displayName LocalizedText, description LocalizedText, writeMask uint32, userWriteMask uint32, noOfReferences int32, references []ExtensionObjectDefinition) *_Node { - _result := &_Node{ - NodeId: nodeId, - NodeClass: nodeClass, - BrowseName: browseName, - DisplayName: displayName, - Description: description, - WriteMask: writeMask, - UserWriteMask: userWriteMask, - NoOfReferences: noOfReferences, - References: references, - _ExtensionObjectDefinition: NewExtensionObjectDefinition(), - } - _result._ExtensionObjectDefinition._ExtensionObjectDefinitionChildRequirements = _result - return _result -} - -// Deprecated: use the interface for direct cast -func CastNode(structType any) Node { - if casted, ok := structType.(Node); ok { - return casted - } - if casted, ok := structType.(*Node); ok { - return *casted - } - return nil -} - -func (m *_Node) GetTypeName() string { - return "Node" -} - -func (m *_Node) GetLengthInBits(ctx context.Context) uint16 { - lengthInBits := uint16(m.GetParentLengthInBits(ctx)) - - // Simple field (nodeId) - lengthInBits += m.NodeId.GetLengthInBits(ctx) - - // Simple field (nodeClass) - lengthInBits += 32 - - // Simple field (browseName) - lengthInBits += m.BrowseName.GetLengthInBits(ctx) - - // Simple field (displayName) - lengthInBits += m.DisplayName.GetLengthInBits(ctx) - - // Simple field (description) - lengthInBits += m.Description.GetLengthInBits(ctx) - - // Simple field (writeMask) - lengthInBits += 32 - - // Simple field (userWriteMask) - lengthInBits += 32 - - // Simple field (noOfReferences) - lengthInBits += 32 - - // Array field - if len(m.References) > 0 { - for _curItem, element := range m.References { - arrayCtx := utils.CreateArrayContext(ctx, len(m.References), _curItem) - _ = arrayCtx - _ = _curItem - lengthInBits += element.(interface{ GetLengthInBits(context.Context) uint16 }).GetLengthInBits(arrayCtx) - } - } - - return lengthInBits -} - -func (m *_Node) GetLengthInBytes(ctx context.Context) uint16 { - return m.GetLengthInBits(ctx) / 8 -} - -func NodeParse(ctx context.Context, theBytes []byte, identifier string) (Node, error) { - return NodeParseWithBuffer(ctx, utils.NewReadBufferByteBased(theBytes), identifier) -} - -func NodeParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, identifier string) (Node, error) { - positionAware := readBuffer - _ = positionAware - log := zerolog.Ctx(ctx) - _ = log - if pullErr := readBuffer.PullContext("Node"); pullErr != nil { - return nil, errors.Wrap(pullErr, "Error pulling for Node") - } - currentPos := positionAware.GetPos() - _ = currentPos - - // Simple Field (nodeId) - if pullErr := readBuffer.PullContext("nodeId"); pullErr != nil { - return nil, errors.Wrap(pullErr, "Error pulling for nodeId") - } - _nodeId, _nodeIdErr := NodeIdParseWithBuffer(ctx, readBuffer) - if _nodeIdErr != nil { - return nil, errors.Wrap(_nodeIdErr, "Error parsing 'nodeId' field of Node") - } - nodeId := _nodeId.(NodeId) - if closeErr := readBuffer.CloseContext("nodeId"); closeErr != nil { - return nil, errors.Wrap(closeErr, "Error closing for nodeId") - } - - // Simple Field (nodeClass) - if pullErr := readBuffer.PullContext("nodeClass"); pullErr != nil { - return nil, errors.Wrap(pullErr, "Error pulling for nodeClass") - } - _nodeClass, _nodeClassErr := NodeClassParseWithBuffer(ctx, readBuffer) - if _nodeClassErr != nil { - return nil, errors.Wrap(_nodeClassErr, "Error parsing 'nodeClass' field of Node") - } - nodeClass := _nodeClass - if closeErr := readBuffer.CloseContext("nodeClass"); closeErr != nil { - return nil, errors.Wrap(closeErr, "Error closing for nodeClass") - } - - // Simple Field (browseName) - if pullErr := readBuffer.PullContext("browseName"); pullErr != nil { - return nil, errors.Wrap(pullErr, "Error pulling for browseName") - } - _browseName, _browseNameErr := QualifiedNameParseWithBuffer(ctx, readBuffer) - if _browseNameErr != nil { - return nil, errors.Wrap(_browseNameErr, "Error parsing 'browseName' field of Node") - } - browseName := _browseName.(QualifiedName) - if closeErr := readBuffer.CloseContext("browseName"); closeErr != nil { - return nil, errors.Wrap(closeErr, "Error closing for browseName") - } - - // Simple Field (displayName) - if pullErr := readBuffer.PullContext("displayName"); pullErr != nil { - return nil, errors.Wrap(pullErr, "Error pulling for displayName") - } - _displayName, _displayNameErr := LocalizedTextParseWithBuffer(ctx, readBuffer) - if _displayNameErr != nil { - return nil, errors.Wrap(_displayNameErr, "Error parsing 'displayName' field of Node") - } - displayName := _displayName.(LocalizedText) - if closeErr := readBuffer.CloseContext("displayName"); closeErr != nil { - return nil, errors.Wrap(closeErr, "Error closing for displayName") - } - - // Simple Field (description) - if pullErr := readBuffer.PullContext("description"); pullErr != nil { - return nil, errors.Wrap(pullErr, "Error pulling for description") - } - _description, _descriptionErr := LocalizedTextParseWithBuffer(ctx, readBuffer) - if _descriptionErr != nil { - return nil, errors.Wrap(_descriptionErr, "Error parsing 'description' field of Node") - } - description := _description.(LocalizedText) - if closeErr := readBuffer.CloseContext("description"); closeErr != nil { - return nil, errors.Wrap(closeErr, "Error closing for description") - } - - // Simple Field (writeMask) - _writeMask, _writeMaskErr := readBuffer.ReadUint32("writeMask", 32) - if _writeMaskErr != nil { - return nil, errors.Wrap(_writeMaskErr, "Error parsing 'writeMask' field of Node") - } - writeMask := _writeMask - - // Simple Field (userWriteMask) - _userWriteMask, _userWriteMaskErr := readBuffer.ReadUint32("userWriteMask", 32) - if _userWriteMaskErr != nil { - return nil, errors.Wrap(_userWriteMaskErr, "Error parsing 'userWriteMask' field of Node") - } - userWriteMask := _userWriteMask - - // Simple Field (noOfReferences) - _noOfReferences, _noOfReferencesErr := readBuffer.ReadInt32("noOfReferences", 32) - if _noOfReferencesErr != nil { - return nil, errors.Wrap(_noOfReferencesErr, "Error parsing 'noOfReferences' field of Node") - } - noOfReferences := _noOfReferences - - // Array field (references) - if pullErr := readBuffer.PullContext("references", utils.WithRenderAsList(true)); pullErr != nil { - return nil, errors.Wrap(pullErr, "Error pulling for references") - } - // Count array - references := make([]ExtensionObjectDefinition, utils.Max(noOfReferences, 0)) - // This happens when the size is set conditional to 0 - if len(references) == 0 { - references = nil - } - { - _numItems := uint16(utils.Max(noOfReferences, 0)) - for _curItem := uint16(0); _curItem < _numItems; _curItem++ { - arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) - _ = arrayCtx - _ = _curItem - _item, _err := ExtensionObjectDefinitionParseWithBuffer(arrayCtx, readBuffer, "287") - if _err != nil { - return nil, errors.Wrap(_err, "Error parsing 'references' field of Node") - } - references[_curItem] = _item.(ExtensionObjectDefinition) - } - } - if closeErr := readBuffer.CloseContext("references", utils.WithRenderAsList(true)); closeErr != nil { - return nil, errors.Wrap(closeErr, "Error closing for references") - } - - if closeErr := readBuffer.CloseContext("Node"); closeErr != nil { - return nil, errors.Wrap(closeErr, "Error closing for Node") - } - - // Create a partially initialized instance - _child := &_Node{ - _ExtensionObjectDefinition: &_ExtensionObjectDefinition{}, - NodeId: nodeId, - NodeClass: nodeClass, - BrowseName: browseName, - DisplayName: displayName, - Description: description, - WriteMask: writeMask, - UserWriteMask: userWriteMask, - NoOfReferences: noOfReferences, - References: references, - } - _child._ExtensionObjectDefinition._ExtensionObjectDefinitionChildRequirements = _child - return _child, nil -} - -func (m *_Node) Serialize() ([]byte, error) { - wb := utils.NewWriteBufferByteBased(utils.WithInitialSizeForByteBasedBuffer(int(m.GetLengthInBytes(context.Background())))) - if err := m.SerializeWithWriteBuffer(context.Background(), wb); err != nil { - return nil, err - } - return wb.GetBytes(), nil -} - -func (m *_Node) SerializeWithWriteBuffer(ctx context.Context, writeBuffer utils.WriteBuffer) error { - positionAware := writeBuffer - _ = positionAware - log := zerolog.Ctx(ctx) - _ = log - ser := func() error { - if pushErr := writeBuffer.PushContext("Node"); pushErr != nil { - return errors.Wrap(pushErr, "Error pushing for Node") - } - - // Simple Field (nodeId) - if pushErr := writeBuffer.PushContext("nodeId"); pushErr != nil { - return errors.Wrap(pushErr, "Error pushing for nodeId") - } - _nodeIdErr := writeBuffer.WriteSerializable(ctx, m.GetNodeId()) - if popErr := writeBuffer.PopContext("nodeId"); popErr != nil { - return errors.Wrap(popErr, "Error popping for nodeId") - } - if _nodeIdErr != nil { - return errors.Wrap(_nodeIdErr, "Error serializing 'nodeId' field") - } - - // Simple Field (nodeClass) - if pushErr := writeBuffer.PushContext("nodeClass"); pushErr != nil { - return errors.Wrap(pushErr, "Error pushing for nodeClass") - } - _nodeClassErr := writeBuffer.WriteSerializable(ctx, m.GetNodeClass()) - if popErr := writeBuffer.PopContext("nodeClass"); popErr != nil { - return errors.Wrap(popErr, "Error popping for nodeClass") - } - if _nodeClassErr != nil { - return errors.Wrap(_nodeClassErr, "Error serializing 'nodeClass' field") - } - - // Simple Field (browseName) - if pushErr := writeBuffer.PushContext("browseName"); pushErr != nil { - return errors.Wrap(pushErr, "Error pushing for browseName") - } - _browseNameErr := writeBuffer.WriteSerializable(ctx, m.GetBrowseName()) - if popErr := writeBuffer.PopContext("browseName"); popErr != nil { - return errors.Wrap(popErr, "Error popping for browseName") - } - if _browseNameErr != nil { - return errors.Wrap(_browseNameErr, "Error serializing 'browseName' field") - } - - // Simple Field (displayName) - if pushErr := writeBuffer.PushContext("displayName"); pushErr != nil { - return errors.Wrap(pushErr, "Error pushing for displayName") - } - _displayNameErr := writeBuffer.WriteSerializable(ctx, m.GetDisplayName()) - if popErr := writeBuffer.PopContext("displayName"); popErr != nil { - return errors.Wrap(popErr, "Error popping for displayName") - } - if _displayNameErr != nil { - return errors.Wrap(_displayNameErr, "Error serializing 'displayName' field") - } - - // Simple Field (description) - if pushErr := writeBuffer.PushContext("description"); pushErr != nil { - return errors.Wrap(pushErr, "Error pushing for description") - } - _descriptionErr := writeBuffer.WriteSerializable(ctx, m.GetDescription()) - if popErr := writeBuffer.PopContext("description"); popErr != nil { - return errors.Wrap(popErr, "Error popping for description") - } - if _descriptionErr != nil { - return errors.Wrap(_descriptionErr, "Error serializing 'description' field") - } - - // Simple Field (writeMask) - writeMask := uint32(m.GetWriteMask()) - _writeMaskErr := writeBuffer.WriteUint32("writeMask", 32, (writeMask)) - if _writeMaskErr != nil { - return errors.Wrap(_writeMaskErr, "Error serializing 'writeMask' field") - } - - // Simple Field (userWriteMask) - userWriteMask := uint32(m.GetUserWriteMask()) - _userWriteMaskErr := writeBuffer.WriteUint32("userWriteMask", 32, (userWriteMask)) - if _userWriteMaskErr != nil { - return errors.Wrap(_userWriteMaskErr, "Error serializing 'userWriteMask' field") - } - - // Simple Field (noOfReferences) - noOfReferences := int32(m.GetNoOfReferences()) - _noOfReferencesErr := writeBuffer.WriteInt32("noOfReferences", 32, (noOfReferences)) - if _noOfReferencesErr != nil { - return errors.Wrap(_noOfReferencesErr, "Error serializing 'noOfReferences' field") - } - - // Array Field (references) - if pushErr := writeBuffer.PushContext("references", utils.WithRenderAsList(true)); pushErr != nil { - return errors.Wrap(pushErr, "Error pushing for references") - } - for _curItem, _element := range m.GetReferences() { - _ = _curItem - arrayCtx := utils.CreateArrayContext(ctx, len(m.GetReferences()), _curItem) - _ = arrayCtx - _elementErr := writeBuffer.WriteSerializable(arrayCtx, _element) - if _elementErr != nil { - return errors.Wrap(_elementErr, "Error serializing 'references' field") - } - } - if popErr := writeBuffer.PopContext("references", utils.WithRenderAsList(true)); popErr != nil { - return errors.Wrap(popErr, "Error popping for references") - } - - if popErr := writeBuffer.PopContext("Node"); popErr != nil { - return errors.Wrap(popErr, "Error popping for Node") - } - return nil - } - return m.SerializeParent(ctx, writeBuffer, m, ser) -} - -func (m *_Node) isNode() bool { - return true -} - -func (m *_Node) String() string { - if m == nil { - return "" - } - writeBuffer := utils.NewWriteBufferBoxBasedWithOptions(true, true) - if err := writeBuffer.WriteSerializable(context.Background(), m); err != nil { - return err.Error() - } - return writeBuffer.GetBox().String() -} diff --git a/plc4go/protocols/opcua/readwrite/model/NodeReference.go b/plc4go/protocols/opcua/readwrite/model/NodeReference.go index 0aef5b80e36..fd26de9e4af 100644 --- a/plc4go/protocols/opcua/readwrite/model/NodeReference.go +++ b/plc4go/protocols/opcua/readwrite/model/NodeReference.go @@ -257,13 +257,13 @@ func NodeReferenceParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuff return nil, errors.Wrap(pullErr, "Error pulling for referencedNodeIds") } // Count array - referencedNodeIds := make([]NodeId, utils.Max(noOfReferencedNodeIds, 0)) + referencedNodeIds := make([]NodeId, max(noOfReferencedNodeIds, 0)) // This happens when the size is set conditional to 0 if len(referencedNodeIds) == 0 { referencedNodeIds = nil } { - _numItems := uint16(utils.Max(noOfReferencedNodeIds, 0)) + _numItems := uint16(max(noOfReferencedNodeIds, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/NodeTypeDescription.go b/plc4go/protocols/opcua/readwrite/model/NodeTypeDescription.go index 21741c77b10..20ad61b3c51 100644 --- a/plc4go/protocols/opcua/readwrite/model/NodeTypeDescription.go +++ b/plc4go/protocols/opcua/readwrite/model/NodeTypeDescription.go @@ -233,13 +233,13 @@ func NodeTypeDescriptionParseWithBuffer(ctx context.Context, readBuffer utils.Re return nil, errors.Wrap(pullErr, "Error pulling for dataToReturn") } // Count array - dataToReturn := make([]ExtensionObjectDefinition, utils.Max(noOfDataToReturn, 0)) + dataToReturn := make([]ExtensionObjectDefinition, max(noOfDataToReturn, 0)) // This happens when the size is set conditional to 0 if len(dataToReturn) == 0 { dataToReturn = nil } { - _numItems := uint16(utils.Max(noOfDataToReturn, 0)) + _numItems := uint16(max(noOfDataToReturn, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/NotificationMessage.go b/plc4go/protocols/opcua/readwrite/model/NotificationMessage.go index 32037994691..5d230562d15 100644 --- a/plc4go/protocols/opcua/readwrite/model/NotificationMessage.go +++ b/plc4go/protocols/opcua/readwrite/model/NotificationMessage.go @@ -205,13 +205,13 @@ func NotificationMessageParseWithBuffer(ctx context.Context, readBuffer utils.Re return nil, errors.Wrap(pullErr, "Error pulling for notificationData") } // Count array - notificationData := make([]ExtensionObject, utils.Max(noOfNotificationData, 0)) + notificationData := make([]ExtensionObject, max(noOfNotificationData, 0)) // This happens when the size is set conditional to 0 if len(notificationData) == 0 { notificationData = nil } { - _numItems := uint16(utils.Max(noOfNotificationData, 0)) + _numItems := uint16(max(noOfNotificationData, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/ParsingResult.go b/plc4go/protocols/opcua/readwrite/model/ParsingResult.go index 032e96f8b64..a660d696499 100644 --- a/plc4go/protocols/opcua/readwrite/model/ParsingResult.go +++ b/plc4go/protocols/opcua/readwrite/model/ParsingResult.go @@ -222,13 +222,13 @@ func ParsingResultParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuff return nil, errors.Wrap(pullErr, "Error pulling for dataStatusCodes") } // Count array - dataStatusCodes := make([]StatusCode, utils.Max(noOfDataStatusCodes, 0)) + dataStatusCodes := make([]StatusCode, max(noOfDataStatusCodes, 0)) // This happens when the size is set conditional to 0 if len(dataStatusCodes) == 0 { dataStatusCodes = nil } { - _numItems := uint16(utils.Max(noOfDataStatusCodes, 0)) + _numItems := uint16(max(noOfDataStatusCodes, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -256,13 +256,13 @@ func ParsingResultParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuff return nil, errors.Wrap(pullErr, "Error pulling for dataDiagnosticInfos") } // Count array - dataDiagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDataDiagnosticInfos, 0)) + dataDiagnosticInfos := make([]DiagnosticInfo, max(noOfDataDiagnosticInfos, 0)) // This happens when the size is set conditional to 0 if len(dataDiagnosticInfos) == 0 { dataDiagnosticInfos = nil } { - _numItems := uint16(utils.Max(noOfDataDiagnosticInfos, 0)) + _numItems := uint16(max(noOfDataDiagnosticInfos, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/ProgramDiagnostic2DataType.go b/plc4go/protocols/opcua/readwrite/model/ProgramDiagnostic2DataType.go index b10c23dc60f..6272aba9210 100644 --- a/plc4go/protocols/opcua/readwrite/model/ProgramDiagnostic2DataType.go +++ b/plc4go/protocols/opcua/readwrite/model/ProgramDiagnostic2DataType.go @@ -410,13 +410,13 @@ func ProgramDiagnostic2DataTypeParseWithBuffer(ctx context.Context, readBuffer u return nil, errors.Wrap(pullErr, "Error pulling for lastMethodInputArguments") } // Count array - lastMethodInputArguments := make([]ExtensionObjectDefinition, utils.Max(noOfLastMethodInputArguments, 0)) + lastMethodInputArguments := make([]ExtensionObjectDefinition, max(noOfLastMethodInputArguments, 0)) // This happens when the size is set conditional to 0 if len(lastMethodInputArguments) == 0 { lastMethodInputArguments = nil } { - _numItems := uint16(utils.Max(noOfLastMethodInputArguments, 0)) + _numItems := uint16(max(noOfLastMethodInputArguments, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -444,13 +444,13 @@ func ProgramDiagnostic2DataTypeParseWithBuffer(ctx context.Context, readBuffer u return nil, errors.Wrap(pullErr, "Error pulling for lastMethodOutputArguments") } // Count array - lastMethodOutputArguments := make([]ExtensionObjectDefinition, utils.Max(noOfLastMethodOutputArguments, 0)) + lastMethodOutputArguments := make([]ExtensionObjectDefinition, max(noOfLastMethodOutputArguments, 0)) // This happens when the size is set conditional to 0 if len(lastMethodOutputArguments) == 0 { lastMethodOutputArguments = nil } { - _numItems := uint16(utils.Max(noOfLastMethodOutputArguments, 0)) + _numItems := uint16(max(noOfLastMethodOutputArguments, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -478,13 +478,13 @@ func ProgramDiagnostic2DataTypeParseWithBuffer(ctx context.Context, readBuffer u return nil, errors.Wrap(pullErr, "Error pulling for lastMethodInputValues") } // Count array - lastMethodInputValues := make([]Variant, utils.Max(noOfLastMethodInputValues, 0)) + lastMethodInputValues := make([]Variant, max(noOfLastMethodInputValues, 0)) // This happens when the size is set conditional to 0 if len(lastMethodInputValues) == 0 { lastMethodInputValues = nil } { - _numItems := uint16(utils.Max(noOfLastMethodInputValues, 0)) + _numItems := uint16(max(noOfLastMethodInputValues, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -512,13 +512,13 @@ func ProgramDiagnostic2DataTypeParseWithBuffer(ctx context.Context, readBuffer u return nil, errors.Wrap(pullErr, "Error pulling for lastMethodOutputValues") } // Count array - lastMethodOutputValues := make([]Variant, utils.Max(noOfLastMethodOutputValues, 0)) + lastMethodOutputValues := make([]Variant, max(noOfLastMethodOutputValues, 0)) // This happens when the size is set conditional to 0 if len(lastMethodOutputValues) == 0 { lastMethodOutputValues = nil } { - _numItems := uint16(utils.Max(noOfLastMethodOutputValues, 0)) + _numItems := uint16(max(noOfLastMethodOutputValues, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/ProgramDiagnosticDataType.go b/plc4go/protocols/opcua/readwrite/model/ProgramDiagnosticDataType.go index f9cc6890710..b461038e4b5 100644 --- a/plc4go/protocols/opcua/readwrite/model/ProgramDiagnosticDataType.go +++ b/plc4go/protocols/opcua/readwrite/model/ProgramDiagnosticDataType.go @@ -352,13 +352,13 @@ func ProgramDiagnosticDataTypeParseWithBuffer(ctx context.Context, readBuffer ut return nil, errors.Wrap(pullErr, "Error pulling for lastMethodInputArguments") } // Count array - lastMethodInputArguments := make([]ExtensionObjectDefinition, utils.Max(noOfLastMethodInputArguments, 0)) + lastMethodInputArguments := make([]ExtensionObjectDefinition, max(noOfLastMethodInputArguments, 0)) // This happens when the size is set conditional to 0 if len(lastMethodInputArguments) == 0 { lastMethodInputArguments = nil } { - _numItems := uint16(utils.Max(noOfLastMethodInputArguments, 0)) + _numItems := uint16(max(noOfLastMethodInputArguments, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -386,13 +386,13 @@ func ProgramDiagnosticDataTypeParseWithBuffer(ctx context.Context, readBuffer ut return nil, errors.Wrap(pullErr, "Error pulling for lastMethodOutputArguments") } // Count array - lastMethodOutputArguments := make([]ExtensionObjectDefinition, utils.Max(noOfLastMethodOutputArguments, 0)) + lastMethodOutputArguments := make([]ExtensionObjectDefinition, max(noOfLastMethodOutputArguments, 0)) // This happens when the size is set conditional to 0 if len(lastMethodOutputArguments) == 0 { lastMethodOutputArguments = nil } { - _numItems := uint16(utils.Max(noOfLastMethodOutputArguments, 0)) + _numItems := uint16(max(noOfLastMethodOutputArguments, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/PubSubConfigurationDataType.go b/plc4go/protocols/opcua/readwrite/model/PubSubConfigurationDataType.go index 7ee13b5a787..15671fdd93d 100644 --- a/plc4go/protocols/opcua/readwrite/model/PubSubConfigurationDataType.go +++ b/plc4go/protocols/opcua/readwrite/model/PubSubConfigurationDataType.go @@ -214,13 +214,13 @@ func PubSubConfigurationDataTypeParseWithBuffer(ctx context.Context, readBuffer return nil, errors.Wrap(pullErr, "Error pulling for publishedDataSets") } // Count array - publishedDataSets := make([]ExtensionObjectDefinition, utils.Max(noOfPublishedDataSets, 0)) + publishedDataSets := make([]ExtensionObjectDefinition, max(noOfPublishedDataSets, 0)) // This happens when the size is set conditional to 0 if len(publishedDataSets) == 0 { publishedDataSets = nil } { - _numItems := uint16(utils.Max(noOfPublishedDataSets, 0)) + _numItems := uint16(max(noOfPublishedDataSets, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -248,13 +248,13 @@ func PubSubConfigurationDataTypeParseWithBuffer(ctx context.Context, readBuffer return nil, errors.Wrap(pullErr, "Error pulling for connections") } // Count array - connections := make([]ExtensionObjectDefinition, utils.Max(noOfConnections, 0)) + connections := make([]ExtensionObjectDefinition, max(noOfConnections, 0)) // This happens when the size is set conditional to 0 if len(connections) == 0 { connections = nil } { - _numItems := uint16(utils.Max(noOfConnections, 0)) + _numItems := uint16(max(noOfConnections, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/PubSubConnectionDataType.go b/plc4go/protocols/opcua/readwrite/model/PubSubConnectionDataType.go index 159d6d321ad..57cc22e564f 100644 --- a/plc4go/protocols/opcua/readwrite/model/PubSubConnectionDataType.go +++ b/plc4go/protocols/opcua/readwrite/model/PubSubConnectionDataType.go @@ -374,13 +374,13 @@ func PubSubConnectionDataTypeParseWithBuffer(ctx context.Context, readBuffer uti return nil, errors.Wrap(pullErr, "Error pulling for connectionProperties") } // Count array - connectionProperties := make([]ExtensionObjectDefinition, utils.Max(noOfConnectionProperties, 0)) + connectionProperties := make([]ExtensionObjectDefinition, max(noOfConnectionProperties, 0)) // This happens when the size is set conditional to 0 if len(connectionProperties) == 0 { connectionProperties = nil } { - _numItems := uint16(utils.Max(noOfConnectionProperties, 0)) + _numItems := uint16(max(noOfConnectionProperties, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -421,13 +421,13 @@ func PubSubConnectionDataTypeParseWithBuffer(ctx context.Context, readBuffer uti return nil, errors.Wrap(pullErr, "Error pulling for writerGroups") } // Count array - writerGroups := make([]PubSubGroupDataType, utils.Max(noOfWriterGroups, 0)) + writerGroups := make([]PubSubGroupDataType, max(noOfWriterGroups, 0)) // This happens when the size is set conditional to 0 if len(writerGroups) == 0 { writerGroups = nil } { - _numItems := uint16(utils.Max(noOfWriterGroups, 0)) + _numItems := uint16(max(noOfWriterGroups, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -455,13 +455,13 @@ func PubSubConnectionDataTypeParseWithBuffer(ctx context.Context, readBuffer uti return nil, errors.Wrap(pullErr, "Error pulling for readerGroups") } // Count array - readerGroups := make([]PubSubGroupDataType, utils.Max(noOfReaderGroups, 0)) + readerGroups := make([]PubSubGroupDataType, max(noOfReaderGroups, 0)) // This happens when the size is set conditional to 0 if len(readerGroups) == 0 { readerGroups = nil } { - _numItems := uint16(utils.Max(noOfReaderGroups, 0)) + _numItems := uint16(max(noOfReaderGroups, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/PubSubGroupDataType.go b/plc4go/protocols/opcua/readwrite/model/PubSubGroupDataType.go index fd6afd19603..83737ed715f 100644 --- a/plc4go/protocols/opcua/readwrite/model/PubSubGroupDataType.go +++ b/plc4go/protocols/opcua/readwrite/model/PubSubGroupDataType.go @@ -321,13 +321,13 @@ func PubSubGroupDataTypeParseWithBuffer(ctx context.Context, readBuffer utils.Re return nil, errors.Wrap(pullErr, "Error pulling for securityKeyServices") } // Count array - securityKeyServices := make([]ExtensionObjectDefinition, utils.Max(noOfSecurityKeyServices, 0)) + securityKeyServices := make([]ExtensionObjectDefinition, max(noOfSecurityKeyServices, 0)) // This happens when the size is set conditional to 0 if len(securityKeyServices) == 0 { securityKeyServices = nil } { - _numItems := uint16(utils.Max(noOfSecurityKeyServices, 0)) + _numItems := uint16(max(noOfSecurityKeyServices, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -362,13 +362,13 @@ func PubSubGroupDataTypeParseWithBuffer(ctx context.Context, readBuffer utils.Re return nil, errors.Wrap(pullErr, "Error pulling for groupProperties") } // Count array - groupProperties := make([]ExtensionObjectDefinition, utils.Max(noOfGroupProperties, 0)) + groupProperties := make([]ExtensionObjectDefinition, max(noOfGroupProperties, 0)) // This happens when the size is set conditional to 0 if len(groupProperties) == 0 { groupProperties = nil } { - _numItems := uint16(utils.Max(noOfGroupProperties, 0)) + _numItems := uint16(max(noOfGroupProperties, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/PubSubKeyPushTargetDataType.go b/plc4go/protocols/opcua/readwrite/model/PubSubKeyPushTargetDataType.go index 7871f6737bb..34fb495478f 100644 --- a/plc4go/protocols/opcua/readwrite/model/PubSubKeyPushTargetDataType.go +++ b/plc4go/protocols/opcua/readwrite/model/PubSubKeyPushTargetDataType.go @@ -306,13 +306,13 @@ func PubSubKeyPushTargetDataTypeParseWithBuffer(ctx context.Context, readBuffer return nil, errors.Wrap(pullErr, "Error pulling for pushTargetFolder") } // Count array - pushTargetFolder := make([]PascalString, utils.Max(noOfPushTargetFolder, 0)) + pushTargetFolder := make([]PascalString, max(noOfPushTargetFolder, 0)) // This happens when the size is set conditional to 0 if len(pushTargetFolder) == 0 { pushTargetFolder = nil } { - _numItems := uint16(utils.Max(noOfPushTargetFolder, 0)) + _numItems := uint16(max(noOfPushTargetFolder, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -393,13 +393,13 @@ func PubSubKeyPushTargetDataTypeParseWithBuffer(ctx context.Context, readBuffer return nil, errors.Wrap(pullErr, "Error pulling for pushTargetProperties") } // Count array - pushTargetProperties := make([]ExtensionObjectDefinition, utils.Max(noOfPushTargetProperties, 0)) + pushTargetProperties := make([]ExtensionObjectDefinition, max(noOfPushTargetProperties, 0)) // This happens when the size is set conditional to 0 if len(pushTargetProperties) == 0 { pushTargetProperties = nil } { - _numItems := uint16(utils.Max(noOfPushTargetProperties, 0)) + _numItems := uint16(max(noOfPushTargetProperties, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -427,13 +427,13 @@ func PubSubKeyPushTargetDataTypeParseWithBuffer(ctx context.Context, readBuffer return nil, errors.Wrap(pullErr, "Error pulling for securityGroups") } // Count array - securityGroups := make([]PascalString, utils.Max(noOfSecurityGroups, 0)) + securityGroups := make([]PascalString, max(noOfSecurityGroups, 0)) // This happens when the size is set conditional to 0 if len(securityGroups) == 0 { securityGroups = nil } { - _numItems := uint16(utils.Max(noOfSecurityGroups, 0)) + _numItems := uint16(max(noOfSecurityGroups, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/PublishRequest.go b/plc4go/protocols/opcua/readwrite/model/PublishRequest.go index ffd3492a076..0068cc79b03 100644 --- a/plc4go/protocols/opcua/readwrite/model/PublishRequest.go +++ b/plc4go/protocols/opcua/readwrite/model/PublishRequest.go @@ -193,13 +193,13 @@ func PublishRequestParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuf return nil, errors.Wrap(pullErr, "Error pulling for subscriptionAcknowledgements") } // Count array - subscriptionAcknowledgements := make([]ExtensionObjectDefinition, utils.Max(noOfSubscriptionAcknowledgements, 0)) + subscriptionAcknowledgements := make([]ExtensionObjectDefinition, max(noOfSubscriptionAcknowledgements, 0)) // This happens when the size is set conditional to 0 if len(subscriptionAcknowledgements) == 0 { subscriptionAcknowledgements = nil } { - _numItems := uint16(utils.Max(noOfSubscriptionAcknowledgements, 0)) + _numItems := uint16(max(noOfSubscriptionAcknowledgements, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/PublishResponse.go b/plc4go/protocols/opcua/readwrite/model/PublishResponse.go index 502f94d4fe6..02592b4be02 100644 --- a/plc4go/protocols/opcua/readwrite/model/PublishResponse.go +++ b/plc4go/protocols/opcua/readwrite/model/PublishResponse.go @@ -291,13 +291,13 @@ func PublishResponseParseWithBuffer(ctx context.Context, readBuffer utils.ReadBu return nil, errors.Wrap(pullErr, "Error pulling for availableSequenceNumbers") } // Count array - availableSequenceNumbers := make([]uint32, utils.Max(noOfAvailableSequenceNumbers, 0)) + availableSequenceNumbers := make([]uint32, max(noOfAvailableSequenceNumbers, 0)) // This happens when the size is set conditional to 0 if len(availableSequenceNumbers) == 0 { availableSequenceNumbers = nil } { - _numItems := uint16(utils.Max(noOfAvailableSequenceNumbers, 0)) + _numItems := uint16(max(noOfAvailableSequenceNumbers, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -362,13 +362,13 @@ func PublishResponseParseWithBuffer(ctx context.Context, readBuffer utils.ReadBu return nil, errors.Wrap(pullErr, "Error pulling for results") } // Count array - results := make([]StatusCode, utils.Max(noOfResults, 0)) + results := make([]StatusCode, max(noOfResults, 0)) // This happens when the size is set conditional to 0 if len(results) == 0 { results = nil } { - _numItems := uint16(utils.Max(noOfResults, 0)) + _numItems := uint16(max(noOfResults, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -396,13 +396,13 @@ func PublishResponseParseWithBuffer(ctx context.Context, readBuffer utils.ReadBu return nil, errors.Wrap(pullErr, "Error pulling for diagnosticInfos") } // Count array - diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0)) + diagnosticInfos := make([]DiagnosticInfo, max(noOfDiagnosticInfos, 0)) // This happens when the size is set conditional to 0 if len(diagnosticInfos) == 0 { diagnosticInfos = nil } { - _numItems := uint16(utils.Max(noOfDiagnosticInfos, 0)) + _numItems := uint16(max(noOfDiagnosticInfos, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/PublishedVariableDataType.go b/plc4go/protocols/opcua/readwrite/model/PublishedVariableDataType.go index 83f6b17ea52..def1b578980 100644 --- a/plc4go/protocols/opcua/readwrite/model/PublishedVariableDataType.go +++ b/plc4go/protocols/opcua/readwrite/model/PublishedVariableDataType.go @@ -313,13 +313,13 @@ func PublishedVariableDataTypeParseWithBuffer(ctx context.Context, readBuffer ut return nil, errors.Wrap(pullErr, "Error pulling for metaDataProperties") } // Count array - metaDataProperties := make([]QualifiedName, utils.Max(noOfMetaDataProperties, 0)) + metaDataProperties := make([]QualifiedName, max(noOfMetaDataProperties, 0)) // This happens when the size is set conditional to 0 if len(metaDataProperties) == 0 { metaDataProperties = nil } { - _numItems := uint16(utils.Max(noOfMetaDataProperties, 0)) + _numItems := uint16(max(noOfMetaDataProperties, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/QueryDataSet.go b/plc4go/protocols/opcua/readwrite/model/QueryDataSet.go index 30db537ef65..118f391f05b 100644 --- a/plc4go/protocols/opcua/readwrite/model/QueryDataSet.go +++ b/plc4go/protocols/opcua/readwrite/model/QueryDataSet.go @@ -217,13 +217,13 @@ func QueryDataSetParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffe return nil, errors.Wrap(pullErr, "Error pulling for values") } // Count array - values := make([]Variant, utils.Max(noOfValues, 0)) + values := make([]Variant, max(noOfValues, 0)) // This happens when the size is set conditional to 0 if len(values) == 0 { values = nil } { - _numItems := uint16(utils.Max(noOfValues, 0)) + _numItems := uint16(max(noOfValues, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/QueryFirstRequest.go b/plc4go/protocols/opcua/readwrite/model/QueryFirstRequest.go index 38ba06f42d7..af856242ebe 100644 --- a/plc4go/protocols/opcua/readwrite/model/QueryFirstRequest.go +++ b/plc4go/protocols/opcua/readwrite/model/QueryFirstRequest.go @@ -250,13 +250,13 @@ func QueryFirstRequestParseWithBuffer(ctx context.Context, readBuffer utils.Read return nil, errors.Wrap(pullErr, "Error pulling for nodeTypes") } // Count array - nodeTypes := make([]ExtensionObjectDefinition, utils.Max(noOfNodeTypes, 0)) + nodeTypes := make([]ExtensionObjectDefinition, max(noOfNodeTypes, 0)) // This happens when the size is set conditional to 0 if len(nodeTypes) == 0 { nodeTypes = nil } { - _numItems := uint16(utils.Max(noOfNodeTypes, 0)) + _numItems := uint16(max(noOfNodeTypes, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/QueryFirstResponse.go b/plc4go/protocols/opcua/readwrite/model/QueryFirstResponse.go index 32e9ab6bb6f..9ef06e83687 100644 --- a/plc4go/protocols/opcua/readwrite/model/QueryFirstResponse.go +++ b/plc4go/protocols/opcua/readwrite/model/QueryFirstResponse.go @@ -273,13 +273,13 @@ func QueryFirstResponseParseWithBuffer(ctx context.Context, readBuffer utils.Rea return nil, errors.Wrap(pullErr, "Error pulling for queryDataSets") } // Count array - queryDataSets := make([]ExtensionObjectDefinition, utils.Max(noOfQueryDataSets, 0)) + queryDataSets := make([]ExtensionObjectDefinition, max(noOfQueryDataSets, 0)) // This happens when the size is set conditional to 0 if len(queryDataSets) == 0 { queryDataSets = nil } { - _numItems := uint16(utils.Max(noOfQueryDataSets, 0)) + _numItems := uint16(max(noOfQueryDataSets, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -320,13 +320,13 @@ func QueryFirstResponseParseWithBuffer(ctx context.Context, readBuffer utils.Rea return nil, errors.Wrap(pullErr, "Error pulling for parsingResults") } // Count array - parsingResults := make([]ExtensionObjectDefinition, utils.Max(noOfParsingResults, 0)) + parsingResults := make([]ExtensionObjectDefinition, max(noOfParsingResults, 0)) // This happens when the size is set conditional to 0 if len(parsingResults) == 0 { parsingResults = nil } { - _numItems := uint16(utils.Max(noOfParsingResults, 0)) + _numItems := uint16(max(noOfParsingResults, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -354,13 +354,13 @@ func QueryFirstResponseParseWithBuffer(ctx context.Context, readBuffer utils.Rea return nil, errors.Wrap(pullErr, "Error pulling for diagnosticInfos") } // Count array - diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0)) + diagnosticInfos := make([]DiagnosticInfo, max(noOfDiagnosticInfos, 0)) // This happens when the size is set conditional to 0 if len(diagnosticInfos) == 0 { diagnosticInfos = nil } { - _numItems := uint16(utils.Max(noOfDiagnosticInfos, 0)) + _numItems := uint16(max(noOfDiagnosticInfos, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/QueryNextResponse.go b/plc4go/protocols/opcua/readwrite/model/QueryNextResponse.go index 752e57bf9e2..7bcda074c1c 100644 --- a/plc4go/protocols/opcua/readwrite/model/QueryNextResponse.go +++ b/plc4go/protocols/opcua/readwrite/model/QueryNextResponse.go @@ -204,13 +204,13 @@ func QueryNextResponseParseWithBuffer(ctx context.Context, readBuffer utils.Read return nil, errors.Wrap(pullErr, "Error pulling for queryDataSets") } // Count array - queryDataSets := make([]ExtensionObjectDefinition, utils.Max(noOfQueryDataSets, 0)) + queryDataSets := make([]ExtensionObjectDefinition, max(noOfQueryDataSets, 0)) // This happens when the size is set conditional to 0 if len(queryDataSets) == 0 { queryDataSets = nil } { - _numItems := uint16(utils.Max(noOfQueryDataSets, 0)) + _numItems := uint16(max(noOfQueryDataSets, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/ReadRequest.go b/plc4go/protocols/opcua/readwrite/model/ReadRequest.go index 36aba879bd9..043e871e0e2 100644 --- a/plc4go/protocols/opcua/readwrite/model/ReadRequest.go +++ b/plc4go/protocols/opcua/readwrite/model/ReadRequest.go @@ -235,13 +235,13 @@ func ReadRequestParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer return nil, errors.Wrap(pullErr, "Error pulling for nodesToRead") } // Count array - nodesToRead := make([]ExtensionObjectDefinition, utils.Max(noOfNodesToRead, 0)) + nodesToRead := make([]ExtensionObjectDefinition, max(noOfNodesToRead, 0)) // This happens when the size is set conditional to 0 if len(nodesToRead) == 0 { nodesToRead = nil } { - _numItems := uint16(utils.Max(noOfNodesToRead, 0)) + _numItems := uint16(max(noOfNodesToRead, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/ReadResponse.go b/plc4go/protocols/opcua/readwrite/model/ReadResponse.go index c1579179b32..cfc6c1fc8a3 100644 --- a/plc4go/protocols/opcua/readwrite/model/ReadResponse.go +++ b/plc4go/protocols/opcua/readwrite/model/ReadResponse.go @@ -222,13 +222,13 @@ func ReadResponseParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffe return nil, errors.Wrap(pullErr, "Error pulling for results") } // Count array - results := make([]DataValue, utils.Max(noOfResults, 0)) + results := make([]DataValue, max(noOfResults, 0)) // This happens when the size is set conditional to 0 if len(results) == 0 { results = nil } { - _numItems := uint16(utils.Max(noOfResults, 0)) + _numItems := uint16(max(noOfResults, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -256,13 +256,13 @@ func ReadResponseParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffe return nil, errors.Wrap(pullErr, "Error pulling for diagnosticInfos") } // Count array - diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0)) + diagnosticInfos := make([]DiagnosticInfo, max(noOfDiagnosticInfos, 0)) // This happens when the size is set conditional to 0 if len(diagnosticInfos) == 0 { diagnosticInfos = nil } { - _numItems := uint16(utils.Max(noOfDiagnosticInfos, 0)) + _numItems := uint16(max(noOfDiagnosticInfos, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/RegisterNodesRequest.go b/plc4go/protocols/opcua/readwrite/model/RegisterNodesRequest.go index 1c36d2aba53..301b729334c 100644 --- a/plc4go/protocols/opcua/readwrite/model/RegisterNodesRequest.go +++ b/plc4go/protocols/opcua/readwrite/model/RegisterNodesRequest.go @@ -193,13 +193,13 @@ func RegisterNodesRequestParseWithBuffer(ctx context.Context, readBuffer utils.R return nil, errors.Wrap(pullErr, "Error pulling for nodesToRegister") } // Count array - nodesToRegister := make([]NodeId, utils.Max(noOfNodesToRegister, 0)) + nodesToRegister := make([]NodeId, max(noOfNodesToRegister, 0)) // This happens when the size is set conditional to 0 if len(nodesToRegister) == 0 { nodesToRegister = nil } { - _numItems := uint16(utils.Max(noOfNodesToRegister, 0)) + _numItems := uint16(max(noOfNodesToRegister, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/RegisterNodesResponse.go b/plc4go/protocols/opcua/readwrite/model/RegisterNodesResponse.go index 29fc19bfc9e..4cf7d364f84 100644 --- a/plc4go/protocols/opcua/readwrite/model/RegisterNodesResponse.go +++ b/plc4go/protocols/opcua/readwrite/model/RegisterNodesResponse.go @@ -193,13 +193,13 @@ func RegisterNodesResponseParseWithBuffer(ctx context.Context, readBuffer utils. return nil, errors.Wrap(pullErr, "Error pulling for registeredNodeIds") } // Count array - registeredNodeIds := make([]NodeId, utils.Max(noOfRegisteredNodeIds, 0)) + registeredNodeIds := make([]NodeId, max(noOfRegisteredNodeIds, 0)) // This happens when the size is set conditional to 0 if len(registeredNodeIds) == 0 { registeredNodeIds = nil } { - _numItems := uint16(utils.Max(noOfRegisteredNodeIds, 0)) + _numItems := uint16(max(noOfRegisteredNodeIds, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/RegisterServer2Request.go b/plc4go/protocols/opcua/readwrite/model/RegisterServer2Request.go index e68a57d4f1d..cb3d2d68648 100644 --- a/plc4go/protocols/opcua/readwrite/model/RegisterServer2Request.go +++ b/plc4go/protocols/opcua/readwrite/model/RegisterServer2Request.go @@ -217,13 +217,13 @@ func RegisterServer2RequestParseWithBuffer(ctx context.Context, readBuffer utils return nil, errors.Wrap(pullErr, "Error pulling for discoveryConfiguration") } // Count array - discoveryConfiguration := make([]ExtensionObject, utils.Max(noOfDiscoveryConfiguration, 0)) + discoveryConfiguration := make([]ExtensionObject, max(noOfDiscoveryConfiguration, 0)) // This happens when the size is set conditional to 0 if len(discoveryConfiguration) == 0 { discoveryConfiguration = nil } { - _numItems := uint16(utils.Max(noOfDiscoveryConfiguration, 0)) + _numItems := uint16(max(noOfDiscoveryConfiguration, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/RegisterServer2Response.go b/plc4go/protocols/opcua/readwrite/model/RegisterServer2Response.go index f16aedf2635..948841a1cc2 100644 --- a/plc4go/protocols/opcua/readwrite/model/RegisterServer2Response.go +++ b/plc4go/protocols/opcua/readwrite/model/RegisterServer2Response.go @@ -222,13 +222,13 @@ func RegisterServer2ResponseParseWithBuffer(ctx context.Context, readBuffer util return nil, errors.Wrap(pullErr, "Error pulling for configurationResults") } // Count array - configurationResults := make([]StatusCode, utils.Max(noOfConfigurationResults, 0)) + configurationResults := make([]StatusCode, max(noOfConfigurationResults, 0)) // This happens when the size is set conditional to 0 if len(configurationResults) == 0 { configurationResults = nil } { - _numItems := uint16(utils.Max(noOfConfigurationResults, 0)) + _numItems := uint16(max(noOfConfigurationResults, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -256,13 +256,13 @@ func RegisterServer2ResponseParseWithBuffer(ctx context.Context, readBuffer util return nil, errors.Wrap(pullErr, "Error pulling for diagnosticInfos") } // Count array - diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0)) + diagnosticInfos := make([]DiagnosticInfo, max(noOfDiagnosticInfos, 0)) // This happens when the size is set conditional to 0 if len(diagnosticInfos) == 0 { diagnosticInfos = nil } { - _numItems := uint16(utils.Max(noOfDiagnosticInfos, 0)) + _numItems := uint16(max(noOfDiagnosticInfos, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/RegisteredServer.go b/plc4go/protocols/opcua/readwrite/model/RegisteredServer.go index 026fed3a311..53f9b00c477 100644 --- a/plc4go/protocols/opcua/readwrite/model/RegisteredServer.go +++ b/plc4go/protocols/opcua/readwrite/model/RegisteredServer.go @@ -295,13 +295,13 @@ func RegisteredServerParseWithBuffer(ctx context.Context, readBuffer utils.ReadB return nil, errors.Wrap(pullErr, "Error pulling for serverNames") } // Count array - serverNames := make([]LocalizedText, utils.Max(noOfServerNames, 0)) + serverNames := make([]LocalizedText, max(noOfServerNames, 0)) // This happens when the size is set conditional to 0 if len(serverNames) == 0 { serverNames = nil } { - _numItems := uint16(utils.Max(noOfServerNames, 0)) + _numItems := uint16(max(noOfServerNames, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -355,13 +355,13 @@ func RegisteredServerParseWithBuffer(ctx context.Context, readBuffer utils.ReadB return nil, errors.Wrap(pullErr, "Error pulling for discoveryUrls") } // Count array - discoveryUrls := make([]PascalString, utils.Max(noOfDiscoveryUrls, 0)) + discoveryUrls := make([]PascalString, max(noOfDiscoveryUrls, 0)) // This happens when the size is set conditional to 0 if len(discoveryUrls) == 0 { discoveryUrls = nil } { - _numItems := uint16(utils.Max(noOfDiscoveryUrls, 0)) + _numItems := uint16(max(noOfDiscoveryUrls, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/RelativePath.go b/plc4go/protocols/opcua/readwrite/model/RelativePath.go index 63b2c8bdeb3..ca28bb2971a 100644 --- a/plc4go/protocols/opcua/readwrite/model/RelativePath.go +++ b/plc4go/protocols/opcua/readwrite/model/RelativePath.go @@ -169,13 +169,13 @@ func RelativePathParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffe return nil, errors.Wrap(pullErr, "Error pulling for elements") } // Count array - elements := make([]ExtensionObjectDefinition, utils.Max(noOfElements, 0)) + elements := make([]ExtensionObjectDefinition, max(noOfElements, 0)) // This happens when the size is set conditional to 0 if len(elements) == 0 { elements = nil } { - _numItems := uint16(utils.Max(noOfElements, 0)) + _numItems := uint16(max(noOfElements, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/ResponseHeader.go b/plc4go/protocols/opcua/readwrite/model/ResponseHeader.go index d5901fec613..e06f9372a01 100644 --- a/plc4go/protocols/opcua/readwrite/model/ResponseHeader.go +++ b/plc4go/protocols/opcua/readwrite/model/ResponseHeader.go @@ -264,13 +264,13 @@ func ResponseHeaderParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuf return nil, errors.Wrap(pullErr, "Error pulling for stringTable") } // Count array - stringTable := make([]PascalString, utils.Max(noOfStringTable, 0)) + stringTable := make([]PascalString, max(noOfStringTable, 0)) // This happens when the size is set conditional to 0 if len(stringTable) == 0 { stringTable = nil } { - _numItems := uint16(utils.Max(noOfStringTable, 0)) + _numItems := uint16(max(noOfStringTable, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/SecurityGroupDataType.go b/plc4go/protocols/opcua/readwrite/model/SecurityGroupDataType.go index 7bb872dc085..08697a00c5b 100644 --- a/plc4go/protocols/opcua/readwrite/model/SecurityGroupDataType.go +++ b/plc4go/protocols/opcua/readwrite/model/SecurityGroupDataType.go @@ -306,13 +306,13 @@ func SecurityGroupDataTypeParseWithBuffer(ctx context.Context, readBuffer utils. return nil, errors.Wrap(pullErr, "Error pulling for securityGroupFolder") } // Count array - securityGroupFolder := make([]PascalString, utils.Max(noOfSecurityGroupFolder, 0)) + securityGroupFolder := make([]PascalString, max(noOfSecurityGroupFolder, 0)) // This happens when the size is set conditional to 0 if len(securityGroupFolder) == 0 { securityGroupFolder = nil } { - _numItems := uint16(utils.Max(noOfSecurityGroupFolder, 0)) + _numItems := uint16(max(noOfSecurityGroupFolder, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -387,13 +387,13 @@ func SecurityGroupDataTypeParseWithBuffer(ctx context.Context, readBuffer utils. return nil, errors.Wrap(pullErr, "Error pulling for rolePermissions") } // Count array - rolePermissions := make([]ExtensionObjectDefinition, utils.Max(noOfRolePermissions, 0)) + rolePermissions := make([]ExtensionObjectDefinition, max(noOfRolePermissions, 0)) // This happens when the size is set conditional to 0 if len(rolePermissions) == 0 { rolePermissions = nil } { - _numItems := uint16(utils.Max(noOfRolePermissions, 0)) + _numItems := uint16(max(noOfRolePermissions, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -421,13 +421,13 @@ func SecurityGroupDataTypeParseWithBuffer(ctx context.Context, readBuffer utils. return nil, errors.Wrap(pullErr, "Error pulling for groupProperties") } // Count array - groupProperties := make([]ExtensionObjectDefinition, utils.Max(noOfGroupProperties, 0)) + groupProperties := make([]ExtensionObjectDefinition, max(noOfGroupProperties, 0)) // This happens when the size is set conditional to 0 if len(groupProperties) == 0 { groupProperties = nil } { - _numItems := uint16(utils.Max(noOfGroupProperties, 0)) + _numItems := uint16(max(noOfGroupProperties, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/ServerOnNetwork.go b/plc4go/protocols/opcua/readwrite/model/ServerOnNetwork.go index c91ab32bd18..432599be3b8 100644 --- a/plc4go/protocols/opcua/readwrite/model/ServerOnNetwork.go +++ b/plc4go/protocols/opcua/readwrite/model/ServerOnNetwork.go @@ -235,13 +235,13 @@ func ServerOnNetworkParseWithBuffer(ctx context.Context, readBuffer utils.ReadBu return nil, errors.Wrap(pullErr, "Error pulling for serverCapabilities") } // Count array - serverCapabilities := make([]PascalString, utils.Max(noOfServerCapabilities, 0)) + serverCapabilities := make([]PascalString, max(noOfServerCapabilities, 0)) // This happens when the size is set conditional to 0 if len(serverCapabilities) == 0 { serverCapabilities = nil } { - _numItems := uint16(utils.Max(noOfServerCapabilities, 0)) + _numItems := uint16(max(noOfServerCapabilities, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/SessionDiagnosticsDataType.go b/plc4go/protocols/opcua/readwrite/model/SessionDiagnosticsDataType.go index 6f694392a84..f3d2279ca06 100644 --- a/plc4go/protocols/opcua/readwrite/model/SessionDiagnosticsDataType.go +++ b/plc4go/protocols/opcua/readwrite/model/SessionDiagnosticsDataType.go @@ -696,13 +696,13 @@ func SessionDiagnosticsDataTypeParseWithBuffer(ctx context.Context, readBuffer u return nil, errors.Wrap(pullErr, "Error pulling for localeIds") } // Count array - localeIds := make([]PascalString, utils.Max(noOfLocaleIds, 0)) + localeIds := make([]PascalString, max(noOfLocaleIds, 0)) // This happens when the size is set conditional to 0 if len(localeIds) == 0 { localeIds = nil } { - _numItems := uint16(utils.Max(noOfLocaleIds, 0)) + _numItems := uint16(max(noOfLocaleIds, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/SessionSecurityDiagnosticsDataType.go b/plc4go/protocols/opcua/readwrite/model/SessionSecurityDiagnosticsDataType.go index 50e371df27c..97cf9017c8f 100644 --- a/plc4go/protocols/opcua/readwrite/model/SessionSecurityDiagnosticsDataType.go +++ b/plc4go/protocols/opcua/readwrite/model/SessionSecurityDiagnosticsDataType.go @@ -283,13 +283,13 @@ func SessionSecurityDiagnosticsDataTypeParseWithBuffer(ctx context.Context, read return nil, errors.Wrap(pullErr, "Error pulling for clientUserIdHistory") } // Count array - clientUserIdHistory := make([]PascalString, utils.Max(noOfClientUserIdHistory, 0)) + clientUserIdHistory := make([]PascalString, max(noOfClientUserIdHistory, 0)) // This happens when the size is set conditional to 0 if len(clientUserIdHistory) == 0 { clientUserIdHistory = nil } { - _numItems := uint16(utils.Max(noOfClientUserIdHistory, 0)) + _numItems := uint16(max(noOfClientUserIdHistory, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/SessionlessInvokeRequestType.go b/plc4go/protocols/opcua/readwrite/model/SessionlessInvokeRequestType.go index 955c75c5dce..26b99110863 100644 --- a/plc4go/protocols/opcua/readwrite/model/SessionlessInvokeRequestType.go +++ b/plc4go/protocols/opcua/readwrite/model/SessionlessInvokeRequestType.go @@ -256,13 +256,13 @@ func SessionlessInvokeRequestTypeParseWithBuffer(ctx context.Context, readBuffer return nil, errors.Wrap(pullErr, "Error pulling for namespaceUris") } // Count array - namespaceUris := make([]PascalString, utils.Max(noOfNamespaceUris, 0)) + namespaceUris := make([]PascalString, max(noOfNamespaceUris, 0)) // This happens when the size is set conditional to 0 if len(namespaceUris) == 0 { namespaceUris = nil } { - _numItems := uint16(utils.Max(noOfNamespaceUris, 0)) + _numItems := uint16(max(noOfNamespaceUris, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -290,13 +290,13 @@ func SessionlessInvokeRequestTypeParseWithBuffer(ctx context.Context, readBuffer return nil, errors.Wrap(pullErr, "Error pulling for serverUris") } // Count array - serverUris := make([]PascalString, utils.Max(noOfServerUris, 0)) + serverUris := make([]PascalString, max(noOfServerUris, 0)) // This happens when the size is set conditional to 0 if len(serverUris) == 0 { serverUris = nil } { - _numItems := uint16(utils.Max(noOfServerUris, 0)) + _numItems := uint16(max(noOfServerUris, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -324,13 +324,13 @@ func SessionlessInvokeRequestTypeParseWithBuffer(ctx context.Context, readBuffer return nil, errors.Wrap(pullErr, "Error pulling for localeIds") } // Count array - localeIds := make([]PascalString, utils.Max(noOfLocaleIds, 0)) + localeIds := make([]PascalString, max(noOfLocaleIds, 0)) // This happens when the size is set conditional to 0 if len(localeIds) == 0 { localeIds = nil } { - _numItems := uint16(utils.Max(noOfLocaleIds, 0)) + _numItems := uint16(max(noOfLocaleIds, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/SessionlessInvokeResponseType.go b/plc4go/protocols/opcua/readwrite/model/SessionlessInvokeResponseType.go index e4b88d0a21d..7e77b520997 100644 --- a/plc4go/protocols/opcua/readwrite/model/SessionlessInvokeResponseType.go +++ b/plc4go/protocols/opcua/readwrite/model/SessionlessInvokeResponseType.go @@ -209,13 +209,13 @@ func SessionlessInvokeResponseTypeParseWithBuffer(ctx context.Context, readBuffe return nil, errors.Wrap(pullErr, "Error pulling for namespaceUris") } // Count array - namespaceUris := make([]PascalString, utils.Max(noOfNamespaceUris, 0)) + namespaceUris := make([]PascalString, max(noOfNamespaceUris, 0)) // This happens when the size is set conditional to 0 if len(namespaceUris) == 0 { namespaceUris = nil } { - _numItems := uint16(utils.Max(noOfNamespaceUris, 0)) + _numItems := uint16(max(noOfNamespaceUris, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -243,13 +243,13 @@ func SessionlessInvokeResponseTypeParseWithBuffer(ctx context.Context, readBuffe return nil, errors.Wrap(pullErr, "Error pulling for serverUris") } // Count array - serverUris := make([]PascalString, utils.Max(noOfServerUris, 0)) + serverUris := make([]PascalString, max(noOfServerUris, 0)) // This happens when the size is set conditional to 0 if len(serverUris) == 0 { serverUris = nil } { - _numItems := uint16(utils.Max(noOfServerUris, 0)) + _numItems := uint16(max(noOfServerUris, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/SetMonitoringModeRequest.go b/plc4go/protocols/opcua/readwrite/model/SetMonitoringModeRequest.go index 7148432cc71..439a9c4e0e6 100644 --- a/plc4go/protocols/opcua/readwrite/model/SetMonitoringModeRequest.go +++ b/plc4go/protocols/opcua/readwrite/model/SetMonitoringModeRequest.go @@ -230,13 +230,13 @@ func SetMonitoringModeRequestParseWithBuffer(ctx context.Context, readBuffer uti return nil, errors.Wrap(pullErr, "Error pulling for monitoredItemIds") } // Count array - monitoredItemIds := make([]uint32, utils.Max(noOfMonitoredItemIds, 0)) + monitoredItemIds := make([]uint32, max(noOfMonitoredItemIds, 0)) // This happens when the size is set conditional to 0 if len(monitoredItemIds) == 0 { monitoredItemIds = nil } { - _numItems := uint16(utils.Max(noOfMonitoredItemIds, 0)) + _numItems := uint16(max(noOfMonitoredItemIds, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/SetMonitoringModeResponse.go b/plc4go/protocols/opcua/readwrite/model/SetMonitoringModeResponse.go index 83cafbfc3e3..90ef338fcb4 100644 --- a/plc4go/protocols/opcua/readwrite/model/SetMonitoringModeResponse.go +++ b/plc4go/protocols/opcua/readwrite/model/SetMonitoringModeResponse.go @@ -222,13 +222,13 @@ func SetMonitoringModeResponseParseWithBuffer(ctx context.Context, readBuffer ut return nil, errors.Wrap(pullErr, "Error pulling for results") } // Count array - results := make([]StatusCode, utils.Max(noOfResults, 0)) + results := make([]StatusCode, max(noOfResults, 0)) // This happens when the size is set conditional to 0 if len(results) == 0 { results = nil } { - _numItems := uint16(utils.Max(noOfResults, 0)) + _numItems := uint16(max(noOfResults, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -256,13 +256,13 @@ func SetMonitoringModeResponseParseWithBuffer(ctx context.Context, readBuffer ut return nil, errors.Wrap(pullErr, "Error pulling for diagnosticInfos") } // Count array - diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0)) + diagnosticInfos := make([]DiagnosticInfo, max(noOfDiagnosticInfos, 0)) // This happens when the size is set conditional to 0 if len(diagnosticInfos) == 0 { diagnosticInfos = nil } { - _numItems := uint16(utils.Max(noOfDiagnosticInfos, 0)) + _numItems := uint16(max(noOfDiagnosticInfos, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/SetPublishingModeRequest.go b/plc4go/protocols/opcua/readwrite/model/SetPublishingModeRequest.go index 57d9ced23cf..3fae79b3e6e 100644 --- a/plc4go/protocols/opcua/readwrite/model/SetPublishingModeRequest.go +++ b/plc4go/protocols/opcua/readwrite/model/SetPublishingModeRequest.go @@ -228,13 +228,13 @@ func SetPublishingModeRequestParseWithBuffer(ctx context.Context, readBuffer uti return nil, errors.Wrap(pullErr, "Error pulling for subscriptionIds") } // Count array - subscriptionIds := make([]uint32, utils.Max(noOfSubscriptionIds, 0)) + subscriptionIds := make([]uint32, max(noOfSubscriptionIds, 0)) // This happens when the size is set conditional to 0 if len(subscriptionIds) == 0 { subscriptionIds = nil } { - _numItems := uint16(utils.Max(noOfSubscriptionIds, 0)) + _numItems := uint16(max(noOfSubscriptionIds, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/SetPublishingModeResponse.go b/plc4go/protocols/opcua/readwrite/model/SetPublishingModeResponse.go index 40c64e17d51..ab28a933098 100644 --- a/plc4go/protocols/opcua/readwrite/model/SetPublishingModeResponse.go +++ b/plc4go/protocols/opcua/readwrite/model/SetPublishingModeResponse.go @@ -222,13 +222,13 @@ func SetPublishingModeResponseParseWithBuffer(ctx context.Context, readBuffer ut return nil, errors.Wrap(pullErr, "Error pulling for results") } // Count array - results := make([]StatusCode, utils.Max(noOfResults, 0)) + results := make([]StatusCode, max(noOfResults, 0)) // This happens when the size is set conditional to 0 if len(results) == 0 { results = nil } { - _numItems := uint16(utils.Max(noOfResults, 0)) + _numItems := uint16(max(noOfResults, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -256,13 +256,13 @@ func SetPublishingModeResponseParseWithBuffer(ctx context.Context, readBuffer ut return nil, errors.Wrap(pullErr, "Error pulling for diagnosticInfos") } // Count array - diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0)) + diagnosticInfos := make([]DiagnosticInfo, max(noOfDiagnosticInfos, 0)) // This happens when the size is set conditional to 0 if len(diagnosticInfos) == 0 { diagnosticInfos = nil } { - _numItems := uint16(utils.Max(noOfDiagnosticInfos, 0)) + _numItems := uint16(max(noOfDiagnosticInfos, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/SetTriggeringRequest.go b/plc4go/protocols/opcua/readwrite/model/SetTriggeringRequest.go index d96e2c9cd25..b95f3ab8996 100644 --- a/plc4go/protocols/opcua/readwrite/model/SetTriggeringRequest.go +++ b/plc4go/protocols/opcua/readwrite/model/SetTriggeringRequest.go @@ -248,13 +248,13 @@ func SetTriggeringRequestParseWithBuffer(ctx context.Context, readBuffer utils.R return nil, errors.Wrap(pullErr, "Error pulling for linksToAdd") } // Count array - linksToAdd := make([]uint32, utils.Max(noOfLinksToAdd, 0)) + linksToAdd := make([]uint32, max(noOfLinksToAdd, 0)) // This happens when the size is set conditional to 0 if len(linksToAdd) == 0 { linksToAdd = nil } { - _numItems := uint16(utils.Max(noOfLinksToAdd, 0)) + _numItems := uint16(max(noOfLinksToAdd, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -282,13 +282,13 @@ func SetTriggeringRequestParseWithBuffer(ctx context.Context, readBuffer utils.R return nil, errors.Wrap(pullErr, "Error pulling for linksToRemove") } // Count array - linksToRemove := make([]uint32, utils.Max(noOfLinksToRemove, 0)) + linksToRemove := make([]uint32, max(noOfLinksToRemove, 0)) // This happens when the size is set conditional to 0 if len(linksToRemove) == 0 { linksToRemove = nil } { - _numItems := uint16(utils.Max(noOfLinksToRemove, 0)) + _numItems := uint16(max(noOfLinksToRemove, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/SetTriggeringResponse.go b/plc4go/protocols/opcua/readwrite/model/SetTriggeringResponse.go index 5f208867eba..83fd682d8dd 100644 --- a/plc4go/protocols/opcua/readwrite/model/SetTriggeringResponse.go +++ b/plc4go/protocols/opcua/readwrite/model/SetTriggeringResponse.go @@ -280,13 +280,13 @@ func SetTriggeringResponseParseWithBuffer(ctx context.Context, readBuffer utils. return nil, errors.Wrap(pullErr, "Error pulling for addResults") } // Count array - addResults := make([]StatusCode, utils.Max(noOfAddResults, 0)) + addResults := make([]StatusCode, max(noOfAddResults, 0)) // This happens when the size is set conditional to 0 if len(addResults) == 0 { addResults = nil } { - _numItems := uint16(utils.Max(noOfAddResults, 0)) + _numItems := uint16(max(noOfAddResults, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -314,13 +314,13 @@ func SetTriggeringResponseParseWithBuffer(ctx context.Context, readBuffer utils. return nil, errors.Wrap(pullErr, "Error pulling for addDiagnosticInfos") } // Count array - addDiagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfAddDiagnosticInfos, 0)) + addDiagnosticInfos := make([]DiagnosticInfo, max(noOfAddDiagnosticInfos, 0)) // This happens when the size is set conditional to 0 if len(addDiagnosticInfos) == 0 { addDiagnosticInfos = nil } { - _numItems := uint16(utils.Max(noOfAddDiagnosticInfos, 0)) + _numItems := uint16(max(noOfAddDiagnosticInfos, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -348,13 +348,13 @@ func SetTriggeringResponseParseWithBuffer(ctx context.Context, readBuffer utils. return nil, errors.Wrap(pullErr, "Error pulling for removeResults") } // Count array - removeResults := make([]StatusCode, utils.Max(noOfRemoveResults, 0)) + removeResults := make([]StatusCode, max(noOfRemoveResults, 0)) // This happens when the size is set conditional to 0 if len(removeResults) == 0 { removeResults = nil } { - _numItems := uint16(utils.Max(noOfRemoveResults, 0)) + _numItems := uint16(max(noOfRemoveResults, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -382,13 +382,13 @@ func SetTriggeringResponseParseWithBuffer(ctx context.Context, readBuffer utils. return nil, errors.Wrap(pullErr, "Error pulling for removeDiagnosticInfos") } // Count array - removeDiagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfRemoveDiagnosticInfos, 0)) + removeDiagnosticInfos := make([]DiagnosticInfo, max(noOfRemoveDiagnosticInfos, 0)) // This happens when the size is set conditional to 0 if len(removeDiagnosticInfos) == 0 { removeDiagnosticInfos = nil } { - _numItems := uint16(utils.Max(noOfRemoveDiagnosticInfos, 0)) + _numItems := uint16(max(noOfRemoveDiagnosticInfos, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/StaticHelper.go b/plc4go/protocols/opcua/readwrite/model/StaticHelper.go index 7c27e92c0d2..86c487662f2 100644 --- a/plc4go/protocols/opcua/readwrite/model/StaticHelper.go +++ b/plc4go/protocols/opcua/readwrite/model/StaticHelper.go @@ -21,7 +21,6 @@ package model import ( "context" - "github.com/apache/plc4x/plc4go/spi/utils" ) func Utf8LengthToPascalLength(_ context.Context, stringValue string) int32 { @@ -32,5 +31,5 @@ func Utf8LengthToPascalLength(_ context.Context, stringValue string) int32 { } func PascalLengthToUtf8Length(_ context.Context, slength int32) int32 { - return utils.Max(slength, 0) + return max(slength, 0) } diff --git a/plc4go/protocols/opcua/readwrite/model/StructureField.go b/plc4go/protocols/opcua/readwrite/model/StructureField.go index 42576a9bc44..a71d989e55b 100644 --- a/plc4go/protocols/opcua/readwrite/model/StructureField.go +++ b/plc4go/protocols/opcua/readwrite/model/StructureField.go @@ -281,13 +281,13 @@ func StructureFieldParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuf return nil, errors.Wrap(pullErr, "Error pulling for arrayDimensions") } // Count array - arrayDimensions := make([]uint32, utils.Max(noOfArrayDimensions, 0)) + arrayDimensions := make([]uint32, max(noOfArrayDimensions, 0)) // This happens when the size is set conditional to 0 if len(arrayDimensions) == 0 { arrayDimensions = nil } { - _numItems := uint16(utils.Max(noOfArrayDimensions, 0)) + _numItems := uint16(max(noOfArrayDimensions, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/TransferResult.go b/plc4go/protocols/opcua/readwrite/model/TransferResult.go index 64c918912ab..c12696d7bd2 100644 --- a/plc4go/protocols/opcua/readwrite/model/TransferResult.go +++ b/plc4go/protocols/opcua/readwrite/model/TransferResult.go @@ -188,13 +188,13 @@ func TransferResultParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuf return nil, errors.Wrap(pullErr, "Error pulling for availableSequenceNumbers") } // Count array - availableSequenceNumbers := make([]uint32, utils.Max(noOfAvailableSequenceNumbers, 0)) + availableSequenceNumbers := make([]uint32, max(noOfAvailableSequenceNumbers, 0)) // This happens when the size is set conditional to 0 if len(availableSequenceNumbers) == 0 { availableSequenceNumbers = nil } { - _numItems := uint16(utils.Max(noOfAvailableSequenceNumbers, 0)) + _numItems := uint16(max(noOfAvailableSequenceNumbers, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/TransferSubscriptionsRequest.go b/plc4go/protocols/opcua/readwrite/model/TransferSubscriptionsRequest.go index aa5c44f12e1..14f014b32b4 100644 --- a/plc4go/protocols/opcua/readwrite/model/TransferSubscriptionsRequest.go +++ b/plc4go/protocols/opcua/readwrite/model/TransferSubscriptionsRequest.go @@ -204,13 +204,13 @@ func TransferSubscriptionsRequestParseWithBuffer(ctx context.Context, readBuffer return nil, errors.Wrap(pullErr, "Error pulling for subscriptionIds") } // Count array - subscriptionIds := make([]uint32, utils.Max(noOfSubscriptionIds, 0)) + subscriptionIds := make([]uint32, max(noOfSubscriptionIds, 0)) // This happens when the size is set conditional to 0 if len(subscriptionIds) == 0 { subscriptionIds = nil } { - _numItems := uint16(utils.Max(noOfSubscriptionIds, 0)) + _numItems := uint16(max(noOfSubscriptionIds, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/TransferSubscriptionsResponse.go b/plc4go/protocols/opcua/readwrite/model/TransferSubscriptionsResponse.go index b3ef69a2e3f..12ff53b2d98 100644 --- a/plc4go/protocols/opcua/readwrite/model/TransferSubscriptionsResponse.go +++ b/plc4go/protocols/opcua/readwrite/model/TransferSubscriptionsResponse.go @@ -222,13 +222,13 @@ func TransferSubscriptionsResponseParseWithBuffer(ctx context.Context, readBuffe return nil, errors.Wrap(pullErr, "Error pulling for results") } // Count array - results := make([]ExtensionObjectDefinition, utils.Max(noOfResults, 0)) + results := make([]ExtensionObjectDefinition, max(noOfResults, 0)) // This happens when the size is set conditional to 0 if len(results) == 0 { results = nil } { - _numItems := uint16(utils.Max(noOfResults, 0)) + _numItems := uint16(max(noOfResults, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -256,13 +256,13 @@ func TransferSubscriptionsResponseParseWithBuffer(ctx context.Context, readBuffe return nil, errors.Wrap(pullErr, "Error pulling for diagnosticInfos") } // Count array - diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0)) + diagnosticInfos := make([]DiagnosticInfo, max(noOfDiagnosticInfos, 0)) // This happens when the size is set conditional to 0 if len(diagnosticInfos) == 0 { diagnosticInfos = nil } { - _numItems := uint16(utils.Max(noOfDiagnosticInfos, 0)) + _numItems := uint16(max(noOfDiagnosticInfos, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/TranslateBrowsePathsToNodeIdsRequest.go b/plc4go/protocols/opcua/readwrite/model/TranslateBrowsePathsToNodeIdsRequest.go index 023ab54fa1f..b6eb915f815 100644 --- a/plc4go/protocols/opcua/readwrite/model/TranslateBrowsePathsToNodeIdsRequest.go +++ b/plc4go/protocols/opcua/readwrite/model/TranslateBrowsePathsToNodeIdsRequest.go @@ -193,13 +193,13 @@ func TranslateBrowsePathsToNodeIdsRequestParseWithBuffer(ctx context.Context, re return nil, errors.Wrap(pullErr, "Error pulling for browsePaths") } // Count array - browsePaths := make([]ExtensionObjectDefinition, utils.Max(noOfBrowsePaths, 0)) + browsePaths := make([]ExtensionObjectDefinition, max(noOfBrowsePaths, 0)) // This happens when the size is set conditional to 0 if len(browsePaths) == 0 { browsePaths = nil } { - _numItems := uint16(utils.Max(noOfBrowsePaths, 0)) + _numItems := uint16(max(noOfBrowsePaths, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/TranslateBrowsePathsToNodeIdsResponse.go b/plc4go/protocols/opcua/readwrite/model/TranslateBrowsePathsToNodeIdsResponse.go index 075933b3192..3d530ac2504 100644 --- a/plc4go/protocols/opcua/readwrite/model/TranslateBrowsePathsToNodeIdsResponse.go +++ b/plc4go/protocols/opcua/readwrite/model/TranslateBrowsePathsToNodeIdsResponse.go @@ -222,13 +222,13 @@ func TranslateBrowsePathsToNodeIdsResponseParseWithBuffer(ctx context.Context, r return nil, errors.Wrap(pullErr, "Error pulling for results") } // Count array - results := make([]ExtensionObjectDefinition, utils.Max(noOfResults, 0)) + results := make([]ExtensionObjectDefinition, max(noOfResults, 0)) // This happens when the size is set conditional to 0 if len(results) == 0 { results = nil } { - _numItems := uint16(utils.Max(noOfResults, 0)) + _numItems := uint16(max(noOfResults, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -256,13 +256,13 @@ func TranslateBrowsePathsToNodeIdsResponseParseWithBuffer(ctx context.Context, r return nil, errors.Wrap(pullErr, "Error pulling for diagnosticInfos") } // Count array - diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0)) + diagnosticInfos := make([]DiagnosticInfo, max(noOfDiagnosticInfos, 0)) // This happens when the size is set conditional to 0 if len(diagnosticInfos) == 0 { diagnosticInfos = nil } { - _numItems := uint16(utils.Max(noOfDiagnosticInfos, 0)) + _numItems := uint16(max(noOfDiagnosticInfos, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/TrustListDataType.go b/plc4go/protocols/opcua/readwrite/model/TrustListDataType.go index d4169737c16..d302dc0956f 100644 --- a/plc4go/protocols/opcua/readwrite/model/TrustListDataType.go +++ b/plc4go/protocols/opcua/readwrite/model/TrustListDataType.go @@ -274,13 +274,13 @@ func TrustListDataTypeParseWithBuffer(ctx context.Context, readBuffer utils.Read return nil, errors.Wrap(pullErr, "Error pulling for trustedCertificates") } // Count array - trustedCertificates := make([]PascalByteString, utils.Max(noOfTrustedCertificates, 0)) + trustedCertificates := make([]PascalByteString, max(noOfTrustedCertificates, 0)) // This happens when the size is set conditional to 0 if len(trustedCertificates) == 0 { trustedCertificates = nil } { - _numItems := uint16(utils.Max(noOfTrustedCertificates, 0)) + _numItems := uint16(max(noOfTrustedCertificates, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -308,13 +308,13 @@ func TrustListDataTypeParseWithBuffer(ctx context.Context, readBuffer utils.Read return nil, errors.Wrap(pullErr, "Error pulling for trustedCrls") } // Count array - trustedCrls := make([]PascalByteString, utils.Max(noOfTrustedCrls, 0)) + trustedCrls := make([]PascalByteString, max(noOfTrustedCrls, 0)) // This happens when the size is set conditional to 0 if len(trustedCrls) == 0 { trustedCrls = nil } { - _numItems := uint16(utils.Max(noOfTrustedCrls, 0)) + _numItems := uint16(max(noOfTrustedCrls, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -342,13 +342,13 @@ func TrustListDataTypeParseWithBuffer(ctx context.Context, readBuffer utils.Read return nil, errors.Wrap(pullErr, "Error pulling for issuerCertificates") } // Count array - issuerCertificates := make([]PascalByteString, utils.Max(noOfIssuerCertificates, 0)) + issuerCertificates := make([]PascalByteString, max(noOfIssuerCertificates, 0)) // This happens when the size is set conditional to 0 if len(issuerCertificates) == 0 { issuerCertificates = nil } { - _numItems := uint16(utils.Max(noOfIssuerCertificates, 0)) + _numItems := uint16(max(noOfIssuerCertificates, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -376,13 +376,13 @@ func TrustListDataTypeParseWithBuffer(ctx context.Context, readBuffer utils.Read return nil, errors.Wrap(pullErr, "Error pulling for issuerCrls") } // Count array - issuerCrls := make([]PascalByteString, utils.Max(noOfIssuerCrls, 0)) + issuerCrls := make([]PascalByteString, max(noOfIssuerCrls, 0)) // This happens when the size is set conditional to 0 if len(issuerCrls) == 0 { issuerCrls = nil } { - _numItems := uint16(utils.Max(noOfIssuerCrls, 0)) + _numItems := uint16(max(noOfIssuerCrls, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/UnregisterNodesRequest.go b/plc4go/protocols/opcua/readwrite/model/UnregisterNodesRequest.go index d9ec925b6b5..5910ee43164 100644 --- a/plc4go/protocols/opcua/readwrite/model/UnregisterNodesRequest.go +++ b/plc4go/protocols/opcua/readwrite/model/UnregisterNodesRequest.go @@ -193,13 +193,13 @@ func UnregisterNodesRequestParseWithBuffer(ctx context.Context, readBuffer utils return nil, errors.Wrap(pullErr, "Error pulling for nodesToUnregister") } // Count array - nodesToUnregister := make([]NodeId, utils.Max(noOfNodesToUnregister, 0)) + nodesToUnregister := make([]NodeId, max(noOfNodesToUnregister, 0)) // This happens when the size is set conditional to 0 if len(nodesToUnregister) == 0 { nodesToUnregister = nil } { - _numItems := uint16(utils.Max(noOfNodesToUnregister, 0)) + _numItems := uint16(max(noOfNodesToUnregister, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/Variant.go b/plc4go/protocols/opcua/readwrite/model/Variant.go index 640c4387d85..fba21e1c6a1 100644 --- a/plc4go/protocols/opcua/readwrite/model/Variant.go +++ b/plc4go/protocols/opcua/readwrite/model/Variant.go @@ -277,13 +277,13 @@ func VariantParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer) (V return nil, errors.Wrap(pullErr, "Error pulling for arrayDimensions") } // Count array - arrayDimensions := make([]bool, utils.Max(utils.InlineIf(bool((noOfArrayDimensions) == (nil)), func() any { return uint16(uint16(0)) }, func() any { return uint16((*noOfArrayDimensions)) }).(uint16), 0)) + arrayDimensions := make([]bool, max(utils.InlineIf(bool((noOfArrayDimensions) == (nil)), func() any { return uint16(uint16(0)) }, func() any { return uint16((*noOfArrayDimensions)) }).(uint16), 0)) // This happens when the size is set conditional to 0 if len(arrayDimensions) == 0 { arrayDimensions = nil } { - _numItems := uint16(utils.Max(utils.InlineIf(bool((noOfArrayDimensions) == (nil)), func() any { return uint16(uint16(0)) }, func() any { return uint16((*noOfArrayDimensions)) }).(uint16), 0)) + _numItems := uint16(max(utils.InlineIf(bool((noOfArrayDimensions) == (nil)), func() any { return uint16(uint16(0)) }, func() any { return uint16((*noOfArrayDimensions)) }).(uint16), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/VariantByte.go b/plc4go/protocols/opcua/readwrite/model/VariantByte.go index 05b3b192b11..3f667a94466 100644 --- a/plc4go/protocols/opcua/readwrite/model/VariantByte.go +++ b/plc4go/protocols/opcua/readwrite/model/VariantByte.go @@ -174,13 +174,13 @@ func VariantByteParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer return nil, errors.Wrap(pullErr, "Error pulling for value") } // Count array - value := make([]uint8, utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + value := make([]uint8, max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) // This happens when the size is set conditional to 0 if len(value) == 0 { value = nil } { - _numItems := uint16(utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + _numItems := uint16(max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/VariantByteString.go b/plc4go/protocols/opcua/readwrite/model/VariantByteString.go index 749304b945c..6ce6f147745 100644 --- a/plc4go/protocols/opcua/readwrite/model/VariantByteString.go +++ b/plc4go/protocols/opcua/readwrite/model/VariantByteString.go @@ -179,13 +179,13 @@ func VariantByteStringParseWithBuffer(ctx context.Context, readBuffer utils.Read return nil, errors.Wrap(pullErr, "Error pulling for value") } // Count array - value := make([]ByteStringArray, utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + value := make([]ByteStringArray, max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) // This happens when the size is set conditional to 0 if len(value) == 0 { value = nil } { - _numItems := uint16(utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + _numItems := uint16(max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/VariantDataValue.go b/plc4go/protocols/opcua/readwrite/model/VariantDataValue.go index 6c3a79273ab..05a18a67a6c 100644 --- a/plc4go/protocols/opcua/readwrite/model/VariantDataValue.go +++ b/plc4go/protocols/opcua/readwrite/model/VariantDataValue.go @@ -179,13 +179,13 @@ func VariantDataValueParseWithBuffer(ctx context.Context, readBuffer utils.ReadB return nil, errors.Wrap(pullErr, "Error pulling for value") } // Count array - value := make([]DataValue, utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + value := make([]DataValue, max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) // This happens when the size is set conditional to 0 if len(value) == 0 { value = nil } { - _numItems := uint16(utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + _numItems := uint16(max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/VariantDateTime.go b/plc4go/protocols/opcua/readwrite/model/VariantDateTime.go index 092b22bd44e..05c132b77b5 100644 --- a/plc4go/protocols/opcua/readwrite/model/VariantDateTime.go +++ b/plc4go/protocols/opcua/readwrite/model/VariantDateTime.go @@ -174,13 +174,13 @@ func VariantDateTimeParseWithBuffer(ctx context.Context, readBuffer utils.ReadBu return nil, errors.Wrap(pullErr, "Error pulling for value") } // Count array - value := make([]int64, utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + value := make([]int64, max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) // This happens when the size is set conditional to 0 if len(value) == 0 { value = nil } { - _numItems := uint16(utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + _numItems := uint16(max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/VariantDiagnosticInfo.go b/plc4go/protocols/opcua/readwrite/model/VariantDiagnosticInfo.go index b9098ea29ba..06a574d5711 100644 --- a/plc4go/protocols/opcua/readwrite/model/VariantDiagnosticInfo.go +++ b/plc4go/protocols/opcua/readwrite/model/VariantDiagnosticInfo.go @@ -179,13 +179,13 @@ func VariantDiagnosticInfoParseWithBuffer(ctx context.Context, readBuffer utils. return nil, errors.Wrap(pullErr, "Error pulling for value") } // Count array - value := make([]DiagnosticInfo, utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + value := make([]DiagnosticInfo, max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) // This happens when the size is set conditional to 0 if len(value) == 0 { value = nil } { - _numItems := uint16(utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + _numItems := uint16(max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/VariantDouble.go b/plc4go/protocols/opcua/readwrite/model/VariantDouble.go index 3c574f77344..8ff9440c3dd 100644 --- a/plc4go/protocols/opcua/readwrite/model/VariantDouble.go +++ b/plc4go/protocols/opcua/readwrite/model/VariantDouble.go @@ -174,13 +174,13 @@ func VariantDoubleParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuff return nil, errors.Wrap(pullErr, "Error pulling for value") } // Count array - value := make([]float64, utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + value := make([]float64, max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) // This happens when the size is set conditional to 0 if len(value) == 0 { value = nil } { - _numItems := uint16(utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + _numItems := uint16(max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/VariantExpandedNodeId.go b/plc4go/protocols/opcua/readwrite/model/VariantExpandedNodeId.go index 3d01dc5d539..dd11baf89aa 100644 --- a/plc4go/protocols/opcua/readwrite/model/VariantExpandedNodeId.go +++ b/plc4go/protocols/opcua/readwrite/model/VariantExpandedNodeId.go @@ -179,13 +179,13 @@ func VariantExpandedNodeIdParseWithBuffer(ctx context.Context, readBuffer utils. return nil, errors.Wrap(pullErr, "Error pulling for value") } // Count array - value := make([]ExpandedNodeId, utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + value := make([]ExpandedNodeId, max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) // This happens when the size is set conditional to 0 if len(value) == 0 { value = nil } { - _numItems := uint16(utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + _numItems := uint16(max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/VariantExtensionObject.go b/plc4go/protocols/opcua/readwrite/model/VariantExtensionObject.go index 0fa2a198eee..c1e9cd42847 100644 --- a/plc4go/protocols/opcua/readwrite/model/VariantExtensionObject.go +++ b/plc4go/protocols/opcua/readwrite/model/VariantExtensionObject.go @@ -179,13 +179,13 @@ func VariantExtensionObjectParseWithBuffer(ctx context.Context, readBuffer utils return nil, errors.Wrap(pullErr, "Error pulling for value") } // Count array - value := make([]ExtensionObject, utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + value := make([]ExtensionObject, max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) // This happens when the size is set conditional to 0 if len(value) == 0 { value = nil } { - _numItems := uint16(utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + _numItems := uint16(max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/VariantFloat.go b/plc4go/protocols/opcua/readwrite/model/VariantFloat.go index 7ba30f1ceb1..9da45eea18e 100644 --- a/plc4go/protocols/opcua/readwrite/model/VariantFloat.go +++ b/plc4go/protocols/opcua/readwrite/model/VariantFloat.go @@ -174,13 +174,13 @@ func VariantFloatParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffe return nil, errors.Wrap(pullErr, "Error pulling for value") } // Count array - value := make([]float32, utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + value := make([]float32, max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) // This happens when the size is set conditional to 0 if len(value) == 0 { value = nil } { - _numItems := uint16(utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + _numItems := uint16(max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/VariantGuid.go b/plc4go/protocols/opcua/readwrite/model/VariantGuid.go index ef81a987e93..325392c568c 100644 --- a/plc4go/protocols/opcua/readwrite/model/VariantGuid.go +++ b/plc4go/protocols/opcua/readwrite/model/VariantGuid.go @@ -179,13 +179,13 @@ func VariantGuidParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer return nil, errors.Wrap(pullErr, "Error pulling for value") } // Count array - value := make([]GuidValue, utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + value := make([]GuidValue, max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) // This happens when the size is set conditional to 0 if len(value) == 0 { value = nil } { - _numItems := uint16(utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + _numItems := uint16(max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/VariantInt16.go b/plc4go/protocols/opcua/readwrite/model/VariantInt16.go index 42fd8587164..690de897b8c 100644 --- a/plc4go/protocols/opcua/readwrite/model/VariantInt16.go +++ b/plc4go/protocols/opcua/readwrite/model/VariantInt16.go @@ -174,13 +174,13 @@ func VariantInt16ParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffe return nil, errors.Wrap(pullErr, "Error pulling for value") } // Count array - value := make([]int16, utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + value := make([]int16, max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) // This happens when the size is set conditional to 0 if len(value) == 0 { value = nil } { - _numItems := uint16(utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + _numItems := uint16(max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/VariantInt32.go b/plc4go/protocols/opcua/readwrite/model/VariantInt32.go index 1b68584ed9e..058f6861437 100644 --- a/plc4go/protocols/opcua/readwrite/model/VariantInt32.go +++ b/plc4go/protocols/opcua/readwrite/model/VariantInt32.go @@ -174,13 +174,13 @@ func VariantInt32ParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffe return nil, errors.Wrap(pullErr, "Error pulling for value") } // Count array - value := make([]int32, utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + value := make([]int32, max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) // This happens when the size is set conditional to 0 if len(value) == 0 { value = nil } { - _numItems := uint16(utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + _numItems := uint16(max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/VariantInt64.go b/plc4go/protocols/opcua/readwrite/model/VariantInt64.go index 39959c0662e..1b5dab3774a 100644 --- a/plc4go/protocols/opcua/readwrite/model/VariantInt64.go +++ b/plc4go/protocols/opcua/readwrite/model/VariantInt64.go @@ -174,13 +174,13 @@ func VariantInt64ParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffe return nil, errors.Wrap(pullErr, "Error pulling for value") } // Count array - value := make([]int64, utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + value := make([]int64, max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) // This happens when the size is set conditional to 0 if len(value) == 0 { value = nil } { - _numItems := uint16(utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + _numItems := uint16(max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/VariantLocalizedText.go b/plc4go/protocols/opcua/readwrite/model/VariantLocalizedText.go index 5b28cc4f7db..5105fc277e9 100644 --- a/plc4go/protocols/opcua/readwrite/model/VariantLocalizedText.go +++ b/plc4go/protocols/opcua/readwrite/model/VariantLocalizedText.go @@ -179,13 +179,13 @@ func VariantLocalizedTextParseWithBuffer(ctx context.Context, readBuffer utils.R return nil, errors.Wrap(pullErr, "Error pulling for value") } // Count array - value := make([]LocalizedText, utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + value := make([]LocalizedText, max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) // This happens when the size is set conditional to 0 if len(value) == 0 { value = nil } { - _numItems := uint16(utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + _numItems := uint16(max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/VariantNodeId.go b/plc4go/protocols/opcua/readwrite/model/VariantNodeId.go index 6435ffbe993..cb463d362da 100644 --- a/plc4go/protocols/opcua/readwrite/model/VariantNodeId.go +++ b/plc4go/protocols/opcua/readwrite/model/VariantNodeId.go @@ -179,13 +179,13 @@ func VariantNodeIdParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuff return nil, errors.Wrap(pullErr, "Error pulling for value") } // Count array - value := make([]NodeId, utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + value := make([]NodeId, max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) // This happens when the size is set conditional to 0 if len(value) == 0 { value = nil } { - _numItems := uint16(utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + _numItems := uint16(max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/VariantQualifiedName.go b/plc4go/protocols/opcua/readwrite/model/VariantQualifiedName.go index 84ba1195674..9e38dcc8878 100644 --- a/plc4go/protocols/opcua/readwrite/model/VariantQualifiedName.go +++ b/plc4go/protocols/opcua/readwrite/model/VariantQualifiedName.go @@ -179,13 +179,13 @@ func VariantQualifiedNameParseWithBuffer(ctx context.Context, readBuffer utils.R return nil, errors.Wrap(pullErr, "Error pulling for value") } // Count array - value := make([]QualifiedName, utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + value := make([]QualifiedName, max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) // This happens when the size is set conditional to 0 if len(value) == 0 { value = nil } { - _numItems := uint16(utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + _numItems := uint16(max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/VariantStatusCode.go b/plc4go/protocols/opcua/readwrite/model/VariantStatusCode.go index 71667c34e00..d4a2ffb72aa 100644 --- a/plc4go/protocols/opcua/readwrite/model/VariantStatusCode.go +++ b/plc4go/protocols/opcua/readwrite/model/VariantStatusCode.go @@ -179,13 +179,13 @@ func VariantStatusCodeParseWithBuffer(ctx context.Context, readBuffer utils.Read return nil, errors.Wrap(pullErr, "Error pulling for value") } // Count array - value := make([]StatusCode, utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + value := make([]StatusCode, max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) // This happens when the size is set conditional to 0 if len(value) == 0 { value = nil } { - _numItems := uint16(utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + _numItems := uint16(max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/VariantString.go b/plc4go/protocols/opcua/readwrite/model/VariantString.go index 3d6c8b5b577..cea311da512 100644 --- a/plc4go/protocols/opcua/readwrite/model/VariantString.go +++ b/plc4go/protocols/opcua/readwrite/model/VariantString.go @@ -179,13 +179,13 @@ func VariantStringParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuff return nil, errors.Wrap(pullErr, "Error pulling for value") } // Count array - value := make([]PascalString, utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + value := make([]PascalString, max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) // This happens when the size is set conditional to 0 if len(value) == 0 { value = nil } { - _numItems := uint16(utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + _numItems := uint16(max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/VariantUInt16.go b/plc4go/protocols/opcua/readwrite/model/VariantUInt16.go index c1e9b998050..702d4706d92 100644 --- a/plc4go/protocols/opcua/readwrite/model/VariantUInt16.go +++ b/plc4go/protocols/opcua/readwrite/model/VariantUInt16.go @@ -174,13 +174,13 @@ func VariantUInt16ParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuff return nil, errors.Wrap(pullErr, "Error pulling for value") } // Count array - value := make([]uint16, utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + value := make([]uint16, max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) // This happens when the size is set conditional to 0 if len(value) == 0 { value = nil } { - _numItems := uint16(utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + _numItems := uint16(max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/VariantUInt32.go b/plc4go/protocols/opcua/readwrite/model/VariantUInt32.go index 4bbd155012d..b386393e8bd 100644 --- a/plc4go/protocols/opcua/readwrite/model/VariantUInt32.go +++ b/plc4go/protocols/opcua/readwrite/model/VariantUInt32.go @@ -174,13 +174,13 @@ func VariantUInt32ParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuff return nil, errors.Wrap(pullErr, "Error pulling for value") } // Count array - value := make([]uint32, utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + value := make([]uint32, max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) // This happens when the size is set conditional to 0 if len(value) == 0 { value = nil } { - _numItems := uint16(utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + _numItems := uint16(max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/VariantUInt64.go b/plc4go/protocols/opcua/readwrite/model/VariantUInt64.go index e6232c031cf..5e0eb2b34b7 100644 --- a/plc4go/protocols/opcua/readwrite/model/VariantUInt64.go +++ b/plc4go/protocols/opcua/readwrite/model/VariantUInt64.go @@ -174,13 +174,13 @@ func VariantUInt64ParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuff return nil, errors.Wrap(pullErr, "Error pulling for value") } // Count array - value := make([]uint64, utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + value := make([]uint64, max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) // This happens when the size is set conditional to 0 if len(value) == 0 { value = nil } { - _numItems := uint16(utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + _numItems := uint16(max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/VariantVariant.go b/plc4go/protocols/opcua/readwrite/model/VariantVariant.go index 408d42e35de..bac807ff5e0 100644 --- a/plc4go/protocols/opcua/readwrite/model/VariantVariant.go +++ b/plc4go/protocols/opcua/readwrite/model/VariantVariant.go @@ -179,13 +179,13 @@ func VariantVariantParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuf return nil, errors.Wrap(pullErr, "Error pulling for value") } // Count array - value := make([]Variant, utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + value := make([]Variant, max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) // This happens when the size is set conditional to 0 if len(value) == 0 { value = nil } { - _numItems := uint16(utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + _numItems := uint16(max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/VariantXmlElement.go b/plc4go/protocols/opcua/readwrite/model/VariantXmlElement.go index b93bba84c98..4561d359703 100644 --- a/plc4go/protocols/opcua/readwrite/model/VariantXmlElement.go +++ b/plc4go/protocols/opcua/readwrite/model/VariantXmlElement.go @@ -179,13 +179,13 @@ func VariantXmlElementParseWithBuffer(ctx context.Context, readBuffer utils.Read return nil, errors.Wrap(pullErr, "Error pulling for value") } // Count array - value := make([]PascalString, utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + value := make([]PascalString, max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) // This happens when the size is set conditional to 0 if len(value) == 0 { value = nil } { - _numItems := uint16(utils.Max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) + _numItems := uint16(max(utils.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/WriteRequest.go b/plc4go/protocols/opcua/readwrite/model/WriteRequest.go index 05fcd8b64ef..b5c86c2ae46 100644 --- a/plc4go/protocols/opcua/readwrite/model/WriteRequest.go +++ b/plc4go/protocols/opcua/readwrite/model/WriteRequest.go @@ -193,13 +193,13 @@ func WriteRequestParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffe return nil, errors.Wrap(pullErr, "Error pulling for nodesToWrite") } // Count array - nodesToWrite := make([]ExtensionObjectDefinition, utils.Max(noOfNodesToWrite, 0)) + nodesToWrite := make([]ExtensionObjectDefinition, max(noOfNodesToWrite, 0)) // This happens when the size is set conditional to 0 if len(nodesToWrite) == 0 { nodesToWrite = nil } { - _numItems := uint16(utils.Max(noOfNodesToWrite, 0)) + _numItems := uint16(max(noOfNodesToWrite, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/WriteResponse.go b/plc4go/protocols/opcua/readwrite/model/WriteResponse.go index 783eef71c07..4cd19c9eb89 100644 --- a/plc4go/protocols/opcua/readwrite/model/WriteResponse.go +++ b/plc4go/protocols/opcua/readwrite/model/WriteResponse.go @@ -222,13 +222,13 @@ func WriteResponseParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuff return nil, errors.Wrap(pullErr, "Error pulling for results") } // Count array - results := make([]StatusCode, utils.Max(noOfResults, 0)) + results := make([]StatusCode, max(noOfResults, 0)) // This happens when the size is set conditional to 0 if len(results) == 0 { results = nil } { - _numItems := uint16(utils.Max(noOfResults, 0)) + _numItems := uint16(max(noOfResults, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx @@ -256,13 +256,13 @@ func WriteResponseParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuff return nil, errors.Wrap(pullErr, "Error pulling for diagnosticInfos") } // Count array - diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0)) + diagnosticInfos := make([]DiagnosticInfo, max(noOfDiagnosticInfos, 0)) // This happens when the size is set conditional to 0 if len(diagnosticInfos) == 0 { diagnosticInfos = nil } { - _numItems := uint16(utils.Max(noOfDiagnosticInfos, 0)) + _numItems := uint16(max(noOfDiagnosticInfos, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/opcua/readwrite/model/XmlElement.go b/plc4go/protocols/opcua/readwrite/model/XmlElement.go index 6e0e1775a62..c215a0c1da1 100644 --- a/plc4go/protocols/opcua/readwrite/model/XmlElement.go +++ b/plc4go/protocols/opcua/readwrite/model/XmlElement.go @@ -136,13 +136,13 @@ func XmlElementParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer) return nil, errors.Wrap(pullErr, "Error pulling for value") } // Count array - value := make([]string, utils.Max(length, 0)) + value := make([]string, max(length, 0)) // This happens when the size is set conditional to 0 if len(value) == 0 { value = nil } { - _numItems := uint16(utils.Max(length, 0)) + _numItems := uint16(max(length, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/s7/readwrite/model/Alarm8MessageQueryType.go b/plc4go/protocols/s7/readwrite/model/Alarm8MessageQueryType.go index 6e1682b6ff1..8bfd06adf78 100644 --- a/plc4go/protocols/s7/readwrite/model/Alarm8MessageQueryType.go +++ b/plc4go/protocols/s7/readwrite/model/Alarm8MessageQueryType.go @@ -221,13 +221,13 @@ func Alarm8MessageQueryTypeParseWithBuffer(ctx context.Context, readBuffer utils return nil, errors.Wrap(pullErr, "Error pulling for messageObjects") } // Count array - messageObjects := make([]AlarmMessageObjectQueryType, utils.Max(uint16(byteCount)/uint16(uint16(12)), 0)) + messageObjects := make([]AlarmMessageObjectQueryType, max(uint16(byteCount)/uint16(uint16(12)), 0)) // This happens when the size is set conditional to 0 if len(messageObjects) == 0 { messageObjects = nil } { - _numItems := uint16(utils.Max(uint16(byteCount)/uint16(uint16(12)), 0)) + _numItems := uint16(max(uint16(byteCount)/uint16(uint16(12)), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/s7/readwrite/model/AlarmMessageAckPushType.go b/plc4go/protocols/s7/readwrite/model/AlarmMessageAckPushType.go index 1caa781204a..ca10f1b4fe9 100644 --- a/plc4go/protocols/s7/readwrite/model/AlarmMessageAckPushType.go +++ b/plc4go/protocols/s7/readwrite/model/AlarmMessageAckPushType.go @@ -181,13 +181,13 @@ func AlarmMessageAckPushTypeParseWithBuffer(ctx context.Context, readBuffer util return nil, errors.Wrap(pullErr, "Error pulling for messageObjects") } // Count array - messageObjects := make([]AlarmMessageAckObjectPushType, utils.Max(numberOfObjects, 0)) + messageObjects := make([]AlarmMessageAckObjectPushType, max(numberOfObjects, 0)) // This happens when the size is set conditional to 0 if len(messageObjects) == 0 { messageObjects = nil } { - _numItems := uint16(utils.Max(numberOfObjects, 0)) + _numItems := uint16(max(numberOfObjects, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/s7/readwrite/model/AlarmMessageAckResponseType.go b/plc4go/protocols/s7/readwrite/model/AlarmMessageAckResponseType.go index 18ca5658a9e..54bf52ed045 100644 --- a/plc4go/protocols/s7/readwrite/model/AlarmMessageAckResponseType.go +++ b/plc4go/protocols/s7/readwrite/model/AlarmMessageAckResponseType.go @@ -153,13 +153,13 @@ func AlarmMessageAckResponseTypeParseWithBuffer(ctx context.Context, readBuffer return nil, errors.Wrap(pullErr, "Error pulling for messageObjects") } // Count array - messageObjects := make([]uint8, utils.Max(numberOfObjects, 0)) + messageObjects := make([]uint8, max(numberOfObjects, 0)) // This happens when the size is set conditional to 0 if len(messageObjects) == 0 { messageObjects = nil } { - _numItems := uint16(utils.Max(numberOfObjects, 0)) + _numItems := uint16(max(numberOfObjects, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/s7/readwrite/model/AlarmMessageAckType.go b/plc4go/protocols/s7/readwrite/model/AlarmMessageAckType.go index 4c8518f7462..a4b62f3b871 100644 --- a/plc4go/protocols/s7/readwrite/model/AlarmMessageAckType.go +++ b/plc4go/protocols/s7/readwrite/model/AlarmMessageAckType.go @@ -158,13 +158,13 @@ func AlarmMessageAckTypeParseWithBuffer(ctx context.Context, readBuffer utils.Re return nil, errors.Wrap(pullErr, "Error pulling for messageObjects") } // Count array - messageObjects := make([]AlarmMessageObjectAckType, utils.Max(numberOfObjects, 0)) + messageObjects := make([]AlarmMessageObjectAckType, max(numberOfObjects, 0)) // This happens when the size is set conditional to 0 if len(messageObjects) == 0 { messageObjects = nil } { - _numItems := uint16(utils.Max(numberOfObjects, 0)) + _numItems := uint16(max(numberOfObjects, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/s7/readwrite/model/AlarmMessageObjectPushType.go b/plc4go/protocols/s7/readwrite/model/AlarmMessageObjectPushType.go index 968d3c19121..ad342d94daa 100644 --- a/plc4go/protocols/s7/readwrite/model/AlarmMessageObjectPushType.go +++ b/plc4go/protocols/s7/readwrite/model/AlarmMessageObjectPushType.go @@ -318,13 +318,13 @@ func AlarmMessageObjectPushTypeParseWithBuffer(ctx context.Context, readBuffer u return nil, errors.Wrap(pullErr, "Error pulling for AssociatedValues") } // Count array - AssociatedValues := make([]AssociatedValueType, utils.Max(numberOfValues, 0)) + AssociatedValues := make([]AssociatedValueType, max(numberOfValues, 0)) // This happens when the size is set conditional to 0 if len(AssociatedValues) == 0 { AssociatedValues = nil } { - _numItems := uint16(utils.Max(numberOfValues, 0)) + _numItems := uint16(max(numberOfValues, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/s7/readwrite/model/AlarmMessagePushType.go b/plc4go/protocols/s7/readwrite/model/AlarmMessagePushType.go index 1f32eba3308..9dd280c5a22 100644 --- a/plc4go/protocols/s7/readwrite/model/AlarmMessagePushType.go +++ b/plc4go/protocols/s7/readwrite/model/AlarmMessagePushType.go @@ -181,13 +181,13 @@ func AlarmMessagePushTypeParseWithBuffer(ctx context.Context, readBuffer utils.R return nil, errors.Wrap(pullErr, "Error pulling for messageObjects") } // Count array - messageObjects := make([]AlarmMessageObjectPushType, utils.Max(numberOfObjects, 0)) + messageObjects := make([]AlarmMessageObjectPushType, max(numberOfObjects, 0)) // This happens when the size is set conditional to 0 if len(messageObjects) == 0 { messageObjects = nil } { - _numItems := uint16(utils.Max(numberOfObjects, 0)) + _numItems := uint16(max(numberOfObjects, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/s7/readwrite/model/AlarmMessageQueryType.go b/plc4go/protocols/s7/readwrite/model/AlarmMessageQueryType.go index 2c4a2b9bb1e..991a55ba8da 100644 --- a/plc4go/protocols/s7/readwrite/model/AlarmMessageQueryType.go +++ b/plc4go/protocols/s7/readwrite/model/AlarmMessageQueryType.go @@ -232,13 +232,13 @@ func AlarmMessageQueryTypeParseWithBuffer(ctx context.Context, readBuffer utils. return nil, errors.Wrap(pullErr, "Error pulling for messageObjects") } // Count array - messageObjects := make([]AlarmMessageObjectQueryType, utils.Max(numberOfObjects, 0)) + messageObjects := make([]AlarmMessageObjectQueryType, max(numberOfObjects, 0)) // This happens when the size is set conditional to 0 if len(messageObjects) == 0 { messageObjects = nil } { - _numItems := uint16(utils.Max(numberOfObjects, 0)) + _numItems := uint16(max(numberOfObjects, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/s7/readwrite/model/AssociatedQueryValueType.go b/plc4go/protocols/s7/readwrite/model/AssociatedQueryValueType.go index 53aa143b77b..4f3b23bc6a9 100644 --- a/plc4go/protocols/s7/readwrite/model/AssociatedQueryValueType.go +++ b/plc4go/protocols/s7/readwrite/model/AssociatedQueryValueType.go @@ -182,13 +182,13 @@ func AssociatedQueryValueTypeParseWithBuffer(ctx context.Context, readBuffer uti return nil, errors.Wrap(pullErr, "Error pulling for data") } // Count array - data := make([]uint8, utils.Max(valueLength, 0)) + data := make([]uint8, max(valueLength, 0)) // This happens when the size is set conditional to 0 if len(data) == 0 { data = nil } { - _numItems := uint16(utils.Max(valueLength, 0)) + _numItems := uint16(max(valueLength, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/s7/readwrite/model/AssociatedValueType.go b/plc4go/protocols/s7/readwrite/model/AssociatedValueType.go index 946a9635c3a..82ad431d3fc 100644 --- a/plc4go/protocols/s7/readwrite/model/AssociatedValueType.go +++ b/plc4go/protocols/s7/readwrite/model/AssociatedValueType.go @@ -185,13 +185,13 @@ func AssociatedValueTypeParseWithBuffer(ctx context.Context, readBuffer utils.Re return nil, errors.Wrap(pullErr, "Error pulling for data") } // Count array - data := make([]uint8, utils.Max(EventItemLength(ctx, readBuffer, valueLength), 0)) + data := make([]uint8, max(EventItemLength(ctx, readBuffer, valueLength), 0)) // This happens when the size is set conditional to 0 if len(data) == 0 { data = nil } { - _numItems := uint16(utils.Max(EventItemLength(ctx, readBuffer, valueLength), 0)) + _numItems := uint16(max(EventItemLength(ctx, readBuffer, valueLength), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/s7/readwrite/model/CycServiceItemDbReadType.go b/plc4go/protocols/s7/readwrite/model/CycServiceItemDbReadType.go index 615590bb15c..7b8a1a50036 100644 --- a/plc4go/protocols/s7/readwrite/model/CycServiceItemDbReadType.go +++ b/plc4go/protocols/s7/readwrite/model/CycServiceItemDbReadType.go @@ -168,13 +168,13 @@ func CycServiceItemDbReadTypeParseWithBuffer(ctx context.Context, readBuffer uti return nil, errors.Wrap(pullErr, "Error pulling for items") } // Count array - items := make([]SubItem, utils.Max(numberOfAreas, 0)) + items := make([]SubItem, max(numberOfAreas, 0)) // This happens when the size is set conditional to 0 if len(items) == 0 { items = nil } { - _numItems := uint16(utils.Max(numberOfAreas, 0)) + _numItems := uint16(max(numberOfAreas, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/s7/readwrite/model/S7ParameterReadVarRequest.go b/plc4go/protocols/s7/readwrite/model/S7ParameterReadVarRequest.go index a3fdedb5591..641a32a68e2 100644 --- a/plc4go/protocols/s7/readwrite/model/S7ParameterReadVarRequest.go +++ b/plc4go/protocols/s7/readwrite/model/S7ParameterReadVarRequest.go @@ -165,13 +165,13 @@ func S7ParameterReadVarRequestParseWithBuffer(ctx context.Context, readBuffer ut return nil, errors.Wrap(pullErr, "Error pulling for items") } // Count array - items := make([]S7VarRequestParameterItem, utils.Max(numItems, 0)) + items := make([]S7VarRequestParameterItem, max(numItems, 0)) // This happens when the size is set conditional to 0 if len(items) == 0 { items = nil } { - _numItems := uint16(utils.Max(numItems, 0)) + _numItems := uint16(max(numItems, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/s7/readwrite/model/S7ParameterUserData.go b/plc4go/protocols/s7/readwrite/model/S7ParameterUserData.go index fce47e84ae1..b5f854c0705 100644 --- a/plc4go/protocols/s7/readwrite/model/S7ParameterUserData.go +++ b/plc4go/protocols/s7/readwrite/model/S7ParameterUserData.go @@ -165,13 +165,13 @@ func S7ParameterUserDataParseWithBuffer(ctx context.Context, readBuffer utils.Re return nil, errors.Wrap(pullErr, "Error pulling for items") } // Count array - items := make([]S7ParameterUserDataItem, utils.Max(numItems, 0)) + items := make([]S7ParameterUserDataItem, max(numItems, 0)) // This happens when the size is set conditional to 0 if len(items) == 0 { items = nil } { - _numItems := uint16(utils.Max(numItems, 0)) + _numItems := uint16(max(numItems, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/s7/readwrite/model/S7ParameterWriteVarRequest.go b/plc4go/protocols/s7/readwrite/model/S7ParameterWriteVarRequest.go index a26920cc541..fa2315ce38c 100644 --- a/plc4go/protocols/s7/readwrite/model/S7ParameterWriteVarRequest.go +++ b/plc4go/protocols/s7/readwrite/model/S7ParameterWriteVarRequest.go @@ -165,13 +165,13 @@ func S7ParameterWriteVarRequestParseWithBuffer(ctx context.Context, readBuffer u return nil, errors.Wrap(pullErr, "Error pulling for items") } // Count array - items := make([]S7VarRequestParameterItem, utils.Max(numItems, 0)) + items := make([]S7VarRequestParameterItem, max(numItems, 0)) // This happens when the size is set conditional to 0 if len(items) == 0 { items = nil } { - _numItems := uint16(utils.Max(numItems, 0)) + _numItems := uint16(max(numItems, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/s7/readwrite/model/S7PayloadReadVarResponse.go b/plc4go/protocols/s7/readwrite/model/S7PayloadReadVarResponse.go index 2d7f9f7091d..c71604d19d3 100644 --- a/plc4go/protocols/s7/readwrite/model/S7PayloadReadVarResponse.go +++ b/plc4go/protocols/s7/readwrite/model/S7PayloadReadVarResponse.go @@ -155,13 +155,13 @@ func S7PayloadReadVarResponseParseWithBuffer(ctx context.Context, readBuffer uti return nil, errors.Wrap(pullErr, "Error pulling for items") } // Count array - items := make([]S7VarPayloadDataItem, utils.Max(CastS7ParameterReadVarResponse(parameter).GetNumItems(), 0)) + items := make([]S7VarPayloadDataItem, max(CastS7ParameterReadVarResponse(parameter).GetNumItems(), 0)) // This happens when the size is set conditional to 0 if len(items) == 0 { items = nil } { - _numItems := uint16(utils.Max(CastS7ParameterReadVarResponse(parameter).GetNumItems(), 0)) + _numItems := uint16(max(CastS7ParameterReadVarResponse(parameter).GetNumItems(), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/s7/readwrite/model/S7PayloadUserData.go b/plc4go/protocols/s7/readwrite/model/S7PayloadUserData.go index 3ddcc278ac7..0b68f476918 100644 --- a/plc4go/protocols/s7/readwrite/model/S7PayloadUserData.go +++ b/plc4go/protocols/s7/readwrite/model/S7PayloadUserData.go @@ -155,13 +155,13 @@ func S7PayloadUserDataParseWithBuffer(ctx context.Context, readBuffer utils.Read return nil, errors.Wrap(pullErr, "Error pulling for items") } // Count array - items := make([]S7PayloadUserDataItem, utils.Max(uint16(len(CastS7ParameterUserData(parameter).GetItems())), 0)) + items := make([]S7PayloadUserDataItem, max(uint16(len(CastS7ParameterUserData(parameter).GetItems())), 0)) // This happens when the size is set conditional to 0 if len(items) == 0 { items = nil } { - _numItems := uint16(utils.Max(uint16(len(CastS7ParameterUserData(parameter).GetItems())), 0)) + _numItems := uint16(max(uint16(len(CastS7ParameterUserData(parameter).GetItems())), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCpuFunctionAlarmAckRequest.go b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCpuFunctionAlarmAckRequest.go index 501bb4e93d2..051dbb26421 100644 --- a/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCpuFunctionAlarmAckRequest.go +++ b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCpuFunctionAlarmAckRequest.go @@ -201,13 +201,13 @@ func S7PayloadUserDataItemCpuFunctionAlarmAckRequestParseWithBuffer(ctx context. return nil, errors.Wrap(pullErr, "Error pulling for messageObjects") } // Count array - messageObjects := make([]AlarmMessageObjectAckType, utils.Max(numberOfObjects, 0)) + messageObjects := make([]AlarmMessageObjectAckType, max(numberOfObjects, 0)) // This happens when the size is set conditional to 0 if len(messageObjects) == 0 { messageObjects = nil } { - _numItems := uint16(utils.Max(numberOfObjects, 0)) + _numItems := uint16(max(numberOfObjects, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCpuFunctionAlarmAckResponse.go b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCpuFunctionAlarmAckResponse.go index a1917a43dc1..27dc9121a7b 100644 --- a/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCpuFunctionAlarmAckResponse.go +++ b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCpuFunctionAlarmAckResponse.go @@ -186,13 +186,13 @@ func S7PayloadUserDataItemCpuFunctionAlarmAckResponseParseWithBuffer(ctx context return nil, errors.Wrap(pullErr, "Error pulling for messageObjects") } // Count array - messageObjects := make([]uint8, utils.Max(numberOfObjects, 0)) + messageObjects := make([]uint8, max(numberOfObjects, 0)) // This happens when the size is set conditional to 0 if len(messageObjects) == 0 { messageObjects = nil } { - _numItems := uint16(utils.Max(numberOfObjects, 0)) + _numItems := uint16(max(numberOfObjects, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCyclicServicesChangeDrivenPush.go b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCyclicServicesChangeDrivenPush.go index 1d9e981b379..dab6d9ff41c 100644 --- a/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCyclicServicesChangeDrivenPush.go +++ b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCyclicServicesChangeDrivenPush.go @@ -181,13 +181,13 @@ func S7PayloadUserDataItemCyclicServicesChangeDrivenPushParseWithBuffer(ctx cont return nil, errors.Wrap(pullErr, "Error pulling for items") } // Count array - items := make([]AssociatedQueryValueType, utils.Max(itemsCount, 0)) + items := make([]AssociatedQueryValueType, max(itemsCount, 0)) // This happens when the size is set conditional to 0 if len(items) == 0 { items = nil } { - _numItems := uint16(utils.Max(itemsCount, 0)) + _numItems := uint16(max(itemsCount, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCyclicServicesChangeDrivenSubscribeResponse.go b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCyclicServicesChangeDrivenSubscribeResponse.go index b44e0d73c2e..5563b94463b 100644 --- a/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCyclicServicesChangeDrivenSubscribeResponse.go +++ b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCyclicServicesChangeDrivenSubscribeResponse.go @@ -181,13 +181,13 @@ func S7PayloadUserDataItemCyclicServicesChangeDrivenSubscribeResponseParseWithBu return nil, errors.Wrap(pullErr, "Error pulling for items") } // Count array - items := make([]AssociatedQueryValueType, utils.Max(itemsCount, 0)) + items := make([]AssociatedQueryValueType, max(itemsCount, 0)) // This happens when the size is set conditional to 0 if len(items) == 0 { items = nil } { - _numItems := uint16(utils.Max(itemsCount, 0)) + _numItems := uint16(max(itemsCount, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCyclicServicesPush.go b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCyclicServicesPush.go index 1ecc24d9fed..7d2f0c4d8af 100644 --- a/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCyclicServicesPush.go +++ b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCyclicServicesPush.go @@ -181,13 +181,13 @@ func S7PayloadUserDataItemCyclicServicesPushParseWithBuffer(ctx context.Context, return nil, errors.Wrap(pullErr, "Error pulling for items") } // Count array - items := make([]AssociatedValueType, utils.Max(itemsCount, 0)) + items := make([]AssociatedValueType, max(itemsCount, 0)) // This happens when the size is set conditional to 0 if len(items) == 0 { items = nil } { - _numItems := uint16(utils.Max(itemsCount, 0)) + _numItems := uint16(max(itemsCount, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCyclicServicesSubscribeRequest.go b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCyclicServicesSubscribeRequest.go index 838e9eab347..0e3356304c5 100644 --- a/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCyclicServicesSubscribeRequest.go +++ b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCyclicServicesSubscribeRequest.go @@ -223,13 +223,13 @@ func S7PayloadUserDataItemCyclicServicesSubscribeRequestParseWithBuffer(ctx cont return nil, errors.Wrap(pullErr, "Error pulling for item") } // Count array - item := make([]CycServiceItemType, utils.Max(itemsCount, 0)) + item := make([]CycServiceItemType, max(itemsCount, 0)) // This happens when the size is set conditional to 0 if len(item) == 0 { item = nil } { - _numItems := uint16(utils.Max(itemsCount, 0)) + _numItems := uint16(max(itemsCount, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCyclicServicesSubscribeResponse.go b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCyclicServicesSubscribeResponse.go index 4ce358aa7cd..a63e6328451 100644 --- a/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCyclicServicesSubscribeResponse.go +++ b/plc4go/protocols/s7/readwrite/model/S7PayloadUserDataItemCyclicServicesSubscribeResponse.go @@ -181,13 +181,13 @@ func S7PayloadUserDataItemCyclicServicesSubscribeResponseParseWithBuffer(ctx con return nil, errors.Wrap(pullErr, "Error pulling for items") } // Count array - items := make([]AssociatedValueType, utils.Max(itemsCount, 0)) + items := make([]AssociatedValueType, max(itemsCount, 0)) // This happens when the size is set conditional to 0 if len(items) == 0 { items = nil } { - _numItems := uint16(utils.Max(itemsCount, 0)) + _numItems := uint16(max(itemsCount, 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/s7/readwrite/model/S7PayloadWriteVarRequest.go b/plc4go/protocols/s7/readwrite/model/S7PayloadWriteVarRequest.go index bd3ed7c4795..bd664fe2cd2 100644 --- a/plc4go/protocols/s7/readwrite/model/S7PayloadWriteVarRequest.go +++ b/plc4go/protocols/s7/readwrite/model/S7PayloadWriteVarRequest.go @@ -155,13 +155,13 @@ func S7PayloadWriteVarRequestParseWithBuffer(ctx context.Context, readBuffer uti return nil, errors.Wrap(pullErr, "Error pulling for items") } // Count array - items := make([]S7VarPayloadDataItem, utils.Max(uint16(len(CastS7ParameterWriteVarRequest(parameter).GetItems())), 0)) + items := make([]S7VarPayloadDataItem, max(uint16(len(CastS7ParameterWriteVarRequest(parameter).GetItems())), 0)) // This happens when the size is set conditional to 0 if len(items) == 0 { items = nil } { - _numItems := uint16(utils.Max(uint16(len(CastS7ParameterWriteVarRequest(parameter).GetItems())), 0)) + _numItems := uint16(max(uint16(len(CastS7ParameterWriteVarRequest(parameter).GetItems())), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/protocols/s7/readwrite/model/S7PayloadWriteVarResponse.go b/plc4go/protocols/s7/readwrite/model/S7PayloadWriteVarResponse.go index c260803cf3a..fd1b88820ec 100644 --- a/plc4go/protocols/s7/readwrite/model/S7PayloadWriteVarResponse.go +++ b/plc4go/protocols/s7/readwrite/model/S7PayloadWriteVarResponse.go @@ -155,13 +155,13 @@ func S7PayloadWriteVarResponseParseWithBuffer(ctx context.Context, readBuffer ut return nil, errors.Wrap(pullErr, "Error pulling for items") } // Count array - items := make([]S7VarPayloadStatusItem, utils.Max(CastS7ParameterWriteVarResponse(parameter).GetNumItems(), 0)) + items := make([]S7VarPayloadStatusItem, max(CastS7ParameterWriteVarResponse(parameter).GetNumItems(), 0)) // This happens when the size is set conditional to 0 if len(items) == 0 { items = nil } { - _numItems := uint16(utils.Max(CastS7ParameterWriteVarResponse(parameter).GetNumItems(), 0)) + _numItems := uint16(max(CastS7ParameterWriteVarResponse(parameter).GetNumItems(), 0)) for _curItem := uint16(0); _curItem < _numItems; _curItem++ { arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem)) _ = arrayCtx diff --git a/plc4go/spi/utils/Misc.go b/plc4go/spi/utils/Misc.go index 8268dd8a0ae..bf974fd5302 100644 --- a/plc4go/spi/utils/Misc.go +++ b/plc4go/spi/utils/Misc.go @@ -20,7 +20,6 @@ package utils import ( - "golang.org/x/exp/constraints" "time" ) @@ -47,19 +46,3 @@ func CleanupTimer(timer *time.Timer) { } } } - -func Min[T constraints.Ordered](left, right T) T { - if left < right { - return left - } else { - return right - } -} - -func Max[T constraints.Ordered](left, right T) T { - if left > right { - return left - } else { - return right - } -} diff --git a/plc4go/spi/utils/Misc_test.go b/plc4go/spi/utils/Misc_test.go index 80791758dd6..82b1beef257 100644 --- a/plc4go/spi/utils/Misc_test.go +++ b/plc4go/spi/utils/Misc_test.go @@ -21,7 +21,6 @@ package utils import ( "github.com/stretchr/testify/assert" - "golang.org/x/exp/constraints" "testing" "time" ) @@ -101,36 +100,3 @@ func TestInlineIf(t *testing.T) { }) } } - -func TestMin(t *testing.T) { - type args[T constraints.Ordered] struct { - left T - right T - } - type testCase[T constraints.Ordered] struct { - name string - args args[T] - want T - } - tests := []testCase[string]{ - { - args: args[string]{ - "a", - "b", - }, - want: "a", - }, - { - args: args[string]{ - "b", - "a", - }, - want: "a", - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - assert.Equalf(t, tt.want, Min(tt.args.left, tt.args.right), "Min(%v, %v)", tt.args.left, tt.args.right) - }) - } -} diff --git a/plc4go/spi/utils/hex.go b/plc4go/spi/utils/hex.go index e3178fc9222..d29c6232878 100644 --- a/plc4go/spi/utils/hex.go +++ b/plc4go/spi/utils/hex.go @@ -52,7 +52,7 @@ func Dump(data []byte, highlights ...int) string { return DumpFixedWidth(data, DefaultWidth, highlights...) } -// DumpFixedWidth dumps hex as hex string. Min width of string returned is 18 up to supplied charWidth +// DumpFixedWidth dumps hex as hex string. The minimum width of string returned is 18 up to supplied charWidth func DumpFixedWidth(data []byte, desiredCharWidth int, highlights ...int) string { if data == nil || len(data) < 1 { return ""