You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@plc4x.apache.org by sr...@apache.org on 2023/08/07 12:40:59 UTC
[plc4x] 05/08: fix(codgen/plc4go): added count array guard
This is an automated email from the ASF dual-hosted git repository.
sruehl pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/plc4x.git
commit f1f08fb58923d55256d23db1be4e3fe194646105
Author: Sebastian Rühl <sr...@apache.org>
AuthorDate: Mon Aug 7 14:05:23 2023 +0200
fix(codgen/plc4go): added count array guard
---
.../resources/templates/go/complex-type-template.go.ftlh | 4 ++--
.../abeth/readwrite/model/CIPEncapsulationPacket.go | 4 ++--
.../ads/discovery/readwrite/model/AdsDiscovery.go | 4 ++--
.../ads/readwrite/model/AdsDataTypeTableChildEntry.go | 8 ++++----
.../ads/readwrite/model/AdsDataTypeTableEntry.go | 8 ++++----
.../ads/readwrite/model/AdsDeviceNotificationRequest.go | 4 ++--
.../protocols/ads/readwrite/model/AdsReadWriteRequest.go | 4 ++--
plc4go/protocols/ads/readwrite/model/AdsStampHeader.go | 4 ++--
.../model/BACnetServiceAckAtomicReadFileRecord.go | 4 ++--
.../readwrite/model/BACnetTagPayloadBitString.go | 8 ++++----
.../model/BVLCBroadcastDistributionTableEntry.go | 8 ++++----
.../readwrite/model/BVLCDeleteForeignDeviceTableEntry.go | 4 ++--
.../readwrite/model/BVLCForeignDeviceTableEntry.go | 4 ++--
.../bacnetip/readwrite/model/BVLCForwardedNPDU.go | 4 ++--
.../bacnetip/readwrite/model/NLMInitalizeRoutingTable.go | 4 ++--
.../readwrite/model/NLMInitalizeRoutingTableAck.go | 4 ++--
.../bacnetip/readwrite/model/NLMUpdateKeyUpdate.go | 8 ++++----
plc4go/protocols/bacnetip/readwrite/model/NPDU.go | 8 ++++----
plc4go/protocols/cbus/readwrite/model/CALDataStatus.go | 4 ++--
.../cbus/readwrite/model/CALDataStatusExtended.go | 8 ++++----
.../model/IdentifyReplyCommandLogicalAssignment.go | 4 ++--
plc4go/protocols/cbus/readwrite/model/NetworkRoute.go | 4 ++--
.../cbus/readwrite/model/SecurityDataStatusReport1.go | 4 ++--
.../cbus/readwrite/model/SecurityDataStatusReport2.go | 4 ++--
plc4go/protocols/eip/readwrite/model/CIPAttributes.go | 4 ++--
plc4go/protocols/eip/readwrite/model/CipIdentity.go | 4 ++--
plc4go/protocols/eip/readwrite/model/CipRRData.go | 4 ++--
.../eip/readwrite/model/CipSecurityInformation.go | 4 ++--
.../eip/readwrite/model/EipListIdentityResponse.go | 4 ++--
.../eip/readwrite/model/ListServicesResponse.go | 4 ++--
.../eip/readwrite/model/MultipleServiceResponse.go | 4 ++--
plc4go/protocols/eip/readwrite/model/SendUnitData.go | 4 ++--
plc4go/protocols/eip/readwrite/model/Services.go | 8 ++++----
.../firmata/readwrite/model/FirmataMessageAnalogIO.go | 4 ++--
.../firmata/readwrite/model/FirmataMessageDigitalIO.go | 4 ++--
.../firmata/readwrite/model/SysexCommandExtendedId.go | 4 ++--
.../readwrite/model/ComObjectTableRealisationType1.go | 4 ++--
.../readwrite/model/ComObjectTableRealisationType2.go | 4 ++--
.../model/ModbusPDUReadDeviceIdentificationResponse.go | 4 ++--
.../readwrite/model/ModbusPDUReadFifoQueueResponse.go | 4 ++--
.../opcua/readwrite/model/ActivateSessionRequest.go | 8 ++++----
.../opcua/readwrite/model/ActivateSessionResponse.go | 8 ++++----
.../protocols/opcua/readwrite/model/AddNodesRequest.go | 4 ++--
.../protocols/opcua/readwrite/model/AddNodesResponse.go | 8 ++++----
.../opcua/readwrite/model/AddReferencesRequest.go | 4 ++--
.../opcua/readwrite/model/AddReferencesResponse.go | 8 ++++----
.../opcua/readwrite/model/AdditionalParametersType.go | 4 ++--
.../protocols/opcua/readwrite/model/AliasNameDataType.go | 4 ++--
.../opcua/readwrite/model/ApplicationDescription.go | 4 ++--
plc4go/protocols/opcua/readwrite/model/Argument.go | 4 ++--
.../protocols/opcua/readwrite/model/AxisInformation.go | 4 ++--
.../protocols/opcua/readwrite/model/BrowseNextRequest.go | 4 ++--
.../opcua/readwrite/model/BrowseNextResponse.go | 8 ++++----
.../protocols/opcua/readwrite/model/BrowsePathResult.go | 4 ++--
plc4go/protocols/opcua/readwrite/model/BrowseRequest.go | 4 ++--
plc4go/protocols/opcua/readwrite/model/BrowseResponse.go | 8 ++++----
plc4go/protocols/opcua/readwrite/model/BrowseResult.go | 4 ++--
.../protocols/opcua/readwrite/model/ByteStringArray.go | 4 ++--
.../protocols/opcua/readwrite/model/CallMethodRequest.go | 4 ++--
.../protocols/opcua/readwrite/model/CallMethodResult.go | 12 ++++++------
plc4go/protocols/opcua/readwrite/model/CallRequest.go | 4 ++--
plc4go/protocols/opcua/readwrite/model/CallResponse.go | 8 ++++----
plc4go/protocols/opcua/readwrite/model/ContentFilter.go | 4 ++--
.../opcua/readwrite/model/ContentFilterElement.go | 4 ++--
.../opcua/readwrite/model/ContentFilterElementResult.go | 8 ++++----
.../opcua/readwrite/model/ContentFilterResult.go | 8 ++++----
.../opcua/readwrite/model/CreateMonitoredItemsRequest.go | 4 ++--
.../readwrite/model/CreateMonitoredItemsResponse.go | 8 ++++----
.../opcua/readwrite/model/CreateSessionResponse.go | 8 ++++----
.../opcua/readwrite/model/DataChangeNotification.go | 8 ++++----
.../opcua/readwrite/model/DataSetWriterDataType.go | 4 ++--
.../opcua/readwrite/model/DataTypeSchemaHeader.go | 16 ++++++++--------
.../opcua/readwrite/model/DeleteMonitoredItemsRequest.go | 4 ++--
.../readwrite/model/DeleteMonitoredItemsResponse.go | 8 ++++----
.../opcua/readwrite/model/DeleteNodesRequest.go | 4 ++--
.../opcua/readwrite/model/DeleteNodesResponse.go | 8 ++++----
.../opcua/readwrite/model/DeleteReferencesRequest.go | 4 ++--
.../opcua/readwrite/model/DeleteReferencesResponse.go | 8 ++++----
.../opcua/readwrite/model/DeleteSubscriptionsRequest.go | 4 ++--
.../opcua/readwrite/model/DeleteSubscriptionsResponse.go | 8 ++++----
.../opcua/readwrite/model/EndpointDescription.go | 4 ++--
.../opcua/readwrite/model/EndpointUrlListDataType.go | 4 ++--
plc4go/protocols/opcua/readwrite/model/EventFieldList.go | 4 ++--
.../opcua/readwrite/model/EventNotificationList.go | 4 ++--
plc4go/protocols/opcua/readwrite/model/FieldMetaData.go | 8 ++++----
.../opcua/readwrite/model/FindServersOnNetworkRequest.go | 4 ++--
.../readwrite/model/FindServersOnNetworkResponse.go | 4 ++--
.../opcua/readwrite/model/FindServersRequest.go | 8 ++++----
.../opcua/readwrite/model/FindServersResponse.go | 4 ++--
.../opcua/readwrite/model/GetEndpointsRequest.go | 8 ++++----
.../opcua/readwrite/model/GetEndpointsResponse.go | 4 ++--
plc4go/protocols/opcua/readwrite/model/HistoryData.go | 4 ++--
plc4go/protocols/opcua/readwrite/model/HistoryEvent.go | 4 ++--
.../opcua/readwrite/model/HistoryEventFieldList.go | 4 ++--
.../opcua/readwrite/model/HistoryReadRequest.go | 4 ++--
.../opcua/readwrite/model/HistoryReadResponse.go | 8 ++++----
.../opcua/readwrite/model/HistoryUpdateRequest.go | 4 ++--
.../opcua/readwrite/model/HistoryUpdateResponse.go | 8 ++++----
.../opcua/readwrite/model/HistoryUpdateResult.go | 8 ++++----
.../opcua/readwrite/model/ModifyMonitoredItemsRequest.go | 4 ++--
.../readwrite/model/ModifyMonitoredItemsResponse.go | 8 ++++----
.../opcua/readwrite/model/NetworkGroupDataType.go | 4 ++--
plc4go/protocols/opcua/readwrite/model/Node.go | 12 ++++++------
plc4go/protocols/opcua/readwrite/model/NodeReference.go | 4 ++--
.../opcua/readwrite/model/NodeTypeDescription.go | 4 ++--
.../opcua/readwrite/model/NotificationMessage.go | 4 ++--
plc4go/protocols/opcua/readwrite/model/ParsingResult.go | 8 ++++----
.../opcua/readwrite/model/ProgramDiagnostic2DataType.go | 16 ++++++++--------
.../opcua/readwrite/model/ProgramDiagnosticDataType.go | 8 ++++----
.../opcua/readwrite/model/PubSubConfigurationDataType.go | 8 ++++----
.../opcua/readwrite/model/PubSubConnectionDataType.go | 12 ++++++------
.../opcua/readwrite/model/PubSubGroupDataType.go | 8 ++++----
plc4go/protocols/opcua/readwrite/model/PublishRequest.go | 4 ++--
.../protocols/opcua/readwrite/model/PublishResponse.go | 12 ++++++------
.../opcua/readwrite/model/PublishedVariableDataType.go | 4 ++--
plc4go/protocols/opcua/readwrite/model/QueryDataSet.go | 4 ++--
.../protocols/opcua/readwrite/model/QueryFirstRequest.go | 4 ++--
.../opcua/readwrite/model/QueryFirstResponse.go | 12 ++++++------
.../protocols/opcua/readwrite/model/QueryNextResponse.go | 4 ++--
plc4go/protocols/opcua/readwrite/model/ReadRequest.go | 4 ++--
plc4go/protocols/opcua/readwrite/model/ReadResponse.go | 8 ++++----
.../opcua/readwrite/model/RegisterNodesRequest.go | 4 ++--
.../opcua/readwrite/model/RegisterNodesResponse.go | 4 ++--
.../opcua/readwrite/model/RegisterServer2Request.go | 4 ++--
.../opcua/readwrite/model/RegisterServer2Response.go | 8 ++++----
.../protocols/opcua/readwrite/model/RegisteredServer.go | 8 ++++----
plc4go/protocols/opcua/readwrite/model/RelativePath.go | 4 ++--
plc4go/protocols/opcua/readwrite/model/ResponseHeader.go | 4 ++--
.../protocols/opcua/readwrite/model/ServerOnNetwork.go | 4 ++--
.../opcua/readwrite/model/SessionDiagnosticsDataType.go | 4 ++--
.../model/SessionSecurityDiagnosticsDataType.go | 4 ++--
.../readwrite/model/SessionlessInvokeRequestType.go | 12 ++++++------
.../readwrite/model/SessionlessInvokeResponseType.go | 8 ++++----
.../opcua/readwrite/model/SetMonitoringModeRequest.go | 4 ++--
.../opcua/readwrite/model/SetMonitoringModeResponse.go | 8 ++++----
.../opcua/readwrite/model/SetPublishingModeRequest.go | 4 ++--
.../opcua/readwrite/model/SetPublishingModeResponse.go | 8 ++++----
.../opcua/readwrite/model/SetTriggeringRequest.go | 8 ++++----
.../opcua/readwrite/model/SetTriggeringResponse.go | 16 ++++++++--------
plc4go/protocols/opcua/readwrite/model/StructureField.go | 4 ++--
plc4go/protocols/opcua/readwrite/model/TransferResult.go | 4 ++--
.../readwrite/model/TransferSubscriptionsRequest.go | 4 ++--
.../readwrite/model/TransferSubscriptionsResponse.go | 8 ++++----
.../model/TranslateBrowsePathsToNodeIdsRequest.go | 4 ++--
.../model/TranslateBrowsePathsToNodeIdsResponse.go | 8 ++++----
.../protocols/opcua/readwrite/model/TrustListDataType.go | 16 ++++++++--------
.../opcua/readwrite/model/UnregisterNodesRequest.go | 4 ++--
plc4go/protocols/opcua/readwrite/model/Variant.go | 4 ++--
plc4go/protocols/opcua/readwrite/model/VariantByte.go | 4 ++--
.../protocols/opcua/readwrite/model/VariantByteString.go | 4 ++--
.../protocols/opcua/readwrite/model/VariantDataValue.go | 4 ++--
.../protocols/opcua/readwrite/model/VariantDateTime.go | 4 ++--
.../opcua/readwrite/model/VariantDiagnosticInfo.go | 4 ++--
plc4go/protocols/opcua/readwrite/model/VariantDouble.go | 4 ++--
.../opcua/readwrite/model/VariantExpandedNodeId.go | 4 ++--
.../opcua/readwrite/model/VariantExtensionObject.go | 4 ++--
plc4go/protocols/opcua/readwrite/model/VariantFloat.go | 4 ++--
plc4go/protocols/opcua/readwrite/model/VariantGuid.go | 4 ++--
plc4go/protocols/opcua/readwrite/model/VariantInt16.go | 4 ++--
plc4go/protocols/opcua/readwrite/model/VariantInt32.go | 4 ++--
plc4go/protocols/opcua/readwrite/model/VariantInt64.go | 4 ++--
.../opcua/readwrite/model/VariantLocalizedText.go | 4 ++--
plc4go/protocols/opcua/readwrite/model/VariantNodeId.go | 4 ++--
.../opcua/readwrite/model/VariantQualifiedName.go | 4 ++--
.../protocols/opcua/readwrite/model/VariantStatusCode.go | 4 ++--
plc4go/protocols/opcua/readwrite/model/VariantString.go | 4 ++--
plc4go/protocols/opcua/readwrite/model/VariantUInt16.go | 4 ++--
plc4go/protocols/opcua/readwrite/model/VariantUInt32.go | 4 ++--
plc4go/protocols/opcua/readwrite/model/VariantUInt64.go | 4 ++--
plc4go/protocols/opcua/readwrite/model/VariantVariant.go | 4 ++--
.../protocols/opcua/readwrite/model/VariantXmlElement.go | 4 ++--
plc4go/protocols/opcua/readwrite/model/WriteRequest.go | 4 ++--
plc4go/protocols/opcua/readwrite/model/WriteResponse.go | 8 ++++----
plc4go/protocols/opcua/readwrite/model/XmlElement.go | 4 ++--
.../s7/readwrite/model/Alarm8MessageQueryType.go | 4 ++--
.../s7/readwrite/model/AlarmMessageAckPushType.go | 4 ++--
.../s7/readwrite/model/AlarmMessageAckResponseType.go | 4 ++--
.../protocols/s7/readwrite/model/AlarmMessageAckType.go | 4 ++--
.../s7/readwrite/model/AlarmMessageObjectPushType.go | 4 ++--
.../protocols/s7/readwrite/model/AlarmMessagePushType.go | 4 ++--
.../s7/readwrite/model/AlarmMessageQueryType.go | 4 ++--
.../s7/readwrite/model/AssociatedQueryValueType.go | 4 ++--
.../protocols/s7/readwrite/model/AssociatedValueType.go | 4 ++--
.../s7/readwrite/model/CycServiceItemDbReadType.go | 4 ++--
.../s7/readwrite/model/S7ParameterReadVarRequest.go | 4 ++--
.../protocols/s7/readwrite/model/S7ParameterUserData.go | 4 ++--
.../s7/readwrite/model/S7ParameterWriteVarRequest.go | 4 ++--
.../s7/readwrite/model/S7PayloadReadVarResponse.go | 4 ++--
plc4go/protocols/s7/readwrite/model/S7PayloadUserData.go | 4 ++--
.../S7PayloadUserDataItemCpuFunctionAlarmAckRequest.go | 4 ++--
.../S7PayloadUserDataItemCpuFunctionAlarmAckResponse.go | 4 ++--
...7PayloadUserDataItemCyclicServicesChangeDrivenPush.go | 4 ++--
...ataItemCyclicServicesChangeDrivenSubscribeResponse.go | 4 ++--
.../model/S7PayloadUserDataItemCyclicServicesPush.go | 4 ++--
...7PayloadUserDataItemCyclicServicesSubscribeRequest.go | 4 ++--
...PayloadUserDataItemCyclicServicesSubscribeResponse.go | 4 ++--
.../s7/readwrite/model/S7PayloadWriteVarRequest.go | 4 ++--
.../s7/readwrite/model/S7PayloadWriteVarResponse.go | 4 ++--
198 files changed, 534 insertions(+), 534 deletions(-)
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 3a2db77fe6..d03ecbe529 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)}, ${helper.toIntegerParseExpression(arrayField, 16, arrayField.loopExpression, parserArguments)})
+ ${arrayField.name} := make(${helper.getLanguageTypeNameForField(field)}, utils.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(${helper.toIntegerParseExpression(arrayField, 16, arrayField.loopExpression, parserArguments)})
+ _numItems := uint16(utils.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/protocols/abeth/readwrite/model/CIPEncapsulationPacket.go b/plc4go/protocols/abeth/readwrite/model/CIPEncapsulationPacket.go
index ad55008a22..0063bd7f47 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, uint16(8))
+ senderContext := make([]uint8, utils.Max(uint16(8), 0))
// This happens when the size is set conditional to 0
if len(senderContext) == 0 {
senderContext = nil
}
{
- _numItems := uint16(uint16(8))
+ _numItems := uint16(utils.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 a308ef07fd..fa97fc3415 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, numBlocks)
+ blocks := make([]AdsDiscoveryBlock, utils.Max(numBlocks, 0))
// This happens when the size is set conditional to 0
if len(blocks) == 0 {
blocks = nil
}
{
- _numItems := uint16(numBlocks)
+ _numItems := uint16(utils.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 9cd8ef48d2..52347df328 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, arrayDimensions)
+ arrayInfo := make([]AdsDataTypeArrayInfo, utils.Max(arrayDimensions, 0))
// This happens when the size is set conditional to 0
if len(arrayInfo) == 0 {
arrayInfo = nil
}
{
- _numItems := uint16(arrayDimensions)
+ _numItems := uint16(utils.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, numChildren)
+ children := make([]AdsDataTypeTableEntry, utils.Max(numChildren, 0))
// This happens when the size is set conditional to 0
if len(children) == 0 {
children = nil
}
{
- _numItems := uint16(numChildren)
+ _numItems := uint16(utils.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 ff8e819755..08795a4c35 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, arrayDimensions)
+ arrayInfo := make([]AdsDataTypeArrayInfo, utils.Max(arrayDimensions, 0))
// This happens when the size is set conditional to 0
if len(arrayInfo) == 0 {
arrayInfo = nil
}
{
- _numItems := uint16(arrayDimensions)
+ _numItems := uint16(utils.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, numChildren)
+ children := make([]AdsDataTypeTableChildEntry, utils.Max(numChildren, 0))
// This happens when the size is set conditional to 0
if len(children) == 0 {
children = nil
}
{
- _numItems := uint16(numChildren)
+ _numItems := uint16(utils.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 65c91d4785..0612228fe5 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, stamps)
+ adsStampHeaders := make([]AdsStampHeader, utils.Max(stamps, 0))
// This happens when the size is set conditional to 0
if len(adsStampHeaders) == 0 {
adsStampHeaders = nil
}
{
- _numItems := uint16(stamps)
+ _numItems := uint16(utils.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 e332d4b31f..807daa857a 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.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))
+ 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))
// This happens when the size is set conditional to 0
if len(items) == 0 {
items = nil
}
{
- _numItems := uint16(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))
+ _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))
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 8a1ae401f3..e5e0ae8781 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, samples)
+ adsNotificationSamples := make([]AdsNotificationSample, utils.Max(samples, 0))
// This happens when the size is set conditional to 0
if len(adsNotificationSamples) == 0 {
adsNotificationSamples = nil
}
{
- _numItems := uint16(samples)
+ _numItems := uint16(utils.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 d3ea2019b8..bd40b23974 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, returnedRecordCount.GetPayload().GetActualValue())
+ fileRecordData := make([]BACnetApplicationTagOctetString, utils.Max(returnedRecordCount.GetPayload().GetActualValue(), 0))
// This happens when the size is set conditional to 0
if len(fileRecordData) == 0 {
fileRecordData = nil
}
{
- _numItems := uint16(returnedRecordCount.GetPayload().GetActualValue())
+ _numItems := uint16(utils.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 7f537f05cb..5ea4b0616d 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, uint16((uint16((uint16(actualLength)-uint16(uint16(1))))*uint16(uint16(8))))-uint16(unusedBits))
+ data := make([]bool, utils.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(uint16((uint16((uint16(actualLength) - uint16(uint16(1)))) * uint16(uint16(8)))) - uint16(unusedBits))
+ _numItems := uint16(utils.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, unusedBits)
+ unused := make([]bool, utils.Max(unusedBits, 0))
// This happens when the size is set conditional to 0
if len(unused) == 0 {
unused = nil
}
{
- _numItems := uint16(unusedBits)
+ _numItems := uint16(utils.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/BVLCBroadcastDistributionTableEntry.go b/plc4go/protocols/bacnetip/readwrite/model/BVLCBroadcastDistributionTableEntry.go
index c683ca551e..699be43e3b 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, uint16(4))
+ ip := make([]uint8, utils.Max(uint16(4), 0))
// This happens when the size is set conditional to 0
if len(ip) == 0 {
ip = nil
}
{
- _numItems := uint16(uint16(4))
+ _numItems := uint16(utils.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, uint16(4))
+ broadcastDistributionMap := make([]uint8, utils.Max(uint16(4), 0))
// This happens when the size is set conditional to 0
if len(broadcastDistributionMap) == 0 {
broadcastDistributionMap = nil
}
{
- _numItems := uint16(uint16(4))
+ _numItems := uint16(utils.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 4efeead489..a21763939f 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, uint16(4))
+ ip := make([]uint8, utils.Max(uint16(4), 0))
// This happens when the size is set conditional to 0
if len(ip) == 0 {
ip = nil
}
{
- _numItems := uint16(uint16(4))
+ _numItems := uint16(utils.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 114772894d..ef4889fb5d 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, uint16(4))
+ ip := make([]uint8, utils.Max(uint16(4), 0))
// This happens when the size is set conditional to 0
if len(ip) == 0 {
ip = nil
}
{
- _numItems := uint16(uint16(4))
+ _numItems := uint16(utils.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 4d8f500f13..f84ef80416 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, uint16(4))
+ ip := make([]uint8, utils.Max(uint16(4), 0))
// This happens when the size is set conditional to 0
if len(ip) == 0 {
ip = nil
}
{
- _numItems := uint16(uint16(4))
+ _numItems := uint16(utils.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 46aa660ecc..a8e8c21e4c 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, numberOfPorts)
+ portMappings := make([]NLMInitalizeRoutingTablePortMapping, utils.Max(numberOfPorts, 0))
// This happens when the size is set conditional to 0
if len(portMappings) == 0 {
portMappings = nil
}
{
- _numItems := uint16(numberOfPorts)
+ _numItems := uint16(utils.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 e14fc50945..970ea2102b 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, numberOfPorts)
+ portMappings := make([]NLMInitalizeRoutingTablePortMapping, utils.Max(numberOfPorts, 0))
// This happens when the size is set conditional to 0
if len(portMappings) == 0 {
portMappings = nil
}
{
- _numItems := uint16(numberOfPorts)
+ _numItems := uint16(utils.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 b551cc926d..2cd8176ac0 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.InlineIf(bool((set1KeyCount) != (nil)), func() any { return uint16((*set1KeyCount)) }, func() any { return uint16(uint16(0)) }).(uint16))
+ set1Keys := make([]NLMUpdateKeyUpdateKeyEntry, utils.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.InlineIf(bool((set1KeyCount) != (nil)), func() any { return uint16((*set1KeyCount)) }, func() any { return uint16(uint16(0)) }).(uint16))
+ _numItems := uint16(utils.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.InlineIf(bool((set1KeyCount) != (nil)), func() any { return uint16((*set1KeyCount)) }, func() any { return uint16(uint16(0)) }).(uint16))
+ set2Keys := make([]NLMUpdateKeyUpdateKeyEntry, utils.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.InlineIf(bool((set1KeyCount) != (nil)), func() any { return uint16((*set1KeyCount)) }, func() any { return uint16(uint16(0)) }).(uint16))
+ _numItems := uint16(utils.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 090afeafc0..8263166811 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.InlineIf(control.GetDestinationSpecified(), func() any { return uint16((*destinationLength)) }, func() any { return uint16(uint16(0)) }).(uint16))
+ destinationAddress := make([]uint8, utils.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.InlineIf(control.GetDestinationSpecified(), func() any { return uint16((*destinationLength)) }, func() any { return uint16(uint16(0)) }).(uint16))
+ _numItems := uint16(utils.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.InlineIf(control.GetSourceSpecified(), func() any { return uint16((*sourceLength)) }, func() any { return uint16(uint16(0)) }).(uint16))
+ sourceAddress := make([]uint8, utils.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.InlineIf(control.GetSourceSpecified(), func() any { return uint16((*sourceLength)) }, func() any { return uint16(uint16(0)) }).(uint16))
+ _numItems := uint16(utils.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 364cec0939..545895c1ef 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, uint16(commandTypeContainer.NumBytes())-uint16(uint16(2)))
+ statusBytes := make([]StatusByte, utils.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(uint16(commandTypeContainer.NumBytes()) - uint16(uint16(2)))
+ _numItems := uint16(utils.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 22ee5feaf0..4a94462137 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, numberOfStatusBytes)
+ statusBytes := make([]StatusByte, utils.Max(numberOfStatusBytes, 0))
// This happens when the size is set conditional to 0
if len(statusBytes) == 0 {
statusBytes = nil
}
{
- _numItems := uint16(numberOfStatusBytes)
+ _numItems := uint16(utils.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, numberOfLevelInformation)
+ levelInformation := make([]LevelInformation, utils.Max(numberOfLevelInformation, 0))
// This happens when the size is set conditional to 0
if len(levelInformation) == 0 {
levelInformation = nil
}
{
- _numItems := uint16(numberOfLevelInformation)
+ _numItems := uint16(utils.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 726a5e8e06..55ebba2dbb 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, numBytes)
+ logicAssigment := make([]LogicAssignment, utils.Max(numBytes, 0))
// This happens when the size is set conditional to 0
if len(logicAssigment) == 0 {
logicAssigment = nil
}
{
- _numItems := uint16(numBytes)
+ _numItems := uint16(utils.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 266f7f784e..98480aacc5 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, uint16(networkPCI.GetStackDepth())-uint16(uint16(1)))
+ additionalBridgeAddresses := make([]BridgeAddress, utils.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(uint16(networkPCI.GetStackDepth()) - uint16(uint16(1)))
+ _numItems := uint16(utils.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 f00ae269b9..b8c05b8d6c 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, uint16(32))
+ zoneStatus := make([]ZoneStatus, utils.Max(uint16(32), 0))
// This happens when the size is set conditional to 0
if len(zoneStatus) == 0 {
zoneStatus = nil
}
{
- _numItems := uint16(uint16(32))
+ _numItems := uint16(utils.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 a3eb518a3e..a757e11e77 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, uint16(48))
+ zoneStatus := make([]ZoneStatus, utils.Max(uint16(48), 0))
// This happens when the size is set conditional to 0
if len(zoneStatus) == 0 {
zoneStatus = nil
}
{
- _numItems := uint16(uint16(48))
+ _numItems := uint16(utils.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 536e0860fa..5b251f9cd9 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, numberOfClasses)
+ classId := make([]uint16, utils.Max(numberOfClasses, 0))
// This happens when the size is set conditional to 0
if len(classId) == 0 {
classId = nil
}
{
- _numItems := uint16(numberOfClasses)
+ _numItems := uint16(utils.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 41618ed7d9..6201ec89df 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, uint16(4))
+ socketAddressAddress := make([]uint8, utils.Max(uint16(4), 0))
// This happens when the size is set conditional to 0
if len(socketAddressAddress) == 0 {
socketAddressAddress = nil
}
{
- _numItems := uint16(uint16(4))
+ _numItems := uint16(utils.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 7d254395cc..80f059c046 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, typeIdCount)
+ typeIds := make([]TypeId, utils.Max(typeIdCount, 0))
// This happens when the size is set conditional to 0
if len(typeIds) == 0 {
typeIds = nil
}
{
- _numItems := uint16(typeIdCount)
+ _numItems := uint16(utils.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 d95aa47dfd..c48b5a7adf 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, itemLength)
+ todoImplement := make([]uint8, utils.Max(itemLength, 0))
// This happens when the size is set conditional to 0
if len(todoImplement) == 0 {
todoImplement = nil
}
{
- _numItems := uint16(itemLength)
+ _numItems := uint16(utils.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 efdc3e8689..7622174fbb 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, itemCount)
+ items := make([]CommandSpecificDataItem, utils.Max(itemCount, 0))
// This happens when the size is set conditional to 0
if len(items) == 0 {
items = nil
}
{
- _numItems := uint16(itemCount)
+ _numItems := uint16(utils.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 3f8658ec39..adeef4cde5 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, typeIdCount)
+ typeIds := make([]TypeId, utils.Max(typeIdCount, 0))
// This happens when the size is set conditional to 0
if len(typeIds) == 0 {
typeIds = nil
}
{
- _numItems := uint16(typeIdCount)
+ _numItems := uint16(utils.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 95f5afd3f6..6a8b1eb10d 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, serviceNb)
+ offsets := make([]uint16, utils.Max(serviceNb, 0))
// This happens when the size is set conditional to 0
if len(offsets) == 0 {
offsets = nil
}
{
- _numItems := uint16(serviceNb)
+ _numItems := uint16(utils.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 b3bb67672e..d1624ab68b 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, typeIdCount)
+ typeIds := make([]TypeId, utils.Max(typeIdCount, 0))
// This happens when the size is set conditional to 0
if len(typeIds) == 0 {
typeIds = nil
}
{
- _numItems := uint16(typeIdCount)
+ _numItems := uint16(utils.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 d3009b1ced..2644b5c7af 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, serviceNb)
+ offsets := make([]uint16, utils.Max(serviceNb, 0))
// This happens when the size is set conditional to 0
if len(offsets) == 0 {
offsets = nil
}
{
- _numItems := uint16(serviceNb)
+ _numItems := uint16(utils.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, serviceNb)
+ services := make([]CipService, utils.Max(serviceNb, 0))
// This happens when the size is set conditional to 0
if len(services) == 0 {
services = nil
}
{
- _numItems := uint16(serviceNb)
+ _numItems := uint16(utils.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 a548a33238..f158a34e31 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, uint16(2))
+ data := make([]int8, utils.Max(uint16(2), 0))
// This happens when the size is set conditional to 0
if len(data) == 0 {
data = nil
}
{
- _numItems := uint16(uint16(2))
+ _numItems := uint16(utils.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 0157acd9bf..83f561dc2d 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, uint16(2))
+ data := make([]int8, utils.Max(uint16(2), 0))
// This happens when the size is set conditional to 0
if len(data) == 0 {
data = nil
}
{
- _numItems := uint16(uint16(2))
+ _numItems := uint16(utils.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 f098d11a20..85866d8453 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, uint16(2))
+ id := make([]int8, utils.Max(uint16(2), 0))
// This happens when the size is set conditional to 0
if len(id) == 0 {
id = nil
}
{
- _numItems := uint16(uint16(2))
+ _numItems := uint16(utils.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 e57e2e5293..b9222fd8c0 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, numEntries)
+ comObjectDescriptors := make([]GroupObjectDescriptorRealisationType1, utils.Max(numEntries, 0))
// This happens when the size is set conditional to 0
if len(comObjectDescriptors) == 0 {
comObjectDescriptors = nil
}
{
- _numItems := uint16(numEntries)
+ _numItems := uint16(utils.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 3093eb2432..753afc4375 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, numEntries)
+ comObjectDescriptors := make([]GroupObjectDescriptorRealisationType2, utils.Max(numEntries, 0))
// This happens when the size is set conditional to 0
if len(comObjectDescriptors) == 0 {
comObjectDescriptors = nil
}
{
- _numItems := uint16(numEntries)
+ _numItems := uint16(utils.Max(numEntries, 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/ModbusPDUReadDeviceIdentificationResponse.go b/plc4go/protocols/modbus/readwrite/model/ModbusPDUReadDeviceIdentificationResponse.go
index b21a0d27d7..862c82748e 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, numberOfObjects)
+ objects := make([]ModbusDeviceInformationObject, utils.Max(numberOfObjects, 0))
// This happens when the size is set conditional to 0
if len(objects) == 0 {
objects = nil
}
{
- _numItems := uint16(numberOfObjects)
+ _numItems := uint16(utils.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 19deb72dd5..7e5fd05310 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, fifoCount)
+ fifoValue := make([]uint16, utils.Max(fifoCount, 0))
// This happens when the size is set conditional to 0
if len(fifoValue) == 0 {
fifoValue = nil
}
{
- _numItems := uint16(fifoCount)
+ _numItems := uint16(utils.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 5f4cf050c0..5a21b50087 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, noOfClientSoftwareCertificates)
+ clientSoftwareCertificates := make([]ExtensionObjectDefinition, utils.Max(noOfClientSoftwareCertificates, 0))
// This happens when the size is set conditional to 0
if len(clientSoftwareCertificates) == 0 {
clientSoftwareCertificates = nil
}
{
- _numItems := uint16(noOfClientSoftwareCertificates)
+ _numItems := uint16(utils.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, noOfLocaleIds)
+ localeIds := make([]PascalString, utils.Max(noOfLocaleIds, 0))
// This happens when the size is set conditional to 0
if len(localeIds) == 0 {
localeIds = nil
}
{
- _numItems := uint16(noOfLocaleIds)
+ _numItems := uint16(utils.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 0f0114982b..95d57ead92 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, noOfResults)
+ results := make([]StatusCode, utils.Max(noOfResults, 0))
// This happens when the size is set conditional to 0
if len(results) == 0 {
results = nil
}
{
- _numItems := uint16(noOfResults)
+ _numItems := uint16(utils.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, noOfDiagnosticInfos)
+ diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0))
// This happens when the size is set conditional to 0
if len(diagnosticInfos) == 0 {
diagnosticInfos = nil
}
{
- _numItems := uint16(noOfDiagnosticInfos)
+ _numItems := uint16(utils.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 3075df1139..b4ba7a9a99 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, noOfNodesToAdd)
+ nodesToAdd := make([]ExtensionObjectDefinition, utils.Max(noOfNodesToAdd, 0))
// This happens when the size is set conditional to 0
if len(nodesToAdd) == 0 {
nodesToAdd = nil
}
{
- _numItems := uint16(noOfNodesToAdd)
+ _numItems := uint16(utils.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 74cf3eb81b..7d015b2df1 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, noOfResults)
+ results := make([]ExtensionObjectDefinition, utils.Max(noOfResults, 0))
// This happens when the size is set conditional to 0
if len(results) == 0 {
results = nil
}
{
- _numItems := uint16(noOfResults)
+ _numItems := uint16(utils.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, noOfDiagnosticInfos)
+ diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0))
// This happens when the size is set conditional to 0
if len(diagnosticInfos) == 0 {
diagnosticInfos = nil
}
{
- _numItems := uint16(noOfDiagnosticInfos)
+ _numItems := uint16(utils.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 2697f0d7d2..9f4c85e1b5 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, noOfReferencesToAdd)
+ referencesToAdd := make([]ExtensionObjectDefinition, utils.Max(noOfReferencesToAdd, 0))
// This happens when the size is set conditional to 0
if len(referencesToAdd) == 0 {
referencesToAdd = nil
}
{
- _numItems := uint16(noOfReferencesToAdd)
+ _numItems := uint16(utils.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 0ffb134d86..9b790606da 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, noOfResults)
+ results := make([]StatusCode, utils.Max(noOfResults, 0))
// This happens when the size is set conditional to 0
if len(results) == 0 {
results = nil
}
{
- _numItems := uint16(noOfResults)
+ _numItems := uint16(utils.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, noOfDiagnosticInfos)
+ diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0))
// This happens when the size is set conditional to 0
if len(diagnosticInfos) == 0 {
diagnosticInfos = nil
}
{
- _numItems := uint16(noOfDiagnosticInfos)
+ _numItems := uint16(utils.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 994354fb7c..ef7ddace0a 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, noOfParameters)
+ parameters := make([]ExtensionObjectDefinition, utils.Max(noOfParameters, 0))
// This happens when the size is set conditional to 0
if len(parameters) == 0 {
parameters = nil
}
{
- _numItems := uint16(noOfParameters)
+ _numItems := uint16(utils.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 6097e7f490..4acbf01b5d 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, noOfReferencedNodes)
+ referencedNodes := make([]ExpandedNodeId, utils.Max(noOfReferencedNodes, 0))
// This happens when the size is set conditional to 0
if len(referencedNodes) == 0 {
referencedNodes = nil
}
{
- _numItems := uint16(noOfReferencedNodes)
+ _numItems := uint16(utils.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 7a03ae2efa..e19d6297ea 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, noOfDiscoveryUrls)
+ discoveryUrls := make([]PascalString, utils.Max(noOfDiscoveryUrls, 0))
// This happens when the size is set conditional to 0
if len(discoveryUrls) == 0 {
discoveryUrls = nil
}
{
- _numItems := uint16(noOfDiscoveryUrls)
+ _numItems := uint16(utils.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 d8485b4c90..a368b19951 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, noOfArrayDimensions)
+ arrayDimensions := make([]uint32, utils.Max(noOfArrayDimensions, 0))
// This happens when the size is set conditional to 0
if len(arrayDimensions) == 0 {
arrayDimensions = nil
}
{
- _numItems := uint16(noOfArrayDimensions)
+ _numItems := uint16(utils.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 9128fd5b6b..382505b831 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, noOfAxisSteps)
+ axisSteps := make([]float64, utils.Max(noOfAxisSteps, 0))
// This happens when the size is set conditional to 0
if len(axisSteps) == 0 {
axisSteps = nil
}
{
- _numItems := uint16(noOfAxisSteps)
+ _numItems := uint16(utils.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 51f170c700..eaca088b59 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, noOfContinuationPoints)
+ continuationPoints := make([]PascalByteString, utils.Max(noOfContinuationPoints, 0))
// This happens when the size is set conditional to 0
if len(continuationPoints) == 0 {
continuationPoints = nil
}
{
- _numItems := uint16(noOfContinuationPoints)
+ _numItems := uint16(utils.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 bb8b3391b1..325cb644d9 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, noOfResults)
+ results := make([]ExtensionObjectDefinition, utils.Max(noOfResults, 0))
// This happens when the size is set conditional to 0
if len(results) == 0 {
results = nil
}
{
- _numItems := uint16(noOfResults)
+ _numItems := uint16(utils.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, noOfDiagnosticInfos)
+ diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0))
// This happens when the size is set conditional to 0
if len(diagnosticInfos) == 0 {
diagnosticInfos = nil
}
{
- _numItems := uint16(noOfDiagnosticInfos)
+ _numItems := uint16(utils.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 730263debb..695fca7782 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, noOfTargets)
+ targets := make([]ExtensionObjectDefinition, utils.Max(noOfTargets, 0))
// This happens when the size is set conditional to 0
if len(targets) == 0 {
targets = nil
}
{
- _numItems := uint16(noOfTargets)
+ _numItems := uint16(utils.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 f2e55489f5..2b3e2aa49e 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, noOfNodesToBrowse)
+ nodesToBrowse := make([]ExtensionObjectDefinition, utils.Max(noOfNodesToBrowse, 0))
// This happens when the size is set conditional to 0
if len(nodesToBrowse) == 0 {
nodesToBrowse = nil
}
{
- _numItems := uint16(noOfNodesToBrowse)
+ _numItems := uint16(utils.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 b39709a73b..409911fa94 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, noOfResults)
+ results := make([]ExtensionObjectDefinition, utils.Max(noOfResults, 0))
// This happens when the size is set conditional to 0
if len(results) == 0 {
results = nil
}
{
- _numItems := uint16(noOfResults)
+ _numItems := uint16(utils.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, noOfDiagnosticInfos)
+ diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0))
// This happens when the size is set conditional to 0
if len(diagnosticInfos) == 0 {
diagnosticInfos = nil
}
{
- _numItems := uint16(noOfDiagnosticInfos)
+ _numItems := uint16(utils.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 991436fe5e..b50cf01021 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, noOfReferences)
+ 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(noOfReferences)
+ _numItems := uint16(utils.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 1251cb7352..9ab27115a7 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, arrayLength)
+ value := make([]uint8, utils.Max(arrayLength, 0))
// This happens when the size is set conditional to 0
if len(value) == 0 {
value = nil
}
{
- _numItems := uint16(arrayLength)
+ _numItems := uint16(utils.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 62a86237c8..7f3092e6b7 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, noOfInputArguments)
+ inputArguments := make([]Variant, utils.Max(noOfInputArguments, 0))
// This happens when the size is set conditional to 0
if len(inputArguments) == 0 {
inputArguments = nil
}
{
- _numItems := uint16(noOfInputArguments)
+ _numItems := uint16(utils.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 768d5d676d..3a067cdfad 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, noOfInputArgumentResults)
+ inputArgumentResults := make([]StatusCode, utils.Max(noOfInputArgumentResults, 0))
// This happens when the size is set conditional to 0
if len(inputArgumentResults) == 0 {
inputArgumentResults = nil
}
{
- _numItems := uint16(noOfInputArgumentResults)
+ _numItems := uint16(utils.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, noOfInputArgumentDiagnosticInfos)
+ inputArgumentDiagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfInputArgumentDiagnosticInfos, 0))
// This happens when the size is set conditional to 0
if len(inputArgumentDiagnosticInfos) == 0 {
inputArgumentDiagnosticInfos = nil
}
{
- _numItems := uint16(noOfInputArgumentDiagnosticInfos)
+ _numItems := uint16(utils.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, noOfOutputArguments)
+ outputArguments := make([]Variant, utils.Max(noOfOutputArguments, 0))
// This happens when the size is set conditional to 0
if len(outputArguments) == 0 {
outputArguments = nil
}
{
- _numItems := uint16(noOfOutputArguments)
+ _numItems := uint16(utils.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 1628d39568..27a13500b5 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, noOfMethodsToCall)
+ methodsToCall := make([]ExtensionObjectDefinition, utils.Max(noOfMethodsToCall, 0))
// This happens when the size is set conditional to 0
if len(methodsToCall) == 0 {
methodsToCall = nil
}
{
- _numItems := uint16(noOfMethodsToCall)
+ _numItems := uint16(utils.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 bc11e3725d..edeac78625 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, noOfResults)
+ results := make([]ExtensionObjectDefinition, utils.Max(noOfResults, 0))
// This happens when the size is set conditional to 0
if len(results) == 0 {
results = nil
}
{
- _numItems := uint16(noOfResults)
+ _numItems := uint16(utils.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, noOfDiagnosticInfos)
+ diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0))
// This happens when the size is set conditional to 0
if len(diagnosticInfos) == 0 {
diagnosticInfos = nil
}
{
- _numItems := uint16(noOfDiagnosticInfos)
+ _numItems := uint16(utils.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 9cfd992480..4bc69f3b9c 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, noOfElements)
+ elements := make([]ExtensionObjectDefinition, utils.Max(noOfElements, 0))
// This happens when the size is set conditional to 0
if len(elements) == 0 {
elements = nil
}
{
- _numItems := uint16(noOfElements)
+ _numItems := uint16(utils.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 caab57db97..4f0086e2db 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, noOfFilterOperands)
+ filterOperands := make([]ExtensionObject, utils.Max(noOfFilterOperands, 0))
// This happens when the size is set conditional to 0
if len(filterOperands) == 0 {
filterOperands = nil
}
{
- _numItems := uint16(noOfFilterOperands)
+ _numItems := uint16(utils.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 b1b7606566..3c1afbd75b 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, noOfOperandStatusCodes)
+ operandStatusCodes := make([]StatusCode, utils.Max(noOfOperandStatusCodes, 0))
// This happens when the size is set conditional to 0
if len(operandStatusCodes) == 0 {
operandStatusCodes = nil
}
{
- _numItems := uint16(noOfOperandStatusCodes)
+ _numItems := uint16(utils.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, noOfOperandDiagnosticInfos)
+ operandDiagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfOperandDiagnosticInfos, 0))
// This happens when the size is set conditional to 0
if len(operandDiagnosticInfos) == 0 {
operandDiagnosticInfos = nil
}
{
- _numItems := uint16(noOfOperandDiagnosticInfos)
+ _numItems := uint16(utils.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 64b57608bb..fb2b9517ad 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, noOfElementResults)
+ elementResults := make([]ExtensionObjectDefinition, utils.Max(noOfElementResults, 0))
// This happens when the size is set conditional to 0
if len(elementResults) == 0 {
elementResults = nil
}
{
- _numItems := uint16(noOfElementResults)
+ _numItems := uint16(utils.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, noOfElementDiagnosticInfos)
+ elementDiagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfElementDiagnosticInfos, 0))
// This happens when the size is set conditional to 0
if len(elementDiagnosticInfos) == 0 {
elementDiagnosticInfos = nil
}
{
- _numItems := uint16(noOfElementDiagnosticInfos)
+ _numItems := uint16(utils.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 dd60f70f20..d7c47562fd 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, noOfItemsToCreate)
+ itemsToCreate := make([]ExtensionObjectDefinition, utils.Max(noOfItemsToCreate, 0))
// This happens when the size is set conditional to 0
if len(itemsToCreate) == 0 {
itemsToCreate = nil
}
{
- _numItems := uint16(noOfItemsToCreate)
+ _numItems := uint16(utils.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 cdff7c2316..2ce76ee672 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, noOfResults)
+ results := make([]ExtensionObjectDefinition, utils.Max(noOfResults, 0))
// This happens when the size is set conditional to 0
if len(results) == 0 {
results = nil
}
{
- _numItems := uint16(noOfResults)
+ _numItems := uint16(utils.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, noOfDiagnosticInfos)
+ diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0))
// This happens when the size is set conditional to 0
if len(diagnosticInfos) == 0 {
diagnosticInfos = nil
}
{
- _numItems := uint16(noOfDiagnosticInfos)
+ _numItems := uint16(utils.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 b922606f42..2a8660c347 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, noOfServerEndpoints)
+ serverEndpoints := make([]ExtensionObjectDefinition, utils.Max(noOfServerEndpoints, 0))
// This happens when the size is set conditional to 0
if len(serverEndpoints) == 0 {
serverEndpoints = nil
}
{
- _numItems := uint16(noOfServerEndpoints)
+ _numItems := uint16(utils.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, noOfServerSoftwareCertificates)
+ serverSoftwareCertificates := make([]ExtensionObjectDefinition, utils.Max(noOfServerSoftwareCertificates, 0))
// This happens when the size is set conditional to 0
if len(serverSoftwareCertificates) == 0 {
serverSoftwareCertificates = nil
}
{
- _numItems := uint16(noOfServerSoftwareCertificates)
+ _numItems := uint16(utils.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 bc844fec6b..1d063a12c1 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, noOfMonitoredItems)
+ monitoredItems := make([]ExtensionObjectDefinition, utils.Max(noOfMonitoredItems, 0))
// This happens when the size is set conditional to 0
if len(monitoredItems) == 0 {
monitoredItems = nil
}
{
- _numItems := uint16(noOfMonitoredItems)
+ _numItems := uint16(utils.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, noOfDiagnosticInfos)
+ diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0))
// This happens when the size is set conditional to 0
if len(diagnosticInfos) == 0 {
diagnosticInfos = nil
}
{
- _numItems := uint16(noOfDiagnosticInfos)
+ _numItems := uint16(utils.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 b744bdc19b..286d6211f0 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, noOfDataSetWriterProperties)
+ dataSetWriterProperties := make([]ExtensionObjectDefinition, utils.Max(noOfDataSetWriterProperties, 0))
// This happens when the size is set conditional to 0
if len(dataSetWriterProperties) == 0 {
dataSetWriterProperties = nil
}
{
- _numItems := uint16(noOfDataSetWriterProperties)
+ _numItems := uint16(utils.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 8c1f841a83..0dd5012470 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, noOfNamespaces)
+ namespaces := make([]PascalString, utils.Max(noOfNamespaces, 0))
// This happens when the size is set conditional to 0
if len(namespaces) == 0 {
namespaces = nil
}
{
- _numItems := uint16(noOfNamespaces)
+ _numItems := uint16(utils.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, noOfStructureDataTypes)
+ structureDataTypes := make([]DataTypeDescription, utils.Max(noOfStructureDataTypes, 0))
// This happens when the size is set conditional to 0
if len(structureDataTypes) == 0 {
structureDataTypes = nil
}
{
- _numItems := uint16(noOfStructureDataTypes)
+ _numItems := uint16(utils.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, noOfEnumDataTypes)
+ enumDataTypes := make([]DataTypeDescription, utils.Max(noOfEnumDataTypes, 0))
// This happens when the size is set conditional to 0
if len(enumDataTypes) == 0 {
enumDataTypes = nil
}
{
- _numItems := uint16(noOfEnumDataTypes)
+ _numItems := uint16(utils.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, noOfSimpleDataTypes)
+ simpleDataTypes := make([]DataTypeDescription, utils.Max(noOfSimpleDataTypes, 0))
// This happens when the size is set conditional to 0
if len(simpleDataTypes) == 0 {
simpleDataTypes = nil
}
{
- _numItems := uint16(noOfSimpleDataTypes)
+ _numItems := uint16(utils.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 723d4ed226..5a85760499 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, noOfMonitoredItemIds)
+ monitoredItemIds := make([]uint32, utils.Max(noOfMonitoredItemIds, 0))
// This happens when the size is set conditional to 0
if len(monitoredItemIds) == 0 {
monitoredItemIds = nil
}
{
- _numItems := uint16(noOfMonitoredItemIds)
+ _numItems := uint16(utils.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 ddb6bddf5a..159f2c786d 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, noOfResults)
+ results := make([]StatusCode, utils.Max(noOfResults, 0))
// This happens when the size is set conditional to 0
if len(results) == 0 {
results = nil
}
{
- _numItems := uint16(noOfResults)
+ _numItems := uint16(utils.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, noOfDiagnosticInfos)
+ diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0))
// This happens when the size is set conditional to 0
if len(diagnosticInfos) == 0 {
diagnosticInfos = nil
}
{
- _numItems := uint16(noOfDiagnosticInfos)
+ _numItems := uint16(utils.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 104e092e86..d512f526e7 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, noOfNodesToDelete)
+ nodesToDelete := make([]ExtensionObjectDefinition, utils.Max(noOfNodesToDelete, 0))
// This happens when the size is set conditional to 0
if len(nodesToDelete) == 0 {
nodesToDelete = nil
}
{
- _numItems := uint16(noOfNodesToDelete)
+ _numItems := uint16(utils.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 b186f9a400..d45c11ab9c 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, noOfResults)
+ results := make([]StatusCode, utils.Max(noOfResults, 0))
// This happens when the size is set conditional to 0
if len(results) == 0 {
results = nil
}
{
- _numItems := uint16(noOfResults)
+ _numItems := uint16(utils.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, noOfDiagnosticInfos)
+ diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0))
// This happens when the size is set conditional to 0
if len(diagnosticInfos) == 0 {
diagnosticInfos = nil
}
{
- _numItems := uint16(noOfDiagnosticInfos)
+ _numItems := uint16(utils.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 b557ea38ac..e412827029 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, noOfReferencesToDelete)
+ referencesToDelete := make([]ExtensionObjectDefinition, utils.Max(noOfReferencesToDelete, 0))
// This happens when the size is set conditional to 0
if len(referencesToDelete) == 0 {
referencesToDelete = nil
}
{
- _numItems := uint16(noOfReferencesToDelete)
+ _numItems := uint16(utils.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 312faa0cdb..e794895df0 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, noOfResults)
+ results := make([]StatusCode, utils.Max(noOfResults, 0))
// This happens when the size is set conditional to 0
if len(results) == 0 {
results = nil
}
{
- _numItems := uint16(noOfResults)
+ _numItems := uint16(utils.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, noOfDiagnosticInfos)
+ diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0))
// This happens when the size is set conditional to 0
if len(diagnosticInfos) == 0 {
diagnosticInfos = nil
}
{
- _numItems := uint16(noOfDiagnosticInfos)
+ _numItems := uint16(utils.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 e29f16e68a..2ba4b70467 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, noOfSubscriptionIds)
+ subscriptionIds := make([]uint32, utils.Max(noOfSubscriptionIds, 0))
// This happens when the size is set conditional to 0
if len(subscriptionIds) == 0 {
subscriptionIds = nil
}
{
- _numItems := uint16(noOfSubscriptionIds)
+ _numItems := uint16(utils.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 5efaa3df67..5d31b18537 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, noOfResults)
+ results := make([]StatusCode, utils.Max(noOfResults, 0))
// This happens when the size is set conditional to 0
if len(results) == 0 {
results = nil
}
{
- _numItems := uint16(noOfResults)
+ _numItems := uint16(utils.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, noOfDiagnosticInfos)
+ diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0))
// This happens when the size is set conditional to 0
if len(diagnosticInfos) == 0 {
diagnosticInfos = nil
}
{
- _numItems := uint16(noOfDiagnosticInfos)
+ _numItems := uint16(utils.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 4ca612c38f..764f2a475d 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, noOfUserIdentityTokens)
+ userIdentityTokens := make([]ExtensionObjectDefinition, utils.Max(noOfUserIdentityTokens, 0))
// This happens when the size is set conditional to 0
if len(userIdentityTokens) == 0 {
userIdentityTokens = nil
}
{
- _numItems := uint16(noOfUserIdentityTokens)
+ _numItems := uint16(utils.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 4daae14dd2..4dcaaca0d7 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, noOfEndpointUrlList)
+ endpointUrlList := make([]PascalString, utils.Max(noOfEndpointUrlList, 0))
// This happens when the size is set conditional to 0
if len(endpointUrlList) == 0 {
endpointUrlList = nil
}
{
- _numItems := uint16(noOfEndpointUrlList)
+ _numItems := uint16(utils.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 f2fc7d4097..574f0ecadd 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, noOfEventFields)
+ eventFields := make([]Variant, utils.Max(noOfEventFields, 0))
// This happens when the size is set conditional to 0
if len(eventFields) == 0 {
eventFields = nil
}
{
- _numItems := uint16(noOfEventFields)
+ _numItems := uint16(utils.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 0eb97cdd43..277ee8715d 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, noOfEvents)
+ events := make([]ExtensionObjectDefinition, utils.Max(noOfEvents, 0))
// This happens when the size is set conditional to 0
if len(events) == 0 {
events = nil
}
{
- _numItems := uint16(noOfEvents)
+ _numItems := uint16(utils.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 37e713e497..123f9b9795 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, noOfArrayDimensions)
+ arrayDimensions := make([]uint32, utils.Max(noOfArrayDimensions, 0))
// This happens when the size is set conditional to 0
if len(arrayDimensions) == 0 {
arrayDimensions = nil
}
{
- _numItems := uint16(noOfArrayDimensions)
+ _numItems := uint16(utils.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, noOfProperties)
+ properties := make([]ExtensionObjectDefinition, utils.Max(noOfProperties, 0))
// This happens when the size is set conditional to 0
if len(properties) == 0 {
properties = nil
}
{
- _numItems := uint16(noOfProperties)
+ _numItems := uint16(utils.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 2c82e1c088..538123e62d 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, noOfServerCapabilityFilter)
+ serverCapabilityFilter := make([]PascalString, utils.Max(noOfServerCapabilityFilter, 0))
// This happens when the size is set conditional to 0
if len(serverCapabilityFilter) == 0 {
serverCapabilityFilter = nil
}
{
- _numItems := uint16(noOfServerCapabilityFilter)
+ _numItems := uint16(utils.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 651be68b39..9be489ed09 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, noOfServers)
+ servers := make([]ExtensionObjectDefinition, utils.Max(noOfServers, 0))
// This happens when the size is set conditional to 0
if len(servers) == 0 {
servers = nil
}
{
- _numItems := uint16(noOfServers)
+ _numItems := uint16(utils.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 b093128e25..59ba645d03 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, noOfLocaleIds)
+ localeIds := make([]PascalString, utils.Max(noOfLocaleIds, 0))
// This happens when the size is set conditional to 0
if len(localeIds) == 0 {
localeIds = nil
}
{
- _numItems := uint16(noOfLocaleIds)
+ _numItems := uint16(utils.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, noOfServerUris)
+ serverUris := make([]PascalString, utils.Max(noOfServerUris, 0))
// This happens when the size is set conditional to 0
if len(serverUris) == 0 {
serverUris = nil
}
{
- _numItems := uint16(noOfServerUris)
+ _numItems := uint16(utils.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 3bcdf39397..ad028dab3b 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, noOfServers)
+ servers := make([]ExtensionObjectDefinition, utils.Max(noOfServers, 0))
// This happens when the size is set conditional to 0
if len(servers) == 0 {
servers = nil
}
{
- _numItems := uint16(noOfServers)
+ _numItems := uint16(utils.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 4a1f4feda4..333f2d5eb1 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, noOfLocaleIds)
+ localeIds := make([]PascalString, utils.Max(noOfLocaleIds, 0))
// This happens when the size is set conditional to 0
if len(localeIds) == 0 {
localeIds = nil
}
{
- _numItems := uint16(noOfLocaleIds)
+ _numItems := uint16(utils.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, noOfProfileUris)
+ profileUris := make([]PascalString, utils.Max(noOfProfileUris, 0))
// This happens when the size is set conditional to 0
if len(profileUris) == 0 {
profileUris = nil
}
{
- _numItems := uint16(noOfProfileUris)
+ _numItems := uint16(utils.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 7dd76073b7..fa172ae142 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, noOfEndpoints)
+ endpoints := make([]ExtensionObjectDefinition, utils.Max(noOfEndpoints, 0))
// This happens when the size is set conditional to 0
if len(endpoints) == 0 {
endpoints = nil
}
{
- _numItems := uint16(noOfEndpoints)
+ _numItems := uint16(utils.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 5c708afbbd..91bcc513eb 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, noOfDataValues)
+ dataValues := make([]DataValue, utils.Max(noOfDataValues, 0))
// This happens when the size is set conditional to 0
if len(dataValues) == 0 {
dataValues = nil
}
{
- _numItems := uint16(noOfDataValues)
+ _numItems := uint16(utils.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 c8d47d66d3..35bdc10594 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, noOfEvents)
+ events := make([]ExtensionObjectDefinition, utils.Max(noOfEvents, 0))
// This happens when the size is set conditional to 0
if len(events) == 0 {
events = nil
}
{
- _numItems := uint16(noOfEvents)
+ _numItems := uint16(utils.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 36b1924f1e..e1dfaafbfc 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, noOfEventFields)
+ eventFields := make([]Variant, utils.Max(noOfEventFields, 0))
// This happens when the size is set conditional to 0
if len(eventFields) == 0 {
eventFields = nil
}
{
- _numItems := uint16(noOfEventFields)
+ _numItems := uint16(utils.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 3c28d544fa..5e855dde8f 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, noOfNodesToRead)
+ nodesToRead := make([]ExtensionObjectDefinition, utils.Max(noOfNodesToRead, 0))
// This happens when the size is set conditional to 0
if len(nodesToRead) == 0 {
nodesToRead = nil
}
{
- _numItems := uint16(noOfNodesToRead)
+ _numItems := uint16(utils.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 70bc68c576..86a16ece02 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, noOfResults)
+ results := make([]ExtensionObjectDefinition, utils.Max(noOfResults, 0))
// This happens when the size is set conditional to 0
if len(results) == 0 {
results = nil
}
{
- _numItems := uint16(noOfResults)
+ _numItems := uint16(utils.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, noOfDiagnosticInfos)
+ diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0))
// This happens when the size is set conditional to 0
if len(diagnosticInfos) == 0 {
diagnosticInfos = nil
}
{
- _numItems := uint16(noOfDiagnosticInfos)
+ _numItems := uint16(utils.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 e7a7e27c01..96957b24d0 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, noOfHistoryUpdateDetails)
+ historyUpdateDetails := make([]ExtensionObject, utils.Max(noOfHistoryUpdateDetails, 0))
// This happens when the size is set conditional to 0
if len(historyUpdateDetails) == 0 {
historyUpdateDetails = nil
}
{
- _numItems := uint16(noOfHistoryUpdateDetails)
+ _numItems := uint16(utils.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 f99e2aa3cb..2bbb5d87b6 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, noOfResults)
+ results := make([]ExtensionObjectDefinition, utils.Max(noOfResults, 0))
// This happens when the size is set conditional to 0
if len(results) == 0 {
results = nil
}
{
- _numItems := uint16(noOfResults)
+ _numItems := uint16(utils.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, noOfDiagnosticInfos)
+ diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0))
// This happens when the size is set conditional to 0
if len(diagnosticInfos) == 0 {
diagnosticInfos = nil
}
{
- _numItems := uint16(noOfDiagnosticInfos)
+ _numItems := uint16(utils.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 2aa471f905..3d97d343bc 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, noOfOperationResults)
+ operationResults := make([]StatusCode, utils.Max(noOfOperationResults, 0))
// This happens when the size is set conditional to 0
if len(operationResults) == 0 {
operationResults = nil
}
{
- _numItems := uint16(noOfOperationResults)
+ _numItems := uint16(utils.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, noOfDiagnosticInfos)
+ diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0))
// This happens when the size is set conditional to 0
if len(diagnosticInfos) == 0 {
diagnosticInfos = nil
}
{
- _numItems := uint16(noOfDiagnosticInfos)
+ _numItems := uint16(utils.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 dc12a2856b..197783ef25 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, noOfItemsToModify)
+ itemsToModify := make([]ExtensionObjectDefinition, utils.Max(noOfItemsToModify, 0))
// This happens when the size is set conditional to 0
if len(itemsToModify) == 0 {
itemsToModify = nil
}
{
- _numItems := uint16(noOfItemsToModify)
+ _numItems := uint16(utils.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 c6eaa21ffa..59ffaea8d6 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, noOfResults)
+ results := make([]ExtensionObjectDefinition, utils.Max(noOfResults, 0))
// This happens when the size is set conditional to 0
if len(results) == 0 {
results = nil
}
{
- _numItems := uint16(noOfResults)
+ _numItems := uint16(utils.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, noOfDiagnosticInfos)
+ diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0))
// This happens when the size is set conditional to 0
if len(diagnosticInfos) == 0 {
diagnosticInfos = nil
}
{
- _numItems := uint16(noOfDiagnosticInfos)
+ _numItems := uint16(utils.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 f932fb514f..bff4ec8af1 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, noOfNetworkPaths)
+ networkPaths := make([]ExtensionObjectDefinition, utils.Max(noOfNetworkPaths, 0))
// This happens when the size is set conditional to 0
if len(networkPaths) == 0 {
networkPaths = nil
}
{
- _numItems := uint16(noOfNetworkPaths)
+ _numItems := uint16(utils.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
index 4587643e09..9f8ca446f2 100644
--- a/plc4go/protocols/opcua/readwrite/model/Node.go
+++ b/plc4go/protocols/opcua/readwrite/model/Node.go
@@ -394,13 +394,13 @@ func NodeParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, ident
return nil, errors.Wrap(pullErr, "Error pulling for rolePermissions")
}
// Count array
- rolePermissions := make([]ExtensionObjectDefinition, noOfRolePermissions)
+ rolePermissions := make([]ExtensionObjectDefinition, utils.Max(noOfRolePermissions, 0))
// This happens when the size is set conditional to 0
if len(rolePermissions) == 0 {
rolePermissions = nil
}
{
- _numItems := uint16(noOfRolePermissions)
+ _numItems := uint16(utils.Max(noOfRolePermissions, 0))
for _curItem := uint16(0); _curItem < _numItems; _curItem++ {
arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem))
_ = arrayCtx
@@ -428,13 +428,13 @@ func NodeParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, ident
return nil, errors.Wrap(pullErr, "Error pulling for userRolePermissions")
}
// Count array
- userRolePermissions := make([]ExtensionObjectDefinition, noOfUserRolePermissions)
+ userRolePermissions := make([]ExtensionObjectDefinition, utils.Max(noOfUserRolePermissions, 0))
// This happens when the size is set conditional to 0
if len(userRolePermissions) == 0 {
userRolePermissions = nil
}
{
- _numItems := uint16(noOfUserRolePermissions)
+ _numItems := uint16(utils.Max(noOfUserRolePermissions, 0))
for _curItem := uint16(0); _curItem < _numItems; _curItem++ {
arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem))
_ = arrayCtx
@@ -469,13 +469,13 @@ func NodeParseWithBuffer(ctx context.Context, readBuffer utils.ReadBuffer, ident
return nil, errors.Wrap(pullErr, "Error pulling for references")
}
// Count array
- references := make([]ExtensionObjectDefinition, noOfReferences)
+ 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(noOfReferences)
+ _numItems := uint16(utils.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/NodeReference.go b/plc4go/protocols/opcua/readwrite/model/NodeReference.go
index be48cdc16e..0f5d8bd2d4 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, noOfReferencedNodeIds)
+ referencedNodeIds := make([]NodeId, utils.Max(noOfReferencedNodeIds, 0))
// This happens when the size is set conditional to 0
if len(referencedNodeIds) == 0 {
referencedNodeIds = nil
}
{
- _numItems := uint16(noOfReferencedNodeIds)
+ _numItems := uint16(utils.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 6b3965fa71..3da8a211dc 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, noOfDataToReturn)
+ dataToReturn := make([]ExtensionObjectDefinition, utils.Max(noOfDataToReturn, 0))
// This happens when the size is set conditional to 0
if len(dataToReturn) == 0 {
dataToReturn = nil
}
{
- _numItems := uint16(noOfDataToReturn)
+ _numItems := uint16(utils.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 f403d11a18..d1b37dce02 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, noOfNotificationData)
+ notificationData := make([]ExtensionObject, utils.Max(noOfNotificationData, 0))
// This happens when the size is set conditional to 0
if len(notificationData) == 0 {
notificationData = nil
}
{
- _numItems := uint16(noOfNotificationData)
+ _numItems := uint16(utils.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 b997c4cf99..6e212ce4ab 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, noOfDataStatusCodes)
+ dataStatusCodes := make([]StatusCode, utils.Max(noOfDataStatusCodes, 0))
// This happens when the size is set conditional to 0
if len(dataStatusCodes) == 0 {
dataStatusCodes = nil
}
{
- _numItems := uint16(noOfDataStatusCodes)
+ _numItems := uint16(utils.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, noOfDataDiagnosticInfos)
+ dataDiagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDataDiagnosticInfos, 0))
// This happens when the size is set conditional to 0
if len(dataDiagnosticInfos) == 0 {
dataDiagnosticInfos = nil
}
{
- _numItems := uint16(noOfDataDiagnosticInfos)
+ _numItems := uint16(utils.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 d3561ff765..e6827395a2 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, noOfLastMethodInputArguments)
+ lastMethodInputArguments := make([]ExtensionObjectDefinition, utils.Max(noOfLastMethodInputArguments, 0))
// This happens when the size is set conditional to 0
if len(lastMethodInputArguments) == 0 {
lastMethodInputArguments = nil
}
{
- _numItems := uint16(noOfLastMethodInputArguments)
+ _numItems := uint16(utils.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, noOfLastMethodOutputArguments)
+ lastMethodOutputArguments := make([]ExtensionObjectDefinition, utils.Max(noOfLastMethodOutputArguments, 0))
// This happens when the size is set conditional to 0
if len(lastMethodOutputArguments) == 0 {
lastMethodOutputArguments = nil
}
{
- _numItems := uint16(noOfLastMethodOutputArguments)
+ _numItems := uint16(utils.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, noOfLastMethodInputValues)
+ lastMethodInputValues := make([]Variant, utils.Max(noOfLastMethodInputValues, 0))
// This happens when the size is set conditional to 0
if len(lastMethodInputValues) == 0 {
lastMethodInputValues = nil
}
{
- _numItems := uint16(noOfLastMethodInputValues)
+ _numItems := uint16(utils.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, noOfLastMethodOutputValues)
+ lastMethodOutputValues := make([]Variant, utils.Max(noOfLastMethodOutputValues, 0))
// This happens when the size is set conditional to 0
if len(lastMethodOutputValues) == 0 {
lastMethodOutputValues = nil
}
{
- _numItems := uint16(noOfLastMethodOutputValues)
+ _numItems := uint16(utils.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 d96d5224f4..7261c90fed 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, noOfLastMethodInputArguments)
+ lastMethodInputArguments := make([]ExtensionObjectDefinition, utils.Max(noOfLastMethodInputArguments, 0))
// This happens when the size is set conditional to 0
if len(lastMethodInputArguments) == 0 {
lastMethodInputArguments = nil
}
{
- _numItems := uint16(noOfLastMethodInputArguments)
+ _numItems := uint16(utils.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, noOfLastMethodOutputArguments)
+ lastMethodOutputArguments := make([]ExtensionObjectDefinition, utils.Max(noOfLastMethodOutputArguments, 0))
// This happens when the size is set conditional to 0
if len(lastMethodOutputArguments) == 0 {
lastMethodOutputArguments = nil
}
{
- _numItems := uint16(noOfLastMethodOutputArguments)
+ _numItems := uint16(utils.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 a73f586a9a..b561e528c7 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, noOfPublishedDataSets)
+ publishedDataSets := make([]ExtensionObjectDefinition, utils.Max(noOfPublishedDataSets, 0))
// This happens when the size is set conditional to 0
if len(publishedDataSets) == 0 {
publishedDataSets = nil
}
{
- _numItems := uint16(noOfPublishedDataSets)
+ _numItems := uint16(utils.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, noOfConnections)
+ connections := make([]ExtensionObjectDefinition, utils.Max(noOfConnections, 0))
// This happens when the size is set conditional to 0
if len(connections) == 0 {
connections = nil
}
{
- _numItems := uint16(noOfConnections)
+ _numItems := uint16(utils.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 0f7183e448..fa5c6759a3 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, noOfConnectionProperties)
+ connectionProperties := make([]ExtensionObjectDefinition, utils.Max(noOfConnectionProperties, 0))
// This happens when the size is set conditional to 0
if len(connectionProperties) == 0 {
connectionProperties = nil
}
{
- _numItems := uint16(noOfConnectionProperties)
+ _numItems := uint16(utils.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, noOfWriterGroups)
+ writerGroups := make([]PubSubGroupDataType, utils.Max(noOfWriterGroups, 0))
// This happens when the size is set conditional to 0
if len(writerGroups) == 0 {
writerGroups = nil
}
{
- _numItems := uint16(noOfWriterGroups)
+ _numItems := uint16(utils.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, noOfReaderGroups)
+ readerGroups := make([]PubSubGroupDataType, utils.Max(noOfReaderGroups, 0))
// This happens when the size is set conditional to 0
if len(readerGroups) == 0 {
readerGroups = nil
}
{
- _numItems := uint16(noOfReaderGroups)
+ _numItems := uint16(utils.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 8f2a3e1340..04e5159e59 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, noOfSecurityKeyServices)
+ securityKeyServices := make([]ExtensionObjectDefinition, utils.Max(noOfSecurityKeyServices, 0))
// This happens when the size is set conditional to 0
if len(securityKeyServices) == 0 {
securityKeyServices = nil
}
{
- _numItems := uint16(noOfSecurityKeyServices)
+ _numItems := uint16(utils.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, noOfGroupProperties)
+ groupProperties := make([]ExtensionObjectDefinition, utils.Max(noOfGroupProperties, 0))
// This happens when the size is set conditional to 0
if len(groupProperties) == 0 {
groupProperties = nil
}
{
- _numItems := uint16(noOfGroupProperties)
+ _numItems := uint16(utils.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/PublishRequest.go b/plc4go/protocols/opcua/readwrite/model/PublishRequest.go
index 2e3844a3c2..eff1162bea 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, noOfSubscriptionAcknowledgements)
+ subscriptionAcknowledgements := make([]ExtensionObjectDefinition, utils.Max(noOfSubscriptionAcknowledgements, 0))
// This happens when the size is set conditional to 0
if len(subscriptionAcknowledgements) == 0 {
subscriptionAcknowledgements = nil
}
{
- _numItems := uint16(noOfSubscriptionAcknowledgements)
+ _numItems := uint16(utils.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 0871b31f82..1e9db3a355 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, noOfAvailableSequenceNumbers)
+ availableSequenceNumbers := make([]uint32, utils.Max(noOfAvailableSequenceNumbers, 0))
// This happens when the size is set conditional to 0
if len(availableSequenceNumbers) == 0 {
availableSequenceNumbers = nil
}
{
- _numItems := uint16(noOfAvailableSequenceNumbers)
+ _numItems := uint16(utils.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, noOfResults)
+ results := make([]StatusCode, utils.Max(noOfResults, 0))
// This happens when the size is set conditional to 0
if len(results) == 0 {
results = nil
}
{
- _numItems := uint16(noOfResults)
+ _numItems := uint16(utils.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, noOfDiagnosticInfos)
+ diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0))
// This happens when the size is set conditional to 0
if len(diagnosticInfos) == 0 {
diagnosticInfos = nil
}
{
- _numItems := uint16(noOfDiagnosticInfos)
+ _numItems := uint16(utils.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 3de2f14160..8dc8d227ba 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, noOfMetaDataProperties)
+ metaDataProperties := make([]QualifiedName, utils.Max(noOfMetaDataProperties, 0))
// This happens when the size is set conditional to 0
if len(metaDataProperties) == 0 {
metaDataProperties = nil
}
{
- _numItems := uint16(noOfMetaDataProperties)
+ _numItems := uint16(utils.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 d3cd0df20b..0a50f3066d 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, noOfValues)
+ values := make([]Variant, utils.Max(noOfValues, 0))
// This happens when the size is set conditional to 0
if len(values) == 0 {
values = nil
}
{
- _numItems := uint16(noOfValues)
+ _numItems := uint16(utils.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 adf6e83147..0bbcf35dfb 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, noOfNodeTypes)
+ nodeTypes := make([]ExtensionObjectDefinition, utils.Max(noOfNodeTypes, 0))
// This happens when the size is set conditional to 0
if len(nodeTypes) == 0 {
nodeTypes = nil
}
{
- _numItems := uint16(noOfNodeTypes)
+ _numItems := uint16(utils.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 8836a027f0..57783c1971 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, noOfQueryDataSets)
+ queryDataSets := make([]ExtensionObjectDefinition, utils.Max(noOfQueryDataSets, 0))
// This happens when the size is set conditional to 0
if len(queryDataSets) == 0 {
queryDataSets = nil
}
{
- _numItems := uint16(noOfQueryDataSets)
+ _numItems := uint16(utils.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, noOfParsingResults)
+ parsingResults := make([]ExtensionObjectDefinition, utils.Max(noOfParsingResults, 0))
// This happens when the size is set conditional to 0
if len(parsingResults) == 0 {
parsingResults = nil
}
{
- _numItems := uint16(noOfParsingResults)
+ _numItems := uint16(utils.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, noOfDiagnosticInfos)
+ diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0))
// This happens when the size is set conditional to 0
if len(diagnosticInfos) == 0 {
diagnosticInfos = nil
}
{
- _numItems := uint16(noOfDiagnosticInfos)
+ _numItems := uint16(utils.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 d004144757..6e8cdc6c6f 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, noOfQueryDataSets)
+ queryDataSets := make([]ExtensionObjectDefinition, utils.Max(noOfQueryDataSets, 0))
// This happens when the size is set conditional to 0
if len(queryDataSets) == 0 {
queryDataSets = nil
}
{
- _numItems := uint16(noOfQueryDataSets)
+ _numItems := uint16(utils.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 ce6853c247..8cec38c552 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, noOfNodesToRead)
+ nodesToRead := make([]ExtensionObjectDefinition, utils.Max(noOfNodesToRead, 0))
// This happens when the size is set conditional to 0
if len(nodesToRead) == 0 {
nodesToRead = nil
}
{
- _numItems := uint16(noOfNodesToRead)
+ _numItems := uint16(utils.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 75f22b1a2b..4ed49165c4 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, noOfResults)
+ results := make([]DataValue, utils.Max(noOfResults, 0))
// This happens when the size is set conditional to 0
if len(results) == 0 {
results = nil
}
{
- _numItems := uint16(noOfResults)
+ _numItems := uint16(utils.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, noOfDiagnosticInfos)
+ diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0))
// This happens when the size is set conditional to 0
if len(diagnosticInfos) == 0 {
diagnosticInfos = nil
}
{
- _numItems := uint16(noOfDiagnosticInfos)
+ _numItems := uint16(utils.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 ce33759da7..689cb0b60d 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, noOfNodesToRegister)
+ nodesToRegister := make([]NodeId, utils.Max(noOfNodesToRegister, 0))
// This happens when the size is set conditional to 0
if len(nodesToRegister) == 0 {
nodesToRegister = nil
}
{
- _numItems := uint16(noOfNodesToRegister)
+ _numItems := uint16(utils.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 9020ec0bd2..a955e0b03c 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, noOfRegisteredNodeIds)
+ registeredNodeIds := make([]NodeId, utils.Max(noOfRegisteredNodeIds, 0))
// This happens when the size is set conditional to 0
if len(registeredNodeIds) == 0 {
registeredNodeIds = nil
}
{
- _numItems := uint16(noOfRegisteredNodeIds)
+ _numItems := uint16(utils.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 09d3aaf6c1..01d07cdeee 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, noOfDiscoveryConfiguration)
+ discoveryConfiguration := make([]ExtensionObject, utils.Max(noOfDiscoveryConfiguration, 0))
// This happens when the size is set conditional to 0
if len(discoveryConfiguration) == 0 {
discoveryConfiguration = nil
}
{
- _numItems := uint16(noOfDiscoveryConfiguration)
+ _numItems := uint16(utils.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 3de165b018..6818fe009f 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, noOfConfigurationResults)
+ configurationResults := make([]StatusCode, utils.Max(noOfConfigurationResults, 0))
// This happens when the size is set conditional to 0
if len(configurationResults) == 0 {
configurationResults = nil
}
{
- _numItems := uint16(noOfConfigurationResults)
+ _numItems := uint16(utils.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, noOfDiagnosticInfos)
+ diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0))
// This happens when the size is set conditional to 0
if len(diagnosticInfos) == 0 {
diagnosticInfos = nil
}
{
- _numItems := uint16(noOfDiagnosticInfos)
+ _numItems := uint16(utils.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 adb7c66313..cae57855e5 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, noOfServerNames)
+ serverNames := make([]LocalizedText, utils.Max(noOfServerNames, 0))
// This happens when the size is set conditional to 0
if len(serverNames) == 0 {
serverNames = nil
}
{
- _numItems := uint16(noOfServerNames)
+ _numItems := uint16(utils.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, noOfDiscoveryUrls)
+ discoveryUrls := make([]PascalString, utils.Max(noOfDiscoveryUrls, 0))
// This happens when the size is set conditional to 0
if len(discoveryUrls) == 0 {
discoveryUrls = nil
}
{
- _numItems := uint16(noOfDiscoveryUrls)
+ _numItems := uint16(utils.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 808e15306f..2bb54be538 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, noOfElements)
+ elements := make([]ExtensionObjectDefinition, utils.Max(noOfElements, 0))
// This happens when the size is set conditional to 0
if len(elements) == 0 {
elements = nil
}
{
- _numItems := uint16(noOfElements)
+ _numItems := uint16(utils.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 4b7498b3d3..b9ffebabb9 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, noOfStringTable)
+ stringTable := make([]PascalString, utils.Max(noOfStringTable, 0))
// This happens when the size is set conditional to 0
if len(stringTable) == 0 {
stringTable = nil
}
{
- _numItems := uint16(noOfStringTable)
+ _numItems := uint16(utils.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/ServerOnNetwork.go b/plc4go/protocols/opcua/readwrite/model/ServerOnNetwork.go
index 477e4d7301..988daac2bd 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, noOfServerCapabilities)
+ serverCapabilities := make([]PascalString, utils.Max(noOfServerCapabilities, 0))
// This happens when the size is set conditional to 0
if len(serverCapabilities) == 0 {
serverCapabilities = nil
}
{
- _numItems := uint16(noOfServerCapabilities)
+ _numItems := uint16(utils.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 bc3577cb39..01db7dac3e 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, noOfLocaleIds)
+ localeIds := make([]PascalString, utils.Max(noOfLocaleIds, 0))
// This happens when the size is set conditional to 0
if len(localeIds) == 0 {
localeIds = nil
}
{
- _numItems := uint16(noOfLocaleIds)
+ _numItems := uint16(utils.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 a3ec3309e1..5ef61ab895 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, noOfClientUserIdHistory)
+ clientUserIdHistory := make([]PascalString, utils.Max(noOfClientUserIdHistory, 0))
// This happens when the size is set conditional to 0
if len(clientUserIdHistory) == 0 {
clientUserIdHistory = nil
}
{
- _numItems := uint16(noOfClientUserIdHistory)
+ _numItems := uint16(utils.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 d4dc11a75c..b91fa6198d 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, noOfNamespaceUris)
+ namespaceUris := make([]PascalString, utils.Max(noOfNamespaceUris, 0))
// This happens when the size is set conditional to 0
if len(namespaceUris) == 0 {
namespaceUris = nil
}
{
- _numItems := uint16(noOfNamespaceUris)
+ _numItems := uint16(utils.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, noOfServerUris)
+ serverUris := make([]PascalString, utils.Max(noOfServerUris, 0))
// This happens when the size is set conditional to 0
if len(serverUris) == 0 {
serverUris = nil
}
{
- _numItems := uint16(noOfServerUris)
+ _numItems := uint16(utils.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, noOfLocaleIds)
+ localeIds := make([]PascalString, utils.Max(noOfLocaleIds, 0))
// This happens when the size is set conditional to 0
if len(localeIds) == 0 {
localeIds = nil
}
{
- _numItems := uint16(noOfLocaleIds)
+ _numItems := uint16(utils.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 baf87aaadf..198ccb4406 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, noOfNamespaceUris)
+ namespaceUris := make([]PascalString, utils.Max(noOfNamespaceUris, 0))
// This happens when the size is set conditional to 0
if len(namespaceUris) == 0 {
namespaceUris = nil
}
{
- _numItems := uint16(noOfNamespaceUris)
+ _numItems := uint16(utils.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, noOfServerUris)
+ serverUris := make([]PascalString, utils.Max(noOfServerUris, 0))
// This happens when the size is set conditional to 0
if len(serverUris) == 0 {
serverUris = nil
}
{
- _numItems := uint16(noOfServerUris)
+ _numItems := uint16(utils.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 2cc36eb1f4..476afd84d9 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, noOfMonitoredItemIds)
+ monitoredItemIds := make([]uint32, utils.Max(noOfMonitoredItemIds, 0))
// This happens when the size is set conditional to 0
if len(monitoredItemIds) == 0 {
monitoredItemIds = nil
}
{
- _numItems := uint16(noOfMonitoredItemIds)
+ _numItems := uint16(utils.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 e1e8eaa040..d10d8f6f9e 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, noOfResults)
+ results := make([]StatusCode, utils.Max(noOfResults, 0))
// This happens when the size is set conditional to 0
if len(results) == 0 {
results = nil
}
{
- _numItems := uint16(noOfResults)
+ _numItems := uint16(utils.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, noOfDiagnosticInfos)
+ diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0))
// This happens when the size is set conditional to 0
if len(diagnosticInfos) == 0 {
diagnosticInfos = nil
}
{
- _numItems := uint16(noOfDiagnosticInfos)
+ _numItems := uint16(utils.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 a715985a89..19aeb571fb 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, noOfSubscriptionIds)
+ subscriptionIds := make([]uint32, utils.Max(noOfSubscriptionIds, 0))
// This happens when the size is set conditional to 0
if len(subscriptionIds) == 0 {
subscriptionIds = nil
}
{
- _numItems := uint16(noOfSubscriptionIds)
+ _numItems := uint16(utils.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 3a4c50a21b..95116b01a9 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, noOfResults)
+ results := make([]StatusCode, utils.Max(noOfResults, 0))
// This happens when the size is set conditional to 0
if len(results) == 0 {
results = nil
}
{
- _numItems := uint16(noOfResults)
+ _numItems := uint16(utils.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, noOfDiagnosticInfos)
+ diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0))
// This happens when the size is set conditional to 0
if len(diagnosticInfos) == 0 {
diagnosticInfos = nil
}
{
- _numItems := uint16(noOfDiagnosticInfos)
+ _numItems := uint16(utils.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 a1005e4c4a..fed0d4037b 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, noOfLinksToAdd)
+ linksToAdd := make([]uint32, utils.Max(noOfLinksToAdd, 0))
// This happens when the size is set conditional to 0
if len(linksToAdd) == 0 {
linksToAdd = nil
}
{
- _numItems := uint16(noOfLinksToAdd)
+ _numItems := uint16(utils.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, noOfLinksToRemove)
+ linksToRemove := make([]uint32, utils.Max(noOfLinksToRemove, 0))
// This happens when the size is set conditional to 0
if len(linksToRemove) == 0 {
linksToRemove = nil
}
{
- _numItems := uint16(noOfLinksToRemove)
+ _numItems := uint16(utils.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 ee3794bd2c..439816a196 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, noOfAddResults)
+ addResults := make([]StatusCode, utils.Max(noOfAddResults, 0))
// This happens when the size is set conditional to 0
if len(addResults) == 0 {
addResults = nil
}
{
- _numItems := uint16(noOfAddResults)
+ _numItems := uint16(utils.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, noOfAddDiagnosticInfos)
+ addDiagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfAddDiagnosticInfos, 0))
// This happens when the size is set conditional to 0
if len(addDiagnosticInfos) == 0 {
addDiagnosticInfos = nil
}
{
- _numItems := uint16(noOfAddDiagnosticInfos)
+ _numItems := uint16(utils.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, noOfRemoveResults)
+ removeResults := make([]StatusCode, utils.Max(noOfRemoveResults, 0))
// This happens when the size is set conditional to 0
if len(removeResults) == 0 {
removeResults = nil
}
{
- _numItems := uint16(noOfRemoveResults)
+ _numItems := uint16(utils.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, noOfRemoveDiagnosticInfos)
+ removeDiagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfRemoveDiagnosticInfos, 0))
// This happens when the size is set conditional to 0
if len(removeDiagnosticInfos) == 0 {
removeDiagnosticInfos = nil
}
{
- _numItems := uint16(noOfRemoveDiagnosticInfos)
+ _numItems := uint16(utils.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/StructureField.go b/plc4go/protocols/opcua/readwrite/model/StructureField.go
index 66aee3146b..da25324260 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, noOfArrayDimensions)
+ arrayDimensions := make([]uint32, utils.Max(noOfArrayDimensions, 0))
// This happens when the size is set conditional to 0
if len(arrayDimensions) == 0 {
arrayDimensions = nil
}
{
- _numItems := uint16(noOfArrayDimensions)
+ _numItems := uint16(utils.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 f659249f80..96f363d5d7 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, noOfAvailableSequenceNumbers)
+ availableSequenceNumbers := make([]uint32, utils.Max(noOfAvailableSequenceNumbers, 0))
// This happens when the size is set conditional to 0
if len(availableSequenceNumbers) == 0 {
availableSequenceNumbers = nil
}
{
- _numItems := uint16(noOfAvailableSequenceNumbers)
+ _numItems := uint16(utils.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 f12ab699d4..56f8b2f4d3 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, noOfSubscriptionIds)
+ subscriptionIds := make([]uint32, utils.Max(noOfSubscriptionIds, 0))
// This happens when the size is set conditional to 0
if len(subscriptionIds) == 0 {
subscriptionIds = nil
}
{
- _numItems := uint16(noOfSubscriptionIds)
+ _numItems := uint16(utils.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 b78372edce..20ddf1c202 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, noOfResults)
+ results := make([]ExtensionObjectDefinition, utils.Max(noOfResults, 0))
// This happens when the size is set conditional to 0
if len(results) == 0 {
results = nil
}
{
- _numItems := uint16(noOfResults)
+ _numItems := uint16(utils.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, noOfDiagnosticInfos)
+ diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0))
// This happens when the size is set conditional to 0
if len(diagnosticInfos) == 0 {
diagnosticInfos = nil
}
{
- _numItems := uint16(noOfDiagnosticInfos)
+ _numItems := uint16(utils.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 a231236235..0170425574 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, noOfBrowsePaths)
+ browsePaths := make([]ExtensionObjectDefinition, utils.Max(noOfBrowsePaths, 0))
// This happens when the size is set conditional to 0
if len(browsePaths) == 0 {
browsePaths = nil
}
{
- _numItems := uint16(noOfBrowsePaths)
+ _numItems := uint16(utils.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 90a6364c25..43130e8140 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, noOfResults)
+ results := make([]ExtensionObjectDefinition, utils.Max(noOfResults, 0))
// This happens when the size is set conditional to 0
if len(results) == 0 {
results = nil
}
{
- _numItems := uint16(noOfResults)
+ _numItems := uint16(utils.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, noOfDiagnosticInfos)
+ diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0))
// This happens when the size is set conditional to 0
if len(diagnosticInfos) == 0 {
diagnosticInfos = nil
}
{
- _numItems := uint16(noOfDiagnosticInfos)
+ _numItems := uint16(utils.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 8431e9f25b..f85a2d81fd 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, noOfTrustedCertificates)
+ trustedCertificates := make([]PascalByteString, utils.Max(noOfTrustedCertificates, 0))
// This happens when the size is set conditional to 0
if len(trustedCertificates) == 0 {
trustedCertificates = nil
}
{
- _numItems := uint16(noOfTrustedCertificates)
+ _numItems := uint16(utils.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, noOfTrustedCrls)
+ trustedCrls := make([]PascalByteString, utils.Max(noOfTrustedCrls, 0))
// This happens when the size is set conditional to 0
if len(trustedCrls) == 0 {
trustedCrls = nil
}
{
- _numItems := uint16(noOfTrustedCrls)
+ _numItems := uint16(utils.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, noOfIssuerCertificates)
+ issuerCertificates := make([]PascalByteString, utils.Max(noOfIssuerCertificates, 0))
// This happens when the size is set conditional to 0
if len(issuerCertificates) == 0 {
issuerCertificates = nil
}
{
- _numItems := uint16(noOfIssuerCertificates)
+ _numItems := uint16(utils.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, noOfIssuerCrls)
+ issuerCrls := make([]PascalByteString, utils.Max(noOfIssuerCrls, 0))
// This happens when the size is set conditional to 0
if len(issuerCrls) == 0 {
issuerCrls = nil
}
{
- _numItems := uint16(noOfIssuerCrls)
+ _numItems := uint16(utils.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 59325ce2d7..16525bb025 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, noOfNodesToUnregister)
+ nodesToUnregister := make([]NodeId, utils.Max(noOfNodesToUnregister, 0))
// This happens when the size is set conditional to 0
if len(nodesToUnregister) == 0 {
nodesToUnregister = nil
}
{
- _numItems := uint16(noOfNodesToUnregister)
+ _numItems := uint16(utils.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 e3f4bcc5bd..f3f5115440 100644
--- a/plc4go/protocols/opcua/readwrite/model/Variant.go
+++ b/plc4go/protocols/opcua/readwrite/model/Variant.go
@@ -275,13 +275,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.InlineIf(bool((noOfArrayDimensions) == (nil)), func() any { return uint16(uint16(0)) }, func() any { return uint16((*noOfArrayDimensions)) }).(uint16))
+ arrayDimensions := make([]bool, utils.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.InlineIf(bool((noOfArrayDimensions) == (nil)), func() any { return uint16(uint16(0)) }, func() any { return uint16((*noOfArrayDimensions)) }).(uint16))
+ _numItems := uint16(utils.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 dd7641006b..25cce084ec 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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ value := make([]uint8, utils.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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ _numItems := uint16(utils.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 c693d813f6..149af95341 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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ value := make([]ByteStringArray, utils.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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ _numItems := uint16(utils.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 1fece3d720..163944921f 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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ value := make([]DataValue, utils.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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ _numItems := uint16(utils.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 34697ed4cf..9e458982ed 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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ value := make([]int64, utils.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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ _numItems := uint16(utils.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 45bf65e502..d7346b2291 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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ value := make([]DiagnosticInfo, utils.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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ _numItems := uint16(utils.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 640997ea1a..0d708d7c3e 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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ value := make([]float64, utils.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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ _numItems := uint16(utils.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 a3b94ddd36..3e8c0bd81e 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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ value := make([]ExpandedNodeId, utils.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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ _numItems := uint16(utils.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 db7e7adfaa..b795fa3c93 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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ value := make([]ExtensionObject, utils.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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ _numItems := uint16(utils.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 0ca73d1f81..cf1f6bc70f 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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ value := make([]float32, utils.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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ _numItems := uint16(utils.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 6800b4ea9a..4be4098f69 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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ value := make([]GuidValue, utils.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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ _numItems := uint16(utils.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 872598af4e..3404d95bfe 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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ value := make([]int16, utils.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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ _numItems := uint16(utils.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 437c1f016a..8120a0838b 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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ value := make([]int32, utils.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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ _numItems := uint16(utils.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 b148458c78..42f8cf1551 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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ value := make([]int64, utils.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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ _numItems := uint16(utils.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 3763ed4c43..4eee1f5b6f 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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ value := make([]LocalizedText, utils.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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ _numItems := uint16(utils.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 da2609f12f..9ad55fa70b 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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ value := make([]NodeId, utils.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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ _numItems := uint16(utils.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 ba8ee7f485..0faf1575dc 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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ value := make([]QualifiedName, utils.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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ _numItems := uint16(utils.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 f2cfe36335..28e88ef77f 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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ value := make([]StatusCode, utils.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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ _numItems := uint16(utils.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 5070e40ad1..3a8e7efbeb 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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ value := make([]PascalString, utils.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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ _numItems := uint16(utils.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 622349b1d5..c4f6442a08 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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ value := make([]uint16, utils.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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ _numItems := uint16(utils.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 f370a749de..343fd75af9 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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ value := make([]uint32, utils.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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ _numItems := uint16(utils.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 b0e52b6d90..c06f5c86ee 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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ value := make([]uint64, utils.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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ _numItems := uint16(utils.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 6c4a2240ab..cc92e938c7 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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ value := make([]Variant, utils.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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ _numItems := uint16(utils.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 00c81fd133..807bbe73ca 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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ value := make([]PascalString, utils.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.InlineIf(bool((arrayLength) == (nil)), func() any { return uint16(uint16(1)) }, func() any { return uint16((*arrayLength)) }).(uint16))
+ _numItems := uint16(utils.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 421cd44f40..7b734226cb 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, noOfNodesToWrite)
+ nodesToWrite := make([]ExtensionObjectDefinition, utils.Max(noOfNodesToWrite, 0))
// This happens when the size is set conditional to 0
if len(nodesToWrite) == 0 {
nodesToWrite = nil
}
{
- _numItems := uint16(noOfNodesToWrite)
+ _numItems := uint16(utils.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 74682674c2..f8dbed5687 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, noOfResults)
+ results := make([]StatusCode, utils.Max(noOfResults, 0))
// This happens when the size is set conditional to 0
if len(results) == 0 {
results = nil
}
{
- _numItems := uint16(noOfResults)
+ _numItems := uint16(utils.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, noOfDiagnosticInfos)
+ diagnosticInfos := make([]DiagnosticInfo, utils.Max(noOfDiagnosticInfos, 0))
// This happens when the size is set conditional to 0
if len(diagnosticInfos) == 0 {
diagnosticInfos = nil
}
{
- _numItems := uint16(noOfDiagnosticInfos)
+ _numItems := uint16(utils.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 a82677de81..8622810624 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, length)
+ value := make([]string, utils.Max(length, 0))
// This happens when the size is set conditional to 0
if len(value) == 0 {
value = nil
}
{
- _numItems := uint16(length)
+ _numItems := uint16(utils.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 361be39f05..db70c1ecaa 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, uint16(byteCount)/uint16(uint16(12)))
+ messageObjects := make([]AlarmMessageObjectQueryType, utils.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(uint16(byteCount) / uint16(uint16(12)))
+ _numItems := uint16(utils.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 b98569fb39..a224e10b6e 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, numberOfObjects)
+ messageObjects := make([]AlarmMessageAckObjectPushType, utils.Max(numberOfObjects, 0))
// This happens when the size is set conditional to 0
if len(messageObjects) == 0 {
messageObjects = nil
}
{
- _numItems := uint16(numberOfObjects)
+ _numItems := uint16(utils.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 66ec0758fa..b3d240fcb1 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, numberOfObjects)
+ messageObjects := make([]uint8, utils.Max(numberOfObjects, 0))
// This happens when the size is set conditional to 0
if len(messageObjects) == 0 {
messageObjects = nil
}
{
- _numItems := uint16(numberOfObjects)
+ _numItems := uint16(utils.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 dac07472e4..03b28e0881 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, numberOfObjects)
+ messageObjects := make([]AlarmMessageObjectAckType, utils.Max(numberOfObjects, 0))
// This happens when the size is set conditional to 0
if len(messageObjects) == 0 {
messageObjects = nil
}
{
- _numItems := uint16(numberOfObjects)
+ _numItems := uint16(utils.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 9b26b7913d..e2adebdf07 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, numberOfValues)
+ AssociatedValues := make([]AssociatedValueType, utils.Max(numberOfValues, 0))
// This happens when the size is set conditional to 0
if len(AssociatedValues) == 0 {
AssociatedValues = nil
}
{
- _numItems := uint16(numberOfValues)
+ _numItems := uint16(utils.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 725d2e7d1d..73447625d0 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, numberOfObjects)
+ messageObjects := make([]AlarmMessageObjectPushType, utils.Max(numberOfObjects, 0))
// This happens when the size is set conditional to 0
if len(messageObjects) == 0 {
messageObjects = nil
}
{
- _numItems := uint16(numberOfObjects)
+ _numItems := uint16(utils.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 b1310cb671..93159b650d 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, numberOfObjects)
+ messageObjects := make([]AlarmMessageObjectQueryType, utils.Max(numberOfObjects, 0))
// This happens when the size is set conditional to 0
if len(messageObjects) == 0 {
messageObjects = nil
}
{
- _numItems := uint16(numberOfObjects)
+ _numItems := uint16(utils.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 a7a97731f8..a5b74a695a 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, valueLength)
+ data := make([]uint8, utils.Max(valueLength, 0))
// This happens when the size is set conditional to 0
if len(data) == 0 {
data = nil
}
{
- _numItems := uint16(valueLength)
+ _numItems := uint16(utils.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 99d238ff9e..9bb03d24a2 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, EventItemLength(ctx, readBuffer, valueLength))
+ data := make([]uint8, utils.Max(EventItemLength(ctx, readBuffer, valueLength), 0))
// This happens when the size is set conditional to 0
if len(data) == 0 {
data = nil
}
{
- _numItems := uint16(EventItemLength(ctx, readBuffer, valueLength))
+ _numItems := uint16(utils.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 8035c90c76..f43b7e930a 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, numberOfAreas)
+ items := make([]SubItem, utils.Max(numberOfAreas, 0))
// This happens when the size is set conditional to 0
if len(items) == 0 {
items = nil
}
{
- _numItems := uint16(numberOfAreas)
+ _numItems := uint16(utils.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 37475235f5..3becf027fa 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, numItems)
+ items := make([]S7VarRequestParameterItem, utils.Max(numItems, 0))
// This happens when the size is set conditional to 0
if len(items) == 0 {
items = nil
}
{
- _numItems := uint16(numItems)
+ _numItems := uint16(utils.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 ea8eae4282..0fe44247c1 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, numItems)
+ items := make([]S7ParameterUserDataItem, utils.Max(numItems, 0))
// This happens when the size is set conditional to 0
if len(items) == 0 {
items = nil
}
{
- _numItems := uint16(numItems)
+ _numItems := uint16(utils.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 48a2b69216..2551bba4e4 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, numItems)
+ items := make([]S7VarRequestParameterItem, utils.Max(numItems, 0))
// This happens when the size is set conditional to 0
if len(items) == 0 {
items = nil
}
{
- _numItems := uint16(numItems)
+ _numItems := uint16(utils.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 819b7f3d69..2d7f9f7091 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, CastS7ParameterReadVarResponse(parameter).GetNumItems())
+ items := make([]S7VarPayloadDataItem, utils.Max(CastS7ParameterReadVarResponse(parameter).GetNumItems(), 0))
// This happens when the size is set conditional to 0
if len(items) == 0 {
items = nil
}
{
- _numItems := uint16(CastS7ParameterReadVarResponse(parameter).GetNumItems())
+ _numItems := uint16(utils.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 1295e81e96..3ddcc278ac 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, uint16(len(CastS7ParameterUserData(parameter).GetItems())))
+ items := make([]S7PayloadUserDataItem, utils.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(uint16(len(CastS7ParameterUserData(parameter).GetItems())))
+ _numItems := uint16(utils.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 899db19272..2627599601 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, numberOfObjects)
+ messageObjects := make([]AlarmMessageObjectAckType, utils.Max(numberOfObjects, 0))
// This happens when the size is set conditional to 0
if len(messageObjects) == 0 {
messageObjects = nil
}
{
- _numItems := uint16(numberOfObjects)
+ _numItems := uint16(utils.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 ee8f02b0b4..30164eebf0 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, numberOfObjects)
+ messageObjects := make([]uint8, utils.Max(numberOfObjects, 0))
// This happens when the size is set conditional to 0
if len(messageObjects) == 0 {
messageObjects = nil
}
{
- _numItems := uint16(numberOfObjects)
+ _numItems := uint16(utils.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 896ef59763..5e03e0ca7b 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, itemsCount)
+ items := make([]AssociatedQueryValueType, utils.Max(itemsCount, 0))
// This happens when the size is set conditional to 0
if len(items) == 0 {
items = nil
}
{
- _numItems := uint16(itemsCount)
+ _numItems := uint16(utils.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 89096fffae..967cf95b82 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, itemsCount)
+ items := make([]AssociatedQueryValueType, utils.Max(itemsCount, 0))
// This happens when the size is set conditional to 0
if len(items) == 0 {
items = nil
}
{
- _numItems := uint16(itemsCount)
+ _numItems := uint16(utils.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 b82316e03a..42aaef2876 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, itemsCount)
+ items := make([]AssociatedValueType, utils.Max(itemsCount, 0))
// This happens when the size is set conditional to 0
if len(items) == 0 {
items = nil
}
{
- _numItems := uint16(itemsCount)
+ _numItems := uint16(utils.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 95c3eeec24..e886ce6af3 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, itemsCount)
+ item := make([]CycServiceItemType, utils.Max(itemsCount, 0))
// This happens when the size is set conditional to 0
if len(item) == 0 {
item = nil
}
{
- _numItems := uint16(itemsCount)
+ _numItems := uint16(utils.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 6ce70ce11d..4eb7d21c6a 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, itemsCount)
+ items := make([]AssociatedValueType, utils.Max(itemsCount, 0))
// This happens when the size is set conditional to 0
if len(items) == 0 {
items = nil
}
{
- _numItems := uint16(itemsCount)
+ _numItems := uint16(utils.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 7c15cb08cd..bd3ed7c479 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, uint16(len(CastS7ParameterWriteVarRequest(parameter).GetItems())))
+ items := make([]S7VarPayloadDataItem, utils.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(uint16(len(CastS7ParameterWriteVarRequest(parameter).GetItems())))
+ _numItems := uint16(utils.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 ebdf5ee437..c260803cf3 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, CastS7ParameterWriteVarResponse(parameter).GetNumItems())
+ items := make([]S7VarPayloadStatusItem, utils.Max(CastS7ParameterWriteVarResponse(parameter).GetNumItems(), 0))
// This happens when the size is set conditional to 0
if len(items) == 0 {
items = nil
}
{
- _numItems := uint16(CastS7ParameterWriteVarResponse(parameter).GetNumItems())
+ _numItems := uint16(utils.Max(CastS7ParameterWriteVarResponse(parameter).GetNumItems(), 0))
for _curItem := uint16(0); _curItem < _numItems; _curItem++ {
arrayCtx := utils.CreateArrayContext(ctx, int(_numItems), int(_curItem))
_ = arrayCtx