You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@plc4x.apache.org by sr...@apache.org on 2022/03/07 13:09:51 UTC
[plc4x] branch develop updated: refactor(plc4go/codegen): simplified cast function
This is an automated email from the ASF dual-hosted git repository.
sruehl pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/plc4x.git
The following commit(s) were added to refs/heads/develop by this push:
new fd8c81c refactor(plc4go/codegen): simplified cast function
fd8c81c is described below
commit fd8c81c888062f76a58415ad686bcdf3545aacc2
Author: Sebastian Rühl <sr...@apache.org>
AuthorDate: Mon Mar 7 14:09:43 2022 +0100
refactor(plc4go/codegen): simplified cast function
---
.../resources/templates/go/model-template.go.ftlh | 29 ++++++++++------------
.../model/CIPEncapsulationConnectionRequest.go | 27 +++++++++-----------
.../model/CIPEncapsulationConnectionResponse.go | 27 +++++++++-----------
.../readwrite/model/CIPEncapsulationPacket.go | 15 +++++------
.../readwrite/model/CIPEncapsulationReadRequest.go | 27 +++++++++-----------
.../model/CIPEncapsulationReadResponse.go | 27 +++++++++-----------
.../readwrite/model/DF1CommandRequestMessage.go | 27 +++++++++-----------
...mandResponseMessageProtectedTypedLogicalRead.go | 27 +++++++++-----------
.../abeth/readwrite/model/DF1RequestCommand.go | 15 +++++------
.../abeth/readwrite/model/DF1RequestMessage.go | 15 +++++------
.../model/DF1RequestProtectedTypedLogicalRead.go | 27 +++++++++-----------
.../abeth/readwrite/model/DF1ResponseMessage.go | 15 +++++------
.../model/AdsAddDeviceNotificationRequest.go | 27 +++++++++-----------
.../model/AdsAddDeviceNotificationResponse.go | 27 +++++++++-----------
.../internal/plc4go/ads/readwrite/model/AdsData.go | 15 +++++------
.../model/AdsDeleteDeviceNotificationRequest.go | 27 +++++++++-----------
.../model/AdsDeleteDeviceNotificationResponse.go | 27 +++++++++-----------
.../model/AdsDeviceNotificationRequest.go | 27 +++++++++-----------
.../model/AdsDeviceNotificationResponse.go | 27 +++++++++-----------
.../ads/readwrite/model/AdsInvalidRequest.go | 27 +++++++++-----------
.../ads/readwrite/model/AdsInvalidResponse.go | 27 +++++++++-----------
.../ads/readwrite/model/AdsMultiRequestItem.go | 15 +++++------
.../ads/readwrite/model/AdsMultiRequestItemRead.go | 27 +++++++++-----------
.../model/AdsMultiRequestItemReadWrite.go | 27 +++++++++-----------
.../readwrite/model/AdsMultiRequestItemWrite.go | 27 +++++++++-----------
.../ads/readwrite/model/AdsNotificationSample.go | 15 +++++------
.../readwrite/model/AdsReadDeviceInfoRequest.go | 27 +++++++++-----------
.../readwrite/model/AdsReadDeviceInfoResponse.go | 27 +++++++++-----------
.../plc4go/ads/readwrite/model/AdsReadRequest.go | 27 +++++++++-----------
.../plc4go/ads/readwrite/model/AdsReadResponse.go | 27 +++++++++-----------
.../ads/readwrite/model/AdsReadStateRequest.go | 27 +++++++++-----------
.../ads/readwrite/model/AdsReadStateResponse.go | 27 +++++++++-----------
.../ads/readwrite/model/AdsReadWriteRequest.go | 27 +++++++++-----------
.../ads/readwrite/model/AdsReadWriteResponse.go | 27 +++++++++-----------
.../plc4go/ads/readwrite/model/AdsStampHeader.go | 15 +++++------
.../ads/readwrite/model/AdsWriteControlRequest.go | 27 +++++++++-----------
.../ads/readwrite/model/AdsWriteControlResponse.go | 27 +++++++++-----------
.../plc4go/ads/readwrite/model/AdsWriteRequest.go | 27 +++++++++-----------
.../plc4go/ads/readwrite/model/AdsWriteResponse.go | 27 +++++++++-----------
.../plc4go/ads/readwrite/model/AmsNetId.go | 15 +++++------
.../plc4go/ads/readwrite/model/AmsPacket.go | 17 ++++++-------
.../readwrite/model/AmsSerialAcknowledgeFrame.go | 15 +++++------
.../plc4go/ads/readwrite/model/AmsSerialFrame.go | 15 +++++------
.../ads/readwrite/model/AmsSerialResetFrame.go | 15 +++++------
.../plc4go/ads/readwrite/model/AmsTCPPacket.go | 15 +++++------
.../internal/plc4go/ads/readwrite/model/State.go | 15 +++++------
.../plc4go/bacnetip/readwrite/model/APDU.go | 15 +++++------
.../plc4go/bacnetip/readwrite/model/APDUAbort.go | 27 +++++++++-----------
.../bacnetip/readwrite/model/APDUComplexAck.go | 27 +++++++++-----------
.../readwrite/model/APDUConfirmedRequest.go | 27 +++++++++-----------
.../plc4go/bacnetip/readwrite/model/APDUError.go | 27 +++++++++-----------
.../plc4go/bacnetip/readwrite/model/APDUReject.go | 27 +++++++++-----------
.../bacnetip/readwrite/model/APDUSegmentAck.go | 27 +++++++++-----------
.../bacnetip/readwrite/model/APDUSimpleAck.go | 27 +++++++++-----------
.../readwrite/model/APDUUnconfirmedRequest.go | 27 +++++++++-----------
.../plc4go/bacnetip/readwrite/model/APDUUnknown.go | 27 +++++++++-----------
.../bacnetip/readwrite/model/BACnetAction.go | 15 +++++------
.../readwrite/model/BACnetActionCommand.go | 15 +++++------
.../bacnetip/readwrite/model/BACnetAddress.go | 15 +++++------
.../readwrite/model/BACnetApplicationTag.go | 15 +++++------
.../model/BACnetApplicationTagBitString.go | 27 +++++++++-----------
.../readwrite/model/BACnetApplicationTagBoolean.go | 27 +++++++++-----------
.../model/BACnetApplicationTagCharacterString.go | 27 +++++++++-----------
.../readwrite/model/BACnetApplicationTagDate.go | 27 +++++++++-----------
.../readwrite/model/BACnetApplicationTagDouble.go | 27 +++++++++-----------
.../model/BACnetApplicationTagEnumerated.go | 27 +++++++++-----------
.../readwrite/model/BACnetApplicationTagNull.go | 27 +++++++++-----------
.../model/BACnetApplicationTagObjectIdentifier.go | 27 +++++++++-----------
.../model/BACnetApplicationTagOctetString.go | 27 +++++++++-----------
.../readwrite/model/BACnetApplicationTagReal.go | 27 +++++++++-----------
.../model/BACnetApplicationTagSignedInteger.go | 27 +++++++++-----------
.../readwrite/model/BACnetApplicationTagTime.go | 27 +++++++++-----------
.../model/BACnetApplicationTagUnsignedInteger.go | 27 +++++++++-----------
.../bacnetip/readwrite/model/BACnetBinaryPV.go | 15 +++++------
.../bacnetip/readwrite/model/BACnetClosingTag.go | 27 +++++++++-----------
.../readwrite/model/BACnetConfirmedServiceACK.go | 15 +++++------
.../BACnetConfirmedServiceACKAtomicReadFile.go | 27 +++++++++-----------
.../BACnetConfirmedServiceACKAtomicWriteFile.go | 27 +++++++++-----------
...tConfirmedServiceACKConfirmedPrivateTransfer.go | 27 +++++++++-----------
.../model/BACnetConfirmedServiceACKCreateObject.go | 27 +++++++++-----------
.../BACnetConfirmedServiceACKGetAlarmSummary.go | 27 +++++++++-----------
...ACnetConfirmedServiceACKGetEnrollmentSummary.go | 27 +++++++++-----------
...BACnetConfirmedServiceACKGetEventInformation.go | 27 +++++++++-----------
.../model/BACnetConfirmedServiceACKReadProperty.go | 27 +++++++++-----------
...ACnetConfirmedServiceACKReadPropertyMultiple.go | 27 +++++++++-----------
.../model/BACnetConfirmedServiceACKReadRange.go | 27 +++++++++-----------
...BACnetConfirmedServiceACKRemovedAuthenticate.go | 27 +++++++++-----------
...rmedServiceACKRemovedReadPropertyConditional.go | 27 +++++++++-----------
.../model/BACnetConfirmedServiceACKVTData.go | 27 +++++++++-----------
.../model/BACnetConfirmedServiceACKVTOpen.go | 27 +++++++++-----------
.../model/BACnetConfirmedServiceAddListElement.go | 27 +++++++++-----------
.../model/BACnetConfirmedServiceRequest.go | 15 +++++------
...ACnetConfirmedServiceRequestAcknowledgeAlarm.go | 27 +++++++++-----------
.../BACnetConfirmedServiceRequestAddListElement.go | 27 +++++++++-----------
.../BACnetConfirmedServiceRequestAtomicReadFile.go | 27 +++++++++-----------
...tConfirmedServiceRequestAtomicReadFileRecord.go | 27 +++++++++-----------
...tConfirmedServiceRequestAtomicReadFileStream.go | 27 +++++++++-----------
...edServiceRequestAtomicReadFileStreamOrRecord.go | 15 +++++------
...BACnetConfirmedServiceRequestAtomicWriteFile.go | 27 +++++++++-----------
...firmedServiceRequestConfirmedCOVNotification.go | 27 +++++++++-----------
...rviceRequestConfirmedCOVNotificationMultiple.go | 27 +++++++++-----------
...rmedServiceRequestConfirmedEventNotification.go | 27 +++++++++-----------
...firmedServiceRequestConfirmedPrivateTransfer.go | 27 +++++++++-----------
...tConfirmedServiceRequestConfirmedTextMessage.go | 27 +++++++++-----------
...ACnetConfirmedServiceRequestConfirmedUnknown.go | 27 +++++++++-----------
.../BACnetConfirmedServiceRequestCreateObject.go | 27 +++++++++-----------
.../BACnetConfirmedServiceRequestDeleteObject.go | 27 +++++++++-----------
...rmedServiceRequestDeviceCommunicationControl.go | 27 +++++++++-----------
...tConfirmedServiceRequestGetEnrollmentSummary.go | 27 +++++++++-----------
...etConfirmedServiceRequestGetEventInformation.go | 27 +++++++++-----------
...etConfirmedServiceRequestLifeSafetyOperation.go | 27 +++++++++-----------
.../BACnetConfirmedServiceRequestReadProperty.go | 27 +++++++++-----------
...tConfirmedServiceRequestReadPropertyMultiple.go | 27 +++++++++-----------
.../BACnetConfirmedServiceRequestReadRange.go | 27 +++++++++-----------
...netConfirmedServiceRequestReinitializeDevice.go | 27 +++++++++-----------
...erviceRequestReinitializeDeviceEnableDisable.go | 15 +++++------
...CnetConfirmedServiceRequestRemoveListElement.go | 27 +++++++++-----------
...etConfirmedServiceRequestRemovedAuthenticate.go | 27 +++++++++-----------
...ServiceRequestRemovedReadPropertyConditional.go | 27 +++++++++-----------
...CnetConfirmedServiceRequestRemovedRequestKey.go | 27 +++++++++-----------
.../BACnetConfirmedServiceRequestSubscribeCOV.go | 27 +++++++++-----------
...tConfirmedServiceRequestSubscribeCOVProperty.go | 27 +++++++++-----------
...edServiceRequestSubscribeCOVPropertyMultiple.go | 27 +++++++++-----------
.../model/BACnetConfirmedServiceRequestVTClose.go | 27 +++++++++-----------
.../model/BACnetConfirmedServiceRequestVTData.go | 27 +++++++++-----------
.../model/BACnetConfirmedServiceRequestVTOpen.go | 27 +++++++++-----------
.../BACnetConfirmedServiceRequestWriteProperty.go | 27 +++++++++-----------
...ConfirmedServiceRequestWritePropertyMultiple.go | 27 +++++++++-----------
.../readwrite/model/BACnetConstructedData.go | 15 +++++------
.../model/BACnetConstructedDataCommand.go | 27 +++++++++-----------
.../model/BACnetConstructedDataElement.go | 15 +++++------
.../model/BACnetConstructedDataEventTimestamps.go | 27 +++++++++-----------
.../model/BACnetConstructedDataLifeSafetyZone.go | 27 +++++++++-----------
.../model/BACnetConstructedDataUnspecified.go | 27 +++++++++-----------
.../bacnetip/readwrite/model/BACnetContextTag.go | 15 +++++------
.../readwrite/model/BACnetContextTagBitString.go | 27 +++++++++-----------
.../readwrite/model/BACnetContextTagBoolean.go | 27 +++++++++-----------
.../model/BACnetContextTagCharacterString.go | 27 +++++++++-----------
.../readwrite/model/BACnetContextTagDate.go | 27 +++++++++-----------
.../readwrite/model/BACnetContextTagDeviceState.go | 27 +++++++++-----------
.../readwrite/model/BACnetContextTagDouble.go | 27 +++++++++-----------
.../readwrite/model/BACnetContextTagEmpty.go | 27 +++++++++-----------
.../readwrite/model/BACnetContextTagEnumerated.go | 27 +++++++++-----------
.../readwrite/model/BACnetContextTagEventState.go | 27 +++++++++-----------
.../readwrite/model/BACnetContextTagEventType.go | 27 +++++++++-----------
.../readwrite/model/BACnetContextTagNotifyType.go | 27 +++++++++-----------
.../model/BACnetContextTagObjectIdentifier.go | 27 +++++++++-----------
.../readwrite/model/BACnetContextTagOctetString.go | 27 +++++++++-----------
.../model/BACnetContextTagPropertyIdentifier.go | 27 +++++++++-----------
.../readwrite/model/BACnetContextTagReal.go | 27 +++++++++-----------
.../model/BACnetContextTagSignedInteger.go | 27 +++++++++-----------
.../readwrite/model/BACnetContextTagTime.go | 27 +++++++++-----------
.../model/BACnetContextTagUnsignedInteger.go | 27 +++++++++-----------
.../bacnetip/readwrite/model/BACnetDateTime.go | 15 +++++------
.../model/BACnetDeviceObjectPropertyReference.go | 15 +++++------
.../plc4go/bacnetip/readwrite/model/BACnetError.go | 15 +++++------
.../readwrite/model/BACnetErrorAcknowledgeAlarm.go | 27 +++++++++-----------
.../readwrite/model/BACnetErrorAtomicReadFile.go | 27 +++++++++-----------
.../readwrite/model/BACnetErrorAtomicWriteFile.go | 27 +++++++++-----------
.../model/BACnetErrorConfirmedEventNotification.go | 27 +++++++++-----------
.../model/BACnetErrorConfirmedPrivateTransfer.go | 27 +++++++++-----------
.../readwrite/model/BACnetErrorCreateObject.go | 27 +++++++++-----------
.../BACnetErrorDeviceCommunicationProtocol.go | 27 +++++++++-----------
.../readwrite/model/BACnetErrorGetAlarmSummary.go | 27 +++++++++-----------
.../model/BACnetErrorGetEnrollmentSummary.go | 27 +++++++++-----------
.../model/BACnetErrorGetEventInformation.go | 27 +++++++++-----------
.../readwrite/model/BACnetErrorPasswordFailure.go | 27 +++++++++-----------
.../readwrite/model/BACnetErrorReadProperty.go | 27 +++++++++-----------
.../model/BACnetErrorReadPropertyMultiple.go | 27 +++++++++-----------
.../readwrite/model/BACnetErrorReadRange.go | 27 +++++++++-----------
.../model/BACnetErrorRemovedAuthenticate.go | 27 +++++++++-----------
.../BACnetErrorRemovedReadPropertyConditional.go | 27 +++++++++-----------
.../bacnetip/readwrite/model/BACnetErrorUnknown.go | 27 +++++++++-----------
.../bacnetip/readwrite/model/BACnetErrorVTData.go | 27 +++++++++-----------
.../bacnetip/readwrite/model/BACnetErrorVTOpen.go | 27 +++++++++-----------
.../readwrite/model/BACnetErrorWriteProperty.go | 27 +++++++++-----------
.../model/BACnetNotificationParameters.go | 15 +++++------
.../BACnetNotificationParametersBufferReady.go | 27 +++++++++-----------
...ACnetNotificationParametersChangeOfBitString.go | 27 +++++++++-----------
.../BACnetNotificationParametersChangeOfState.go | 27 +++++++++-----------
.../BACnetNotificationParametersChangeOfValue.go | 27 +++++++++-----------
...tNotificationParametersChangeOfValueNewValue.go | 15 +++++------
...onParametersChangeOfValueNewValueChangedBits.go | 27 +++++++++-----------
...nParametersChangeOfValueNewValueChangedValue.go | 27 +++++++++-----------
...BACnetNotificationParametersComplexEventType.go | 27 +++++++++-----------
.../model/BACnetNotificationParametersExtended.go | 27 +++++++++-----------
...CnetNotificationParametersExtendedParameters.go | 15 +++++------
.../BACnetNotificationParametersFloatingLimit.go | 27 +++++++++-----------
.../BACnetNotificationParametersOutOfRange.go | 27 +++++++++-----------
.../BACnetNotificationParametersUnsignedRange.go | 27 +++++++++-----------
.../bacnetip/readwrite/model/BACnetOpeningTag.go | 27 +++++++++-----------
.../readwrite/model/BACnetPropertyReference.go | 15 +++++------
.../readwrite/model/BACnetPropertyStates.go | 15 +++++------
.../readwrite/model/BACnetPropertyStatesAction.go | 27 +++++++++-----------
.../model/BACnetPropertyStatesBinaryValue.go | 27 +++++++++-----------
.../readwrite/model/BACnetPropertyStatesBoolean.go | 27 +++++++++-----------
.../readwrite/model/BACnetPropertyValue.go | 15 +++++------
.../readwrite/model/BACnetPropertyValues.go | 15 +++++------
.../model/BACnetReadAccessSpecification.go | 15 +++++------
.../bacnetip/readwrite/model/BACnetSegmentation.go | 17 ++++++-------
.../bacnetip/readwrite/model/BACnetServiceAck.go | 15 +++++------
.../model/BACnetServiceAckAtomicReadFile.go | 27 +++++++++-----------
.../model/BACnetServiceAckAtomicReadFileRecord.go | 27 +++++++++-----------
.../model/BACnetServiceAckAtomicReadFileStream.go | 27 +++++++++-----------
...BACnetServiceAckAtomicReadFileStreamOrRecord.go | 15 +++++------
.../model/BACnetServiceAckAtomicWriteFile.go | 27 +++++++++-----------
.../BACnetServiceAckConfirmedPrivateTransfer.go | 27 +++++++++-----------
.../model/BACnetServiceAckCreateObject.go | 27 +++++++++-----------
.../model/BACnetServiceAckGetAlarmSummary.go | 27 +++++++++-----------
.../model/BACnetServiceAckGetEnrollmentSummary.go | 27 +++++++++-----------
.../model/BACnetServiceAckGetEventInformation.go | 27 +++++++++-----------
.../model/BACnetServiceAckReadProperty.go | 27 +++++++++-----------
.../model/BACnetServiceAckReadPropertyMultiple.go | 27 +++++++++-----------
.../readwrite/model/BACnetServiceAckReadRange.go | 27 +++++++++-----------
.../model/BACnetServiceAckRemovedAuthenticate.go | 27 +++++++++-----------
...CnetServiceAckRemovedReadPropertyConditional.go | 27 +++++++++-----------
.../readwrite/model/BACnetServiceAckVTData.go | 27 +++++++++-----------
.../readwrite/model/BACnetServiceAckVTOpen.go | 27 +++++++++-----------
.../bacnetip/readwrite/model/BACnetStatusFlags.go | 17 ++++++-------
.../bacnetip/readwrite/model/BACnetTagHeader.go | 15 +++++------
.../readwrite/model/BACnetTagPayloadBitString.go | 15 +++++------
.../readwrite/model/BACnetTagPayloadBoolean.go | 15 +++++------
.../model/BACnetTagPayloadCharacterString.go | 17 ++++++-------
.../readwrite/model/BACnetTagPayloadDate.go | 15 +++++------
.../readwrite/model/BACnetTagPayloadDouble.go | 15 +++++------
.../readwrite/model/BACnetTagPayloadEnumerated.go | 15 +++++------
.../model/BACnetTagPayloadObjectIdentifier.go | 15 +++++------
.../readwrite/model/BACnetTagPayloadOctetString.go | 15 +++++------
.../readwrite/model/BACnetTagPayloadReal.go | 15 +++++------
.../model/BACnetTagPayloadSignedInteger.go | 15 +++++------
.../readwrite/model/BACnetTagPayloadTime.go | 15 +++++------
.../model/BACnetTagPayloadUnsignedInteger.go | 15 +++++------
.../bacnetip/readwrite/model/BACnetTimeStamp.go | 15 +++++------
.../readwrite/model/BACnetTimeStampDateTime.go | 27 +++++++++-----------
.../readwrite/model/BACnetTimeStampSequence.go | 27 +++++++++-----------
.../readwrite/model/BACnetTimeStampTime.go | 27 +++++++++-----------
.../model/BACnetUnconfirmedServiceRequest.go | 15 +++++------
.../model/BACnetUnconfirmedServiceRequestIAm.go | 27 +++++++++-----------
.../model/BACnetUnconfirmedServiceRequestIHave.go | 27 +++++++++-----------
...UnconfirmedServiceRequestTimeSynchronization.go | 27 +++++++++-----------
...onfirmedServiceRequestUTCTimeSynchronization.go | 27 +++++++++-----------
...rmedServiceRequestUnconfirmedCOVNotification.go | 27 +++++++++-----------
...iceRequestUnconfirmedCOVNotificationMultiple.go | 27 +++++++++-----------
...edServiceRequestUnconfirmedEventNotification.go | 27 +++++++++-----------
...rmedServiceRequestUnconfirmedPrivateTransfer.go | 27 +++++++++-----------
...onfirmedServiceRequestUnconfirmedTextMessage.go | 27 +++++++++-----------
...tUnconfirmedServiceRequestUnconfirmedUnknown.go | 27 +++++++++-----------
.../model/BACnetUnconfirmedServiceRequestWhoHas.go | 27 +++++++++-----------
.../model/BACnetUnconfirmedServiceRequestWhoIs.go | 27 +++++++++-----------
.../BACnetUnconfirmedServiceRequestWriteGroup.go | 27 +++++++++-----------
.../plc4go/bacnetip/readwrite/model/BVLC.go | 15 +++++------
.../model/BVLCDeleteForeignDeviceTableEntry.go | 27 +++++++++-----------
.../model/BVLCDistributeBroadcastToNetwork.go | 27 +++++++++-----------
.../bacnetip/readwrite/model/BVLCForwardedNPDU.go | 27 +++++++++-----------
.../readwrite/model/BVLCOriginalBroadcastNPDU.go | 27 +++++++++-----------
.../readwrite/model/BVLCOriginalUnicastNPDU.go | 27 +++++++++-----------
.../model/BVLCReadBroadcastDistributionTable.go | 27 +++++++++-----------
.../model/BVLCReadBroadcastDistributionTableAck.go | 27 +++++++++-----------
.../readwrite/model/BVLCReadForeignDeviceTable.go | 27 +++++++++-----------
.../model/BVLCReadForeignDeviceTableAck.go | 27 +++++++++-----------
.../readwrite/model/BVLCRegisterForeignDevice.go | 27 +++++++++-----------
.../plc4go/bacnetip/readwrite/model/BVLCResult.go | 27 +++++++++-----------
.../bacnetip/readwrite/model/BVLCSecureBVLL.go | 27 +++++++++-----------
.../model/BVLCWriteBroadcastDistributionTable.go | 27 +++++++++-----------
.../BVLCWriteBroadcastDistributionTableEntry.go | 15 +++++------
.../plc4go/bacnetip/readwrite/model/NLM.go | 15 +++++------
.../model/NLMDisconnectConnectionToNetwork.go | 27 +++++++++-----------
.../model/NLMEstablishConnectionToNetwork.go | 27 +++++++++-----------
.../readwrite/model/NLMIAmRouterToNetwork.go | 27 +++++++++-----------
.../readwrite/model/NLMICouldBeRouterToNetwork.go | 27 +++++++++-----------
.../readwrite/model/NLMInitalizeRoutingTable.go | 27 +++++++++-----------
.../readwrite/model/NLMInitalizeRoutingTableAck.go | 27 +++++++++-----------
.../model/NLMInitalizeRoutingTablePortMapping.go | 15 +++++------
.../readwrite/model/NLMRejectRouterToNetwork.go | 27 +++++++++-----------
.../readwrite/model/NLMRouterAvailableToNetwork.go | 27 +++++++++-----------
.../readwrite/model/NLMRouterBusyToNetwork.go | 27 +++++++++-----------
.../readwrite/model/NLMWhoIsRouterToNetwork.go | 27 +++++++++-----------
.../plc4go/bacnetip/readwrite/model/NPDU.go | 15 +++++------
.../plc4go/bacnetip/readwrite/model/NPDUControl.go | 15 +++++------
.../internal/plc4go/cbus/readwrite/model/Alpha.go | 15 +++++------
.../plc4go/cbus/readwrite/model/BridgeAddress.go | 15 +++++------
.../plc4go/cbus/readwrite/model/BridgeCount.go | 15 +++++------
.../plc4go/cbus/readwrite/model/CALData.go | 17 ++++++-------
.../readwrite/model/CALDataReplyAcknowledge.go | 27 +++++++++-----------
.../cbus/readwrite/model/CALDataReplyReply.go | 27 +++++++++-----------
.../cbus/readwrite/model/CALDataReplyStatus.go | 27 +++++++++-----------
.../readwrite/model/CALDataReplyStatusExtended.go | 27 +++++++++-----------
.../readwrite/model/CALDataRequestGetStatus.go | 27 +++++++++-----------
.../cbus/readwrite/model/CALDataRequestIdentify.go | 27 +++++++++-----------
.../cbus/readwrite/model/CALDataRequestRecall.go | 27 +++++++++-----------
.../cbus/readwrite/model/CALDataRequestReset.go | 27 +++++++++-----------
.../plc4go/cbus/readwrite/model/CALReply.go | 17 ++++++-------
.../plc4go/cbus/readwrite/model/CALReplyLong.go | 27 +++++++++-----------
.../plc4go/cbus/readwrite/model/CALReplyReply.go | 27 +++++++++-----------
.../plc4go/cbus/readwrite/model/CALReplyShort.go | 27 +++++++++-----------
.../plc4go/cbus/readwrite/model/CBusCommand.go | 17 ++++++-------
.../model/CBusCommandPointToMultiPoint.go | 27 +++++++++-----------
.../readwrite/model/CBusCommandPointToPoint.go | 27 +++++++++-----------
.../model/CBusCommandPointToPointToMultiPoint.go | 27 +++++++++-----------
.../CBusCommandPointToPointToMultiPointNormal.go | 27 +++++++++-----------
.../CBusCommandPointToPointToMultiPointStatus.go | 27 +++++++++-----------
.../plc4go/cbus/readwrite/model/CBusHeader.go | 15 +++++------
.../plc4go/cbus/readwrite/model/CBusOptions.go | 15 +++++------
.../model/CBusPointToMultiPointCommand.go | 15 +++++------
.../model/CBusPointToMultiPointCommandNormal.go | 27 +++++++++-----------
.../model/CBusPointToMultiPointCommandStatus.go | 27 +++++++++-----------
.../readwrite/model/CBusPointToPointCommand.go | 15 +++++------
.../model/CBusPointToPointCommandDirect.go | 27 +++++++++-----------
.../model/CBusPointToPointCommandIndirect.go | 27 +++++++++-----------
.../model/CBusPointToPointToMultipointCommand.go | 17 ++++++-------
.../plc4go/cbus/readwrite/model/Checksum.go | 15 +++++------
.../plc4go/cbus/readwrite/model/CommandHeader.go | 15 +++++------
.../plc4go/cbus/readwrite/model/Confirmation.go | 17 ++++++-------
.../cbus/readwrite/model/ConfirmationReply.go | 27 +++++++++-----------
.../cbus/readwrite/model/ConfirmationSuccessful.go | 27 +++++++++-----------
.../plc4go/cbus/readwrite/model/ExclamationMark.go | 15 +++++------
.../cbus/readwrite/model/ExclamationMarkReply.go | 27 +++++++++-----------
.../readwrite/model/ExtendedFormatStatusReply.go | 15 +++++------
.../cbus/readwrite/model/ExtendedStatusHeader.go | 15 +++++------
.../cbus/readwrite/model/IdentifyReplyCommand.go | 15 +++++------
.../IdentifyReplyCommandCurrentSenseLevels.go | 27 +++++++++-----------
.../model/IdentifyReplyCommandDSIStatus.go | 27 +++++++++-----------
.../readwrite/model/IdentifyReplyCommandDelays.go | 27 +++++++++-----------
...dentifyReplyCommandExtendedDiagnosticSummary.go | 27 +++++++++-----------
.../model/IdentifyReplyCommandFirmwareSummary.go | 27 +++++++++-----------
.../model/IdentifyReplyCommandFirmwareVersion.go | 27 +++++++++-----------
.../IdentifyReplyCommandGAVPhysicalAddresses.go | 27 +++++++++-----------
.../model/IdentifyReplyCommandGAVValuesCurrent.go | 27 +++++++++-----------
.../model/IdentifyReplyCommandGAVValuesStored.go | 27 +++++++++-----------
.../model/IdentifyReplyCommandLogicalAssignment.go | 27 +++++++++-----------
.../model/IdentifyReplyCommandManufacturer.go | 27 +++++++++-----------
.../model/IdentifyReplyCommandMaximumLevels.go | 27 +++++++++-----------
.../model/IdentifyReplyCommandMinimumLevels.go | 27 +++++++++-----------
.../IdentifyReplyCommandNetworkTerminalLevels.go | 27 +++++++++-----------
.../model/IdentifyReplyCommandNetworkVoltage.go | 27 +++++++++-----------
.../model/IdentifyReplyCommandOutputUnitSummary.go | 27 +++++++++-----------
.../model/IdentifyReplyCommandTerminalLevels.go | 27 +++++++++-----------
.../readwrite/model/IdentifyReplyCommandType.go | 27 +++++++++-----------
.../plc4go/cbus/readwrite/model/MonitoredSAL.go | 15 +++++------
.../model/MonitoredSALLongFormSmartMode.go | 27 +++++++++-----------
.../cbus/readwrite/model/MonitoredSALReply.go | 27 +++++++++-----------
.../model/MonitoredSALShortFormBasicMode.go | 27 +++++++++-----------
.../plc4go/cbus/readwrite/model/NetworkNumber.go | 15 +++++------
.../model/NetworkProtocolControlInformation.go | 15 +++++------
.../plc4go/cbus/readwrite/model/NetworkRoute.go | 15 +++++------
.../readwrite/model/NotTransmittedCorruption.go | 27 +++++++++-----------
.../cbus/readwrite/model/NotTransmittedSyncLoss.go | 27 +++++++++-----------
.../model/NotTransmittedToManyReTransmissions.go | 27 +++++++++-----------
.../cbus/readwrite/model/NotTransmittedTooLong.go | 27 +++++++++-----------
.../plc4go/cbus/readwrite/model/ParameterChange.go | 17 ++++++-------
.../cbus/readwrite/model/ParameterChangeReply.go | 27 +++++++++-----------
.../plc4go/cbus/readwrite/model/PowerUp.go | 17 ++++++-------
.../plc4go/cbus/readwrite/model/PowerUpReply.go | 27 +++++++++-----------
.../internal/plc4go/cbus/readwrite/model/Reply.go | 15 +++++------
.../plc4go/cbus/readwrite/model/ReplyNetwork.go | 15 +++++------
.../plc4go/cbus/readwrite/model/SALData.go | 17 ++++++-------
.../plc4go/cbus/readwrite/model/SALDataOff.go | 27 +++++++++-----------
.../plc4go/cbus/readwrite/model/SALDataOn.go | 27 +++++++++-----------
.../cbus/readwrite/model/SALDataRampToLevel.go | 27 +++++++++-----------
.../cbus/readwrite/model/SALDataTerminateRamp.go | 27 +++++++++-----------
.../cbus/readwrite/model/SerialInterfaceAddress.go | 15 +++++------
.../readwrite/model/StandardFormatStatusReply.go | 15 +++++------
.../plc4go/cbus/readwrite/model/StatusByte.go | 15 +++++------
.../plc4go/cbus/readwrite/model/StatusHeader.go | 15 +++++------
.../plc4go/cbus/readwrite/model/StatusRequest.go | 15 +++++------
.../readwrite/model/StatusRequestBinaryState.go | 27 +++++++++-----------
.../cbus/readwrite/model/StatusRequestLevel.go | 27 +++++++++-----------
.../plc4go/cbus/readwrite/model/UnitAddress.go | 15 +++++------
.../plc4go/df1/readwrite/model/DF1Command.go | 17 ++++++-------
.../plc4go/df1/readwrite/model/DF1Symbol.go | 15 +++++------
.../df1/readwrite/model/DF1SymbolMessageFrame.go | 27 +++++++++-----------
.../readwrite/model/DF1SymbolMessageFrameACK.go | 27 +++++++++-----------
.../readwrite/model/DF1SymbolMessageFrameNAK.go | 27 +++++++++-----------
.../readwrite/model/DF1UnprotectedReadRequest.go | 27 +++++++++-----------
.../readwrite/model/DF1UnprotectedReadResponse.go | 27 +++++++++-----------
.../plc4go/eip/readwrite/model/CipExchange.go | 17 ++++++-------
.../plc4go/eip/readwrite/model/CipRRData.go | 27 +++++++++-----------
.../plc4go/eip/readwrite/model/CipReadRequest.go | 27 +++++++++-----------
.../plc4go/eip/readwrite/model/CipReadResponse.go | 27 +++++++++-----------
.../plc4go/eip/readwrite/model/CipService.go | 15 +++++------
.../eip/readwrite/model/CipUnconnectedRequest.go | 27 +++++++++-----------
.../plc4go/eip/readwrite/model/CipWriteRequest.go | 27 +++++++++-----------
.../plc4go/eip/readwrite/model/CipWriteResponse.go | 27 +++++++++-----------
.../eip/readwrite/model/EipConnectionRequest.go | 27 +++++++++-----------
.../eip/readwrite/model/EipDisconnectRequest.go | 27 +++++++++-----------
.../plc4go/eip/readwrite/model/EipPacket.go | 15 +++++------
.../eip/readwrite/model/MultipleServiceRequest.go | 27 +++++++++-----------
.../eip/readwrite/model/MultipleServiceResponse.go | 27 +++++++++-----------
.../plc4go/eip/readwrite/model/Services.go | 15 +++++------
.../firmata/readwrite/model/FirmataCommand.go | 15 +++++------
.../model/FirmataCommandProtocolVersion.go | 27 +++++++++-----------
.../model/FirmataCommandSetDigitalPinValue.go | 27 +++++++++-----------
.../readwrite/model/FirmataCommandSetPinMode.go | 27 +++++++++-----------
.../firmata/readwrite/model/FirmataCommandSysex.go | 27 +++++++++-----------
.../readwrite/model/FirmataCommandSystemReset.go | 27 +++++++++-----------
.../firmata/readwrite/model/FirmataMessage.go | 15 +++++------
.../readwrite/model/FirmataMessageAnalogIO.go | 27 +++++++++-----------
.../readwrite/model/FirmataMessageCommand.go | 27 +++++++++-----------
.../readwrite/model/FirmataMessageDigitalIO.go | 27 +++++++++-----------
.../model/FirmataMessageSubscribeAnalogPinValue.go | 27 +++++++++-----------
.../FirmataMessageSubscribeDigitalPinValue.go | 27 +++++++++-----------
.../plc4go/firmata/readwrite/model/SysexCommand.go | 15 +++++------
.../model/SysexCommandAnalogMappingQueryRequest.go | 27 +++++++++-----------
.../SysexCommandAnalogMappingQueryResponse.go | 27 +++++++++-----------
.../model/SysexCommandAnalogMappingResponse.go | 27 +++++++++-----------
.../readwrite/model/SysexCommandCapabilityQuery.go | 27 +++++++++-----------
.../model/SysexCommandCapabilityResponse.go | 27 +++++++++-----------
.../readwrite/model/SysexCommandExtendedAnalog.go | 27 +++++++++-----------
.../readwrite/model/SysexCommandExtendedId.go | 27 +++++++++-----------
.../readwrite/model/SysexCommandPinStateQuery.go | 27 +++++++++-----------
.../model/SysexCommandPinStateResponse.go | 27 +++++++++-----------
.../model/SysexCommandReportFirmwareRequest.go | 27 +++++++++-----------
.../model/SysexCommandReportFirmwareResponse.go | 27 +++++++++-----------
.../model/SysexCommandSamplingInterval.go | 27 +++++++++-----------
.../readwrite/model/SysexCommandStringData.go | 27 +++++++++-----------
.../model/SysexCommandSysexNonRealtime.go | 27 +++++++++-----------
.../readwrite/model/SysexCommandSysexRealtime.go | 27 +++++++++-----------
.../plc4go/knxnetip/readwrite/model/Apdu.go | 17 ++++++-------
.../plc4go/knxnetip/readwrite/model/ApduControl.go | 15 +++++------
.../knxnetip/readwrite/model/ApduControlAck.go | 27 +++++++++-----------
.../knxnetip/readwrite/model/ApduControlConnect.go | 27 +++++++++-----------
.../readwrite/model/ApduControlContainer.go | 27 +++++++++-----------
.../readwrite/model/ApduControlDisconnect.go | 27 +++++++++-----------
.../knxnetip/readwrite/model/ApduControlNack.go | 27 +++++++++-----------
.../plc4go/knxnetip/readwrite/model/ApduData.go | 15 +++++------
.../knxnetip/readwrite/model/ApduDataAdcRead.go | 27 +++++++++-----------
.../readwrite/model/ApduDataAdcResponse.go | 27 +++++++++-----------
.../knxnetip/readwrite/model/ApduDataContainer.go | 27 +++++++++-----------
.../model/ApduDataDeviceDescriptorRead.go | 27 +++++++++-----------
.../model/ApduDataDeviceDescriptorResponse.go | 27 +++++++++-----------
.../plc4go/knxnetip/readwrite/model/ApduDataExt.go | 15 +++++------
.../readwrite/model/ApduDataExtAuthorizeRequest.go | 27 +++++++++-----------
.../model/ApduDataExtAuthorizeResponse.go | 27 +++++++++-----------
.../model/ApduDataExtDomainAddressRead.go | 27 +++++++++-----------
.../model/ApduDataExtDomainAddressResponse.go | 27 +++++++++-----------
.../model/ApduDataExtDomainAddressSelectiveRead.go | 27 +++++++++-----------
.../ApduDataExtDomainAddressSerialNumberRead.go | 27 +++++++++-----------
...ApduDataExtDomainAddressSerialNumberResponse.go | 27 +++++++++-----------
.../ApduDataExtDomainAddressSerialNumberWrite.go | 27 +++++++++-----------
.../model/ApduDataExtDomainAddressWrite.go | 27 +++++++++-----------
.../model/ApduDataExtFileStreamInfoReport.go | 27 +++++++++-----------
.../ApduDataExtGroupPropertyValueInfoReport.go | 27 +++++++++-----------
.../model/ApduDataExtGroupPropertyValueRead.go | 27 +++++++++-----------
.../model/ApduDataExtGroupPropertyValueResponse.go | 27 +++++++++-----------
.../model/ApduDataExtGroupPropertyValueWrite.go | 27 +++++++++-----------
...ApduDataExtIndividualAddressSerialNumberRead.go | 27 +++++++++-----------
...DataExtIndividualAddressSerialNumberResponse.go | 27 +++++++++-----------
...pduDataExtIndividualAddressSerialNumberWrite.go | 27 +++++++++-----------
.../readwrite/model/ApduDataExtKeyResponse.go | 27 +++++++++-----------
.../readwrite/model/ApduDataExtKeyWrite.go | 27 +++++++++-----------
.../readwrite/model/ApduDataExtLinkRead.go | 27 +++++++++-----------
.../readwrite/model/ApduDataExtLinkResponse.go | 27 +++++++++-----------
.../readwrite/model/ApduDataExtLinkWrite.go | 27 +++++++++-----------
.../readwrite/model/ApduDataExtMemoryBitWrite.go | 27 +++++++++-----------
.../model/ApduDataExtNetworkParameterRead.go | 27 +++++++++-----------
.../model/ApduDataExtNetworkParameterResponse.go | 27 +++++++++-----------
.../model/ApduDataExtNetworkParameterWrite.go | 27 +++++++++-----------
.../model/ApduDataExtOpenRoutingTableRequest.go | 27 +++++++++-----------
.../model/ApduDataExtPropertyDescriptionRead.go | 27 +++++++++-----------
.../ApduDataExtPropertyDescriptionResponse.go | 27 +++++++++-----------
.../model/ApduDataExtPropertyValueRead.go | 27 +++++++++-----------
.../model/ApduDataExtPropertyValueResponse.go | 27 +++++++++-----------
.../model/ApduDataExtPropertyValueWrite.go | 27 +++++++++-----------
.../model/ApduDataExtReadRouterMemoryRequest.go | 27 +++++++++-----------
.../model/ApduDataExtReadRouterMemoryResponse.go | 27 +++++++++-----------
.../model/ApduDataExtReadRouterStatusRequest.go | 27 +++++++++-----------
.../model/ApduDataExtReadRouterStatusResponse.go | 27 +++++++++-----------
.../model/ApduDataExtReadRoutingTableRequest.go | 27 +++++++++-----------
.../model/ApduDataExtReadRoutingTableResponse.go | 27 +++++++++-----------
.../model/ApduDataExtWriteRouterMemoryRequest.go | 27 +++++++++-----------
.../model/ApduDataExtWriteRouterStatusRequest.go | 27 +++++++++-----------
.../model/ApduDataExtWriteRoutingTableRequest.go | 27 +++++++++-----------
.../readwrite/model/ApduDataGroupValueRead.go | 27 +++++++++-----------
.../readwrite/model/ApduDataGroupValueResponse.go | 27 +++++++++-----------
.../readwrite/model/ApduDataGroupValueWrite.go | 27 +++++++++-----------
.../model/ApduDataIndividualAddressRead.go | 27 +++++++++-----------
.../model/ApduDataIndividualAddressResponse.go | 27 +++++++++-----------
.../model/ApduDataIndividualAddressWrite.go | 27 +++++++++-----------
.../knxnetip/readwrite/model/ApduDataMemoryRead.go | 27 +++++++++-----------
.../readwrite/model/ApduDataMemoryResponse.go | 27 +++++++++-----------
.../readwrite/model/ApduDataMemoryWrite.go | 27 +++++++++-----------
.../knxnetip/readwrite/model/ApduDataOther.go | 27 +++++++++-----------
.../knxnetip/readwrite/model/ApduDataRestart.go | 27 +++++++++-----------
.../readwrite/model/ApduDataUserMessage.go | 27 +++++++++-----------
.../plc4go/knxnetip/readwrite/model/CEMI.go | 15 +++++------
.../readwrite/model/CEMIAdditionalInformation.go | 15 +++++------
.../CEMIAdditionalInformationBusmonitorInfo.go | 27 +++++++++-----------
.../CEMIAdditionalInformationRelativeTimestamp.go | 27 +++++++++-----------
.../knxnetip/readwrite/model/ChannelInformation.go | 15 +++++------
.../knxnetip/readwrite/model/ComObjectTable.go | 15 +++++------
.../model/ComObjectTableRealisationType1.go | 27 +++++++++-----------
.../model/ComObjectTableRealisationType2.go | 27 +++++++++-----------
.../model/ComObjectTableRealisationType6.go | 27 +++++++++-----------
.../knxnetip/readwrite/model/ConnectionRequest.go | 27 +++++++++-----------
.../model/ConnectionRequestInformation.go | 15 +++++------
...ConnectionRequestInformationDeviceManagement.go | 27 +++++++++-----------
...ConnectionRequestInformationTunnelConnection.go | 27 +++++++++-----------
.../knxnetip/readwrite/model/ConnectionResponse.go | 27 +++++++++-----------
.../readwrite/model/ConnectionResponseDataBlock.go | 15 +++++------
.../ConnectionResponseDataBlockDeviceManagement.go | 27 +++++++++-----------
.../ConnectionResponseDataBlockTunnelConnection.go | 27 +++++++++-----------
.../readwrite/model/ConnectionStateRequest.go | 27 +++++++++-----------
.../readwrite/model/ConnectionStateResponse.go | 27 +++++++++-----------
.../knxnetip/readwrite/model/DIBDeviceInfo.go | 15 +++++------
.../knxnetip/readwrite/model/DIBSuppSvcFamilies.go | 15 +++++------
.../knxnetip/readwrite/model/DescriptionRequest.go | 27 +++++++++-----------
.../readwrite/model/DescriptionResponse.go | 27 +++++++++-----------
.../readwrite/model/DeviceConfigurationAck.go | 27 +++++++++-----------
.../model/DeviceConfigurationAckDataBlock.go | 17 ++++++-------
.../readwrite/model/DeviceConfigurationRequest.go | 27 +++++++++-----------
.../model/DeviceConfigurationRequestDataBlock.go | 15 +++++------
.../readwrite/model/DeviceDescriptorType2.go | 17 ++++++-------
.../knxnetip/readwrite/model/DeviceStatus.go | 15 +++++------
.../knxnetip/readwrite/model/DisconnectRequest.go | 27 +++++++++-----------
.../knxnetip/readwrite/model/DisconnectResponse.go | 27 +++++++++-----------
.../model/GroupObjectDescriptorRealisationType1.go | 15 +++++------
.../model/GroupObjectDescriptorRealisationType2.go | 17 ++++++-------
.../model/GroupObjectDescriptorRealisationType6.go | 15 +++++------
.../model/GroupObjectDescriptorRealisationType7.go | 17 ++++++-------
.../model/GroupObjectDescriptorRealisationTypeB.go | 15 +++++------
.../readwrite/model/HPAIControlEndpoint.go | 17 ++++++-------
.../knxnetip/readwrite/model/HPAIDataEndpoint.go | 17 ++++++-------
.../readwrite/model/HPAIDiscoveryEndpoint.go | 17 ++++++-------
.../plc4go/knxnetip/readwrite/model/IPAddress.go | 15 +++++------
.../plc4go/knxnetip/readwrite/model/KnxAddress.go | 15 +++++------
.../knxnetip/readwrite/model/KnxGroupAddress.go | 15 +++++------
.../readwrite/model/KnxGroupAddress2Level.go | 27 +++++++++-----------
.../readwrite/model/KnxGroupAddress3Level.go | 27 +++++++++-----------
.../readwrite/model/KnxGroupAddressFreeLevel.go | 27 +++++++++-----------
.../knxnetip/readwrite/model/KnxNetIpCore.go | 27 +++++++++-----------
.../readwrite/model/KnxNetIpDeviceManagement.go | 27 +++++++++-----------
.../knxnetip/readwrite/model/KnxNetIpMessage.go | 15 +++++------
.../knxnetip/readwrite/model/KnxNetIpRouting.go | 27 +++++++++-----------
.../knxnetip/readwrite/model/KnxNetIpTunneling.go | 27 +++++++++-----------
.../knxnetip/readwrite/model/KnxNetObjectServer.go | 27 +++++++++-----------
.../model/KnxNetRemoteConfigurationAndDiagnosis.go | 27 +++++++++-----------
.../readwrite/model/KnxNetRemoteLogging.go | 27 +++++++++-----------
.../plc4go/knxnetip/readwrite/model/LBusmonInd.go | 27 +++++++++-----------
.../plc4go/knxnetip/readwrite/model/LDataCon.go | 27 +++++++++-----------
.../knxnetip/readwrite/model/LDataExtended.go | 27 +++++++++-----------
.../plc4go/knxnetip/readwrite/model/LDataFrame.go | 15 +++++------
.../knxnetip/readwrite/model/LDataFrameACK.go | 27 +++++++++-----------
.../plc4go/knxnetip/readwrite/model/LDataInd.go | 27 +++++++++-----------
.../plc4go/knxnetip/readwrite/model/LDataReq.go | 27 +++++++++-----------
.../plc4go/knxnetip/readwrite/model/LPollData.go | 27 +++++++++-----------
.../knxnetip/readwrite/model/LPollDataCon.go | 27 +++++++++-----------
.../knxnetip/readwrite/model/LPollDataReq.go | 27 +++++++++-----------
.../plc4go/knxnetip/readwrite/model/LRawCon.go | 27 +++++++++-----------
.../plc4go/knxnetip/readwrite/model/LRawInd.go | 27 +++++++++-----------
.../plc4go/knxnetip/readwrite/model/LRawReq.go | 27 +++++++++-----------
.../plc4go/knxnetip/readwrite/model/MACAddress.go | 15 +++++------
.../readwrite/model/MFuncPropCommandReq.go | 27 +++++++++-----------
.../knxnetip/readwrite/model/MFuncPropCon.go | 27 +++++++++-----------
.../readwrite/model/MFuncPropStateReadReq.go | 27 +++++++++-----------
.../knxnetip/readwrite/model/MPropInfoInd.go | 27 +++++++++-----------
.../knxnetip/readwrite/model/MPropReadCon.go | 27 +++++++++-----------
.../knxnetip/readwrite/model/MPropReadReq.go | 27 +++++++++-----------
.../knxnetip/readwrite/model/MPropWriteCon.go | 27 +++++++++-----------
.../knxnetip/readwrite/model/MPropWriteReq.go | 27 +++++++++-----------
.../plc4go/knxnetip/readwrite/model/MResetInd.go | 27 +++++++++-----------
.../plc4go/knxnetip/readwrite/model/MResetReq.go | 27 +++++++++-----------
.../model/ProjectInstallationIdentifier.go | 15 +++++------
.../knxnetip/readwrite/model/RelativeTimestamp.go | 15 +++++------
.../knxnetip/readwrite/model/RoutingIndication.go | 27 +++++++++-----------
.../knxnetip/readwrite/model/SearchRequest.go | 27 +++++++++-----------
.../knxnetip/readwrite/model/SearchResponse.go | 27 +++++++++-----------
.../plc4go/knxnetip/readwrite/model/ServiceId.go | 15 +++++------
.../knxnetip/readwrite/model/TDataConnectedInd.go | 27 +++++++++-----------
.../knxnetip/readwrite/model/TDataConnectedReq.go | 27 +++++++++-----------
.../knxnetip/readwrite/model/TDataIndividualInd.go | 27 +++++++++-----------
.../knxnetip/readwrite/model/TDataIndividualReq.go | 27 +++++++++-----------
.../knxnetip/readwrite/model/TunnelingRequest.go | 27 +++++++++-----------
.../readwrite/model/TunnelingRequestDataBlock.go | 15 +++++------
.../knxnetip/readwrite/model/TunnelingResponse.go | 27 +++++++++-----------
.../readwrite/model/TunnelingResponseDataBlock.go | 17 ++++++-------
.../knxnetip/readwrite/model/UnknownMessage.go | 27 +++++++++-----------
.../modbus/readwrite/model/ModbusConstants.go | 15 +++++------
.../model/ModbusDeviceInformationObject.go | 15 +++++------
.../plc4go/modbus/readwrite/model/ModbusPDU.go | 15 +++++------
.../readwrite/model/ModbusPDUDiagnosticRequest.go | 27 +++++++++-----------
.../readwrite/model/ModbusPDUDiagnosticResponse.go | 27 +++++++++-----------
.../modbus/readwrite/model/ModbusPDUError.go | 27 +++++++++-----------
.../model/ModbusPDUGetComEventCounterRequest.go | 27 +++++++++-----------
.../model/ModbusPDUGetComEventCounterResponse.go | 27 +++++++++-----------
.../model/ModbusPDUGetComEventLogRequest.go | 27 +++++++++-----------
.../model/ModbusPDUGetComEventLogResponse.go | 27 +++++++++-----------
.../ModbusPDUMaskWriteHoldingRegisterRequest.go | 27 +++++++++-----------
.../ModbusPDUMaskWriteHoldingRegisterResponse.go | 27 +++++++++-----------
.../readwrite/model/ModbusPDUReadCoilsRequest.go | 27 +++++++++-----------
.../readwrite/model/ModbusPDUReadCoilsResponse.go | 27 +++++++++-----------
.../ModbusPDUReadDeviceIdentificationRequest.go | 27 +++++++++-----------
.../ModbusPDUReadDeviceIdentificationResponse.go | 27 +++++++++-----------
.../model/ModbusPDUReadDiscreteInputsRequest.go | 27 +++++++++-----------
.../model/ModbusPDUReadDiscreteInputsResponse.go | 27 +++++++++-----------
.../model/ModbusPDUReadExceptionStatusRequest.go | 27 +++++++++-----------
.../model/ModbusPDUReadExceptionStatusResponse.go | 27 +++++++++-----------
.../model/ModbusPDUReadFifoQueueRequest.go | 27 +++++++++-----------
.../model/ModbusPDUReadFifoQueueResponse.go | 27 +++++++++-----------
.../model/ModbusPDUReadFileRecordRequest.go | 27 +++++++++-----------
.../model/ModbusPDUReadFileRecordRequestItem.go | 15 +++++------
.../model/ModbusPDUReadFileRecordResponse.go | 27 +++++++++-----------
.../model/ModbusPDUReadFileRecordResponseItem.go | 15 +++++------
.../model/ModbusPDUReadHoldingRegistersRequest.go | 27 +++++++++-----------
.../model/ModbusPDUReadHoldingRegistersResponse.go | 27 +++++++++-----------
.../model/ModbusPDUReadInputRegistersRequest.go | 27 +++++++++-----------
.../model/ModbusPDUReadInputRegistersResponse.go | 27 +++++++++-----------
...sPDUReadWriteMultipleHoldingRegistersRequest.go | 27 +++++++++-----------
...PDUReadWriteMultipleHoldingRegistersResponse.go | 27 +++++++++-----------
.../model/ModbusPDUReportServerIdRequest.go | 27 +++++++++-----------
.../model/ModbusPDUReportServerIdResponse.go | 27 +++++++++-----------
.../model/ModbusPDUWriteFileRecordRequest.go | 27 +++++++++-----------
.../model/ModbusPDUWriteFileRecordRequestItem.go | 15 +++++------
.../model/ModbusPDUWriteFileRecordResponse.go | 27 +++++++++-----------
.../model/ModbusPDUWriteFileRecordResponseItem.go | 15 +++++------
.../model/ModbusPDUWriteMultipleCoilsRequest.go | 27 +++++++++-----------
.../model/ModbusPDUWriteMultipleCoilsResponse.go | 27 +++++++++-----------
...odbusPDUWriteMultipleHoldingRegistersRequest.go | 27 +++++++++-----------
...dbusPDUWriteMultipleHoldingRegistersResponse.go | 27 +++++++++-----------
.../model/ModbusPDUWriteSingleCoilRequest.go | 27 +++++++++-----------
.../model/ModbusPDUWriteSingleCoilResponse.go | 27 +++++++++-----------
.../model/ModbusPDUWriteSingleRegisterRequest.go | 27 +++++++++-----------
.../model/ModbusPDUWriteSingleRegisterResponse.go | 27 +++++++++-----------
.../modbus/readwrite/model/ModbusSerialADU.go | 15 +++++------
.../plc4go/modbus/readwrite/model/ModbusTcpADU.go | 17 ++++++-------
.../model/AlarmMessageAckObjectPushType.go | 17 ++++++-------
.../s7/readwrite/model/AlarmMessageAckPushType.go | 15 +++++------
.../readwrite/model/AlarmMessageAckResponseType.go | 15 +++++------
.../s7/readwrite/model/AlarmMessageAckType.go | 15 +++++------
.../readwrite/model/AlarmMessageObjectAckType.go | 17 ++++++-------
.../readwrite/model/AlarmMessageObjectPushType.go | 15 +++++------
.../readwrite/model/AlarmMessageObjectQueryType.go | 15 +++++------
.../s7/readwrite/model/AlarmMessagePushType.go | 15 +++++------
.../s7/readwrite/model/AlarmMessageQueryType.go | 15 +++++------
.../s7/readwrite/model/AssociatedValueType.go | 15 +++++------
.../plc4go/s7/readwrite/model/COTPPacket.go | 15 +++++------
.../readwrite/model/COTPPacketConnectionRequest.go | 27 +++++++++-----------
.../model/COTPPacketConnectionResponse.go | 27 +++++++++-----------
.../plc4go/s7/readwrite/model/COTPPacketData.go | 27 +++++++++-----------
.../readwrite/model/COTPPacketDisconnectRequest.go | 27 +++++++++-----------
.../model/COTPPacketDisconnectResponse.go | 27 +++++++++-----------
.../s7/readwrite/model/COTPPacketTpduError.go | 27 +++++++++-----------
.../plc4go/s7/readwrite/model/COTPParameter.go | 15 +++++------
.../s7/readwrite/model/COTPParameterCalledTsap.go | 27 +++++++++-----------
.../s7/readwrite/model/COTPParameterCallingTsap.go | 27 +++++++++-----------
.../s7/readwrite/model/COTPParameterChecksum.go | 27 +++++++++-----------
...COTPParameterDisconnectAdditionalInformation.go | 27 +++++++++-----------
.../s7/readwrite/model/COTPParameterTpduSize.go | 27 +++++++++-----------
.../plc4go/s7/readwrite/model/DateAndTime.go | 15 +++++------
.../plc4go/s7/readwrite/model/S7Address.go | 15 +++++------
.../plc4go/s7/readwrite/model/S7AddressAny.go | 27 +++++++++-----------
.../s7/readwrite/model/S7DataAlarmMessage.go | 17 ++++++-------
.../plc4go/s7/readwrite/model/S7Message.go | 15 +++++------
.../s7/readwrite/model/S7MessageObjectRequest.go | 27 +++++++++-----------
.../s7/readwrite/model/S7MessageObjectResponse.go | 27 +++++++++-----------
.../plc4go/s7/readwrite/model/S7MessageRequest.go | 27 +++++++++-----------
.../plc4go/s7/readwrite/model/S7MessageResponse.go | 27 +++++++++-----------
.../s7/readwrite/model/S7MessageResponseData.go | 27 +++++++++-----------
.../plc4go/s7/readwrite/model/S7MessageUserData.go | 27 +++++++++-----------
.../plc4go/s7/readwrite/model/S7Parameter.go | 15 +++++------
.../readwrite/model/S7ParameterModeTransition.go | 27 +++++++++-----------
.../readwrite/model/S7ParameterReadVarRequest.go | 27 +++++++++-----------
.../readwrite/model/S7ParameterReadVarResponse.go | 27 +++++++++-----------
.../model/S7ParameterSetupCommunication.go | 27 +++++++++-----------
.../s7/readwrite/model/S7ParameterUserData.go | 27 +++++++++-----------
.../s7/readwrite/model/S7ParameterUserDataItem.go | 15 +++++------
.../model/S7ParameterUserDataItemCPUFunctions.go | 27 +++++++++-----------
.../readwrite/model/S7ParameterWriteVarRequest.go | 27 +++++++++-----------
.../readwrite/model/S7ParameterWriteVarResponse.go | 27 +++++++++-----------
.../plc4go/s7/readwrite/model/S7Payload.go | 15 +++++------
.../plc4go/s7/readwrite/model/S7PayloadAlarm8.go | 27 +++++++++-----------
.../s7/readwrite/model/S7PayloadAlarmAckInd.go | 27 +++++++++-----------
.../plc4go/s7/readwrite/model/S7PayloadAlarmS.go | 27 +++++++++-----------
.../plc4go/s7/readwrite/model/S7PayloadAlarmSC.go | 27 +++++++++-----------
.../plc4go/s7/readwrite/model/S7PayloadAlarmSQ.go | 27 +++++++++-----------
.../readwrite/model/S7PayloadDiagnosticMessage.go | 27 +++++++++-----------
.../plc4go/s7/readwrite/model/S7PayloadNotify.go | 27 +++++++++-----------
.../plc4go/s7/readwrite/model/S7PayloadNotify8.go | 27 +++++++++-----------
.../s7/readwrite/model/S7PayloadReadVarResponse.go | 27 +++++++++-----------
.../plc4go/s7/readwrite/model/S7PayloadUserData.go | 27 +++++++++-----------
.../s7/readwrite/model/S7PayloadUserDataItem.go | 15 +++++------
.../S7PayloadUserDataItemCpuFunctionAlarmAck.go | 27 +++++++++-----------
...yloadUserDataItemCpuFunctionAlarmAckResponse.go | 27 +++++++++-----------
.../S7PayloadUserDataItemCpuFunctionAlarmQuery.go | 27 +++++++++-----------
...oadUserDataItemCpuFunctionAlarmQueryResponse.go | 27 +++++++++-----------
...ayloadUserDataItemCpuFunctionMsgSubscription.go | 27 +++++++++-----------
...aItemCpuFunctionMsgSubscriptionAlarmResponse.go | 27 +++++++++-----------
...erDataItemCpuFunctionMsgSubscriptionResponse.go | 27 +++++++++-----------
...ataItemCpuFunctionMsgSubscriptionSysResponse.go | 27 +++++++++-----------
...PayloadUserDataItemCpuFunctionReadSzlRequest.go | 27 +++++++++-----------
...ayloadUserDataItemCpuFunctionReadSzlResponse.go | 27 +++++++++-----------
.../s7/readwrite/model/S7PayloadWriteVarRequest.go | 27 +++++++++-----------
.../readwrite/model/S7PayloadWriteVarResponse.go | 27 +++++++++-----------
.../s7/readwrite/model/S7VarPayloadDataItem.go | 15 +++++------
.../s7/readwrite/model/S7VarPayloadStatusItem.go | 15 +++++------
.../readwrite/model/S7VarRequestParameterItem.go | 15 +++++------
.../model/S7VarRequestParameterItemAddress.go | 27 +++++++++-----------
plc4go/internal/plc4go/s7/readwrite/model/State.go | 15 +++++------
.../plc4go/s7/readwrite/model/SzlDataTreeItem.go | 15 +++++------
plc4go/internal/plc4go/s7/readwrite/model/SzlId.go | 17 ++++++-------
.../plc4go/s7/readwrite/model/TPKTPacket.go | 15 +++++------
.../plc4go/simulated/readwrite/model/Dummy.go | 15 +++++------
701 files changed, 7373 insertions(+), 9476 deletions(-)
diff --git a/code-generation/language-go/src/main/resources/templates/go/model-template.go.ftlh b/code-generation/language-go/src/main/resources/templates/go/model-template.go.ftlh
index 93bb390..1c21235 100644
--- a/code-generation/language-go/src/main/resources/templates/go/model-template.go.ftlh
+++ b/code-generation/language-go/src/main/resources/templates/go/model-template.go.ftlh
@@ -338,24 +338,21 @@ func New${type.name}(
}
func Cast${type.name}(structType interface{}) *${type.name} {
- castFunc := func(typ interface{}) *${type.name} {
- if casted, ok := typ.(${type.name}); ok {
- return &casted
- }
- if casted, ok := typ.(*${type.name}); ok {
- return casted
- }
+ if casted, ok := structType.(${type.name}); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*${type.name}); ok {
+ return casted
+ }
<#if type.parentType.isPresent()>
- if casted, ok := typ.(${type.parentType.orElseThrow().name}); ok {
- return Cast${type.name}(casted.Child)
- }
- if casted, ok := typ.(*${type.parentType.orElseThrow().name}); ok {
- return Cast${type.name}(casted.Child)
- }
- </#if>
- return nil
+ if casted, ok := structType.(${type.parentType.orElseThrow().name}); ok {
+ return Cast${type.name}(casted.Child)
+ }
+ if casted, ok := structType.(*${type.parentType.orElseThrow().name}); ok {
+ return Cast${type.name}(casted.Child)
}
- return castFunc(structType)
+ </#if>
+ return nil
}
func (m *${type.name}) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/abeth/readwrite/model/CIPEncapsulationConnectionRequest.go b/plc4go/internal/plc4go/abeth/readwrite/model/CIPEncapsulationConnectionRequest.go
index fa9ca0c..8e02466 100644
--- a/plc4go/internal/plc4go/abeth/readwrite/model/CIPEncapsulationConnectionRequest.go
+++ b/plc4go/internal/plc4go/abeth/readwrite/model/CIPEncapsulationConnectionRequest.go
@@ -77,22 +77,19 @@ func NewCIPEncapsulationConnectionRequest(sessionHandle uint32, status uint32, s
}
func CastCIPEncapsulationConnectionRequest(structType interface{}) *CIPEncapsulationConnectionRequest {
- castFunc := func(typ interface{}) *CIPEncapsulationConnectionRequest {
- if casted, ok := typ.(CIPEncapsulationConnectionRequest); ok {
- return &casted
- }
- if casted, ok := typ.(*CIPEncapsulationConnectionRequest); ok {
- return casted
- }
- if casted, ok := typ.(CIPEncapsulationPacket); ok {
- return CastCIPEncapsulationConnectionRequest(casted.Child)
- }
- if casted, ok := typ.(*CIPEncapsulationPacket); ok {
- return CastCIPEncapsulationConnectionRequest(casted.Child)
- }
- return nil
+ if casted, ok := structType.(CIPEncapsulationConnectionRequest); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*CIPEncapsulationConnectionRequest); ok {
+ return casted
+ }
+ if casted, ok := structType.(CIPEncapsulationPacket); ok {
+ return CastCIPEncapsulationConnectionRequest(casted.Child)
+ }
+ if casted, ok := structType.(*CIPEncapsulationPacket); ok {
+ return CastCIPEncapsulationConnectionRequest(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *CIPEncapsulationConnectionRequest) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/abeth/readwrite/model/CIPEncapsulationConnectionResponse.go b/plc4go/internal/plc4go/abeth/readwrite/model/CIPEncapsulationConnectionResponse.go
index dca6ee9..0b6704c 100644
--- a/plc4go/internal/plc4go/abeth/readwrite/model/CIPEncapsulationConnectionResponse.go
+++ b/plc4go/internal/plc4go/abeth/readwrite/model/CIPEncapsulationConnectionResponse.go
@@ -77,22 +77,19 @@ func NewCIPEncapsulationConnectionResponse(sessionHandle uint32, status uint32,
}
func CastCIPEncapsulationConnectionResponse(structType interface{}) *CIPEncapsulationConnectionResponse {
- castFunc := func(typ interface{}) *CIPEncapsulationConnectionResponse {
- if casted, ok := typ.(CIPEncapsulationConnectionResponse); ok {
- return &casted
- }
- if casted, ok := typ.(*CIPEncapsulationConnectionResponse); ok {
- return casted
- }
- if casted, ok := typ.(CIPEncapsulationPacket); ok {
- return CastCIPEncapsulationConnectionResponse(casted.Child)
- }
- if casted, ok := typ.(*CIPEncapsulationPacket); ok {
- return CastCIPEncapsulationConnectionResponse(casted.Child)
- }
- return nil
+ if casted, ok := structType.(CIPEncapsulationConnectionResponse); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*CIPEncapsulationConnectionResponse); ok {
+ return casted
+ }
+ if casted, ok := structType.(CIPEncapsulationPacket); ok {
+ return CastCIPEncapsulationConnectionResponse(casted.Child)
+ }
+ if casted, ok := structType.(*CIPEncapsulationPacket); ok {
+ return CastCIPEncapsulationConnectionResponse(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *CIPEncapsulationConnectionResponse) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/abeth/readwrite/model/CIPEncapsulationPacket.go b/plc4go/internal/plc4go/abeth/readwrite/model/CIPEncapsulationPacket.go
index 059b7a0..8345c9f 100644
--- a/plc4go/internal/plc4go/abeth/readwrite/model/CIPEncapsulationPacket.go
+++ b/plc4go/internal/plc4go/abeth/readwrite/model/CIPEncapsulationPacket.go
@@ -97,16 +97,13 @@ func NewCIPEncapsulationPacket(sessionHandle uint32, status uint32, senderContex
}
func CastCIPEncapsulationPacket(structType interface{}) *CIPEncapsulationPacket {
- castFunc := func(typ interface{}) *CIPEncapsulationPacket {
- if casted, ok := typ.(CIPEncapsulationPacket); ok {
- return &casted
- }
- if casted, ok := typ.(*CIPEncapsulationPacket); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(CIPEncapsulationPacket); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*CIPEncapsulationPacket); ok {
+ return casted
+ }
+ return nil
}
func (m *CIPEncapsulationPacket) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/abeth/readwrite/model/CIPEncapsulationReadRequest.go b/plc4go/internal/plc4go/abeth/readwrite/model/CIPEncapsulationReadRequest.go
index 0bdf6f4..9ac8a63 100644
--- a/plc4go/internal/plc4go/abeth/readwrite/model/CIPEncapsulationReadRequest.go
+++ b/plc4go/internal/plc4go/abeth/readwrite/model/CIPEncapsulationReadRequest.go
@@ -85,22 +85,19 @@ func NewCIPEncapsulationReadRequest(request *DF1RequestMessage, sessionHandle ui
}
func CastCIPEncapsulationReadRequest(structType interface{}) *CIPEncapsulationReadRequest {
- castFunc := func(typ interface{}) *CIPEncapsulationReadRequest {
- if casted, ok := typ.(CIPEncapsulationReadRequest); ok {
- return &casted
- }
- if casted, ok := typ.(*CIPEncapsulationReadRequest); ok {
- return casted
- }
- if casted, ok := typ.(CIPEncapsulationPacket); ok {
- return CastCIPEncapsulationReadRequest(casted.Child)
- }
- if casted, ok := typ.(*CIPEncapsulationPacket); ok {
- return CastCIPEncapsulationReadRequest(casted.Child)
- }
- return nil
+ if casted, ok := structType.(CIPEncapsulationReadRequest); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*CIPEncapsulationReadRequest); ok {
+ return casted
+ }
+ if casted, ok := structType.(CIPEncapsulationPacket); ok {
+ return CastCIPEncapsulationReadRequest(casted.Child)
+ }
+ if casted, ok := structType.(*CIPEncapsulationPacket); ok {
+ return CastCIPEncapsulationReadRequest(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *CIPEncapsulationReadRequest) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/abeth/readwrite/model/CIPEncapsulationReadResponse.go b/plc4go/internal/plc4go/abeth/readwrite/model/CIPEncapsulationReadResponse.go
index 26479c4..97587ec 100644
--- a/plc4go/internal/plc4go/abeth/readwrite/model/CIPEncapsulationReadResponse.go
+++ b/plc4go/internal/plc4go/abeth/readwrite/model/CIPEncapsulationReadResponse.go
@@ -88,22 +88,19 @@ func NewCIPEncapsulationReadResponse(response *DF1ResponseMessage, sessionHandle
}
func CastCIPEncapsulationReadResponse(structType interface{}) *CIPEncapsulationReadResponse {
- castFunc := func(typ interface{}) *CIPEncapsulationReadResponse {
- if casted, ok := typ.(CIPEncapsulationReadResponse); ok {
- return &casted
- }
- if casted, ok := typ.(*CIPEncapsulationReadResponse); ok {
- return casted
- }
- if casted, ok := typ.(CIPEncapsulationPacket); ok {
- return CastCIPEncapsulationReadResponse(casted.Child)
- }
- if casted, ok := typ.(*CIPEncapsulationPacket); ok {
- return CastCIPEncapsulationReadResponse(casted.Child)
- }
- return nil
+ if casted, ok := structType.(CIPEncapsulationReadResponse); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*CIPEncapsulationReadResponse); ok {
+ return casted
+ }
+ if casted, ok := structType.(CIPEncapsulationPacket); ok {
+ return CastCIPEncapsulationReadResponse(casted.Child)
+ }
+ if casted, ok := structType.(*CIPEncapsulationPacket); ok {
+ return CastCIPEncapsulationReadResponse(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *CIPEncapsulationReadResponse) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/abeth/readwrite/model/DF1CommandRequestMessage.go b/plc4go/internal/plc4go/abeth/readwrite/model/DF1CommandRequestMessage.go
index 96e9ec4..8ff0181 100644
--- a/plc4go/internal/plc4go/abeth/readwrite/model/DF1CommandRequestMessage.go
+++ b/plc4go/internal/plc4go/abeth/readwrite/model/DF1CommandRequestMessage.go
@@ -85,22 +85,19 @@ func NewDF1CommandRequestMessage(command *DF1RequestCommand, destinationAddress
}
func CastDF1CommandRequestMessage(structType interface{}) *DF1CommandRequestMessage {
- castFunc := func(typ interface{}) *DF1CommandRequestMessage {
- if casted, ok := typ.(DF1CommandRequestMessage); ok {
- return &casted
- }
- if casted, ok := typ.(*DF1CommandRequestMessage); ok {
- return casted
- }
- if casted, ok := typ.(DF1RequestMessage); ok {
- return CastDF1CommandRequestMessage(casted.Child)
- }
- if casted, ok := typ.(*DF1RequestMessage); ok {
- return CastDF1CommandRequestMessage(casted.Child)
- }
- return nil
+ if casted, ok := structType.(DF1CommandRequestMessage); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*DF1CommandRequestMessage); ok {
+ return casted
+ }
+ if casted, ok := structType.(DF1RequestMessage); ok {
+ return CastDF1CommandRequestMessage(casted.Child)
+ }
+ if casted, ok := structType.(*DF1RequestMessage); ok {
+ return CastDF1CommandRequestMessage(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *DF1CommandRequestMessage) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/abeth/readwrite/model/DF1CommandResponseMessageProtectedTypedLogicalRead.go b/plc4go/internal/plc4go/abeth/readwrite/model/DF1CommandResponseMessageProtectedTypedLogicalRead.go
index 78ecad8..c0995ee 100644
--- a/plc4go/internal/plc4go/abeth/readwrite/model/DF1CommandResponseMessageProtectedTypedLogicalRead.go
+++ b/plc4go/internal/plc4go/abeth/readwrite/model/DF1CommandResponseMessageProtectedTypedLogicalRead.go
@@ -88,22 +88,19 @@ func NewDF1CommandResponseMessageProtectedTypedLogicalRead(data []uint8, destina
}
func CastDF1CommandResponseMessageProtectedTypedLogicalRead(structType interface{}) *DF1CommandResponseMessageProtectedTypedLogicalRead {
- castFunc := func(typ interface{}) *DF1CommandResponseMessageProtectedTypedLogicalRead {
- if casted, ok := typ.(DF1CommandResponseMessageProtectedTypedLogicalRead); ok {
- return &casted
- }
- if casted, ok := typ.(*DF1CommandResponseMessageProtectedTypedLogicalRead); ok {
- return casted
- }
- if casted, ok := typ.(DF1ResponseMessage); ok {
- return CastDF1CommandResponseMessageProtectedTypedLogicalRead(casted.Child)
- }
- if casted, ok := typ.(*DF1ResponseMessage); ok {
- return CastDF1CommandResponseMessageProtectedTypedLogicalRead(casted.Child)
- }
- return nil
+ if casted, ok := structType.(DF1CommandResponseMessageProtectedTypedLogicalRead); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*DF1CommandResponseMessageProtectedTypedLogicalRead); ok {
+ return casted
+ }
+ if casted, ok := structType.(DF1ResponseMessage); ok {
+ return CastDF1CommandResponseMessageProtectedTypedLogicalRead(casted.Child)
+ }
+ if casted, ok := structType.(*DF1ResponseMessage); ok {
+ return CastDF1CommandResponseMessageProtectedTypedLogicalRead(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *DF1CommandResponseMessageProtectedTypedLogicalRead) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/abeth/readwrite/model/DF1RequestCommand.go b/plc4go/internal/plc4go/abeth/readwrite/model/DF1RequestCommand.go
index ad9f9cb..f20d235 100644
--- a/plc4go/internal/plc4go/abeth/readwrite/model/DF1RequestCommand.go
+++ b/plc4go/internal/plc4go/abeth/readwrite/model/DF1RequestCommand.go
@@ -69,16 +69,13 @@ func NewDF1RequestCommand() *DF1RequestCommand {
}
func CastDF1RequestCommand(structType interface{}) *DF1RequestCommand {
- castFunc := func(typ interface{}) *DF1RequestCommand {
- if casted, ok := typ.(DF1RequestCommand); ok {
- return &casted
- }
- if casted, ok := typ.(*DF1RequestCommand); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(DF1RequestCommand); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*DF1RequestCommand); ok {
+ return casted
+ }
+ return nil
}
func (m *DF1RequestCommand) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/abeth/readwrite/model/DF1RequestMessage.go b/plc4go/internal/plc4go/abeth/readwrite/model/DF1RequestMessage.go
index 3128792..887fe7a 100644
--- a/plc4go/internal/plc4go/abeth/readwrite/model/DF1RequestMessage.go
+++ b/plc4go/internal/plc4go/abeth/readwrite/model/DF1RequestMessage.go
@@ -97,16 +97,13 @@ func NewDF1RequestMessage(destinationAddress uint8, sourceAddress uint8, status
}
func CastDF1RequestMessage(structType interface{}) *DF1RequestMessage {
- castFunc := func(typ interface{}) *DF1RequestMessage {
- if casted, ok := typ.(DF1RequestMessage); ok {
- return &casted
- }
- if casted, ok := typ.(*DF1RequestMessage); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(DF1RequestMessage); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*DF1RequestMessage); ok {
+ return casted
+ }
+ return nil
}
func (m *DF1RequestMessage) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/abeth/readwrite/model/DF1RequestProtectedTypedLogicalRead.go b/plc4go/internal/plc4go/abeth/readwrite/model/DF1RequestProtectedTypedLogicalRead.go
index a456950..ebf8044 100644
--- a/plc4go/internal/plc4go/abeth/readwrite/model/DF1RequestProtectedTypedLogicalRead.go
+++ b/plc4go/internal/plc4go/abeth/readwrite/model/DF1RequestProtectedTypedLogicalRead.go
@@ -112,22 +112,19 @@ func NewDF1RequestProtectedTypedLogicalRead(byteSize uint8, fileNumber uint8, fi
}
func CastDF1RequestProtectedTypedLogicalRead(structType interface{}) *DF1RequestProtectedTypedLogicalRead {
- castFunc := func(typ interface{}) *DF1RequestProtectedTypedLogicalRead {
- if casted, ok := typ.(DF1RequestProtectedTypedLogicalRead); ok {
- return &casted
- }
- if casted, ok := typ.(*DF1RequestProtectedTypedLogicalRead); ok {
- return casted
- }
- if casted, ok := typ.(DF1RequestCommand); ok {
- return CastDF1RequestProtectedTypedLogicalRead(casted.Child)
- }
- if casted, ok := typ.(*DF1RequestCommand); ok {
- return CastDF1RequestProtectedTypedLogicalRead(casted.Child)
- }
- return nil
+ if casted, ok := structType.(DF1RequestProtectedTypedLogicalRead); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*DF1RequestProtectedTypedLogicalRead); ok {
+ return casted
+ }
+ if casted, ok := structType.(DF1RequestCommand); ok {
+ return CastDF1RequestProtectedTypedLogicalRead(casted.Child)
+ }
+ if casted, ok := structType.(*DF1RequestCommand); ok {
+ return CastDF1RequestProtectedTypedLogicalRead(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *DF1RequestProtectedTypedLogicalRead) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/abeth/readwrite/model/DF1ResponseMessage.go b/plc4go/internal/plc4go/abeth/readwrite/model/DF1ResponseMessage.go
index e153640..1934464 100644
--- a/plc4go/internal/plc4go/abeth/readwrite/model/DF1ResponseMessage.go
+++ b/plc4go/internal/plc4go/abeth/readwrite/model/DF1ResponseMessage.go
@@ -100,16 +100,13 @@ func NewDF1ResponseMessage(destinationAddress uint8, sourceAddress uint8, status
}
func CastDF1ResponseMessage(structType interface{}) *DF1ResponseMessage {
- castFunc := func(typ interface{}) *DF1ResponseMessage {
- if casted, ok := typ.(DF1ResponseMessage); ok {
- return &casted
- }
- if casted, ok := typ.(*DF1ResponseMessage); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(DF1ResponseMessage); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*DF1ResponseMessage); ok {
+ return casted
+ }
+ return nil
}
func (m *DF1ResponseMessage) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AdsAddDeviceNotificationRequest.go b/plc4go/internal/plc4go/ads/readwrite/model/AdsAddDeviceNotificationRequest.go
index 4d11e4f..7040b91 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AdsAddDeviceNotificationRequest.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AdsAddDeviceNotificationRequest.go
@@ -129,22 +129,19 @@ func NewAdsAddDeviceNotificationRequest(indexGroup uint32, indexOffset uint32, l
}
func CastAdsAddDeviceNotificationRequest(structType interface{}) *AdsAddDeviceNotificationRequest {
- castFunc := func(typ interface{}) *AdsAddDeviceNotificationRequest {
- if casted, ok := typ.(AdsAddDeviceNotificationRequest); ok {
- return &casted
- }
- if casted, ok := typ.(*AdsAddDeviceNotificationRequest); ok {
- return casted
- }
- if casted, ok := typ.(AdsData); ok {
- return CastAdsAddDeviceNotificationRequest(casted.Child)
- }
- if casted, ok := typ.(*AdsData); ok {
- return CastAdsAddDeviceNotificationRequest(casted.Child)
- }
- return nil
+ if casted, ok := structType.(AdsAddDeviceNotificationRequest); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*AdsAddDeviceNotificationRequest); ok {
+ return casted
+ }
+ if casted, ok := structType.(AdsData); ok {
+ return CastAdsAddDeviceNotificationRequest(casted.Child)
+ }
+ if casted, ok := structType.(*AdsData); ok {
+ return CastAdsAddDeviceNotificationRequest(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *AdsAddDeviceNotificationRequest) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AdsAddDeviceNotificationResponse.go b/plc4go/internal/plc4go/ads/readwrite/model/AdsAddDeviceNotificationResponse.go
index a60991b..c921468 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AdsAddDeviceNotificationResponse.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AdsAddDeviceNotificationResponse.go
@@ -96,22 +96,19 @@ func NewAdsAddDeviceNotificationResponse(result ReturnCode, notificationHandle u
}
func CastAdsAddDeviceNotificationResponse(structType interface{}) *AdsAddDeviceNotificationResponse {
- castFunc := func(typ interface{}) *AdsAddDeviceNotificationResponse {
- if casted, ok := typ.(AdsAddDeviceNotificationResponse); ok {
- return &casted
- }
- if casted, ok := typ.(*AdsAddDeviceNotificationResponse); ok {
- return casted
- }
- if casted, ok := typ.(AdsData); ok {
- return CastAdsAddDeviceNotificationResponse(casted.Child)
- }
- if casted, ok := typ.(*AdsData); ok {
- return CastAdsAddDeviceNotificationResponse(casted.Child)
- }
- return nil
+ if casted, ok := structType.(AdsAddDeviceNotificationResponse); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*AdsAddDeviceNotificationResponse); ok {
+ return casted
+ }
+ if casted, ok := structType.(AdsData); ok {
+ return CastAdsAddDeviceNotificationResponse(casted.Child)
+ }
+ if casted, ok := structType.(*AdsData); ok {
+ return CastAdsAddDeviceNotificationResponse(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *AdsAddDeviceNotificationResponse) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AdsData.go b/plc4go/internal/plc4go/ads/readwrite/model/AdsData.go
index 79f81a6..ff10853 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AdsData.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AdsData.go
@@ -71,16 +71,13 @@ func NewAdsData() *AdsData {
}
func CastAdsData(structType interface{}) *AdsData {
- castFunc := func(typ interface{}) *AdsData {
- if casted, ok := typ.(AdsData); ok {
- return &casted
- }
- if casted, ok := typ.(*AdsData); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(AdsData); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*AdsData); ok {
+ return casted
+ }
+ return nil
}
func (m *AdsData) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AdsDeleteDeviceNotificationRequest.go b/plc4go/internal/plc4go/ads/readwrite/model/AdsDeleteDeviceNotificationRequest.go
index 1021dec..59c5ab6 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AdsDeleteDeviceNotificationRequest.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AdsDeleteDeviceNotificationRequest.go
@@ -88,22 +88,19 @@ func NewAdsDeleteDeviceNotificationRequest(notificationHandle uint32) *AdsData {
}
func CastAdsDeleteDeviceNotificationRequest(structType interface{}) *AdsDeleteDeviceNotificationRequest {
- castFunc := func(typ interface{}) *AdsDeleteDeviceNotificationRequest {
- if casted, ok := typ.(AdsDeleteDeviceNotificationRequest); ok {
- return &casted
- }
- if casted, ok := typ.(*AdsDeleteDeviceNotificationRequest); ok {
- return casted
- }
- if casted, ok := typ.(AdsData); ok {
- return CastAdsDeleteDeviceNotificationRequest(casted.Child)
- }
- if casted, ok := typ.(*AdsData); ok {
- return CastAdsDeleteDeviceNotificationRequest(casted.Child)
- }
- return nil
+ if casted, ok := structType.(AdsDeleteDeviceNotificationRequest); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*AdsDeleteDeviceNotificationRequest); ok {
+ return casted
+ }
+ if casted, ok := structType.(AdsData); ok {
+ return CastAdsDeleteDeviceNotificationRequest(casted.Child)
+ }
+ if casted, ok := structType.(*AdsData); ok {
+ return CastAdsDeleteDeviceNotificationRequest(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *AdsDeleteDeviceNotificationRequest) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AdsDeleteDeviceNotificationResponse.go b/plc4go/internal/plc4go/ads/readwrite/model/AdsDeleteDeviceNotificationResponse.go
index 0c1b529..a11c004 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AdsDeleteDeviceNotificationResponse.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AdsDeleteDeviceNotificationResponse.go
@@ -88,22 +88,19 @@ func NewAdsDeleteDeviceNotificationResponse(result ReturnCode) *AdsData {
}
func CastAdsDeleteDeviceNotificationResponse(structType interface{}) *AdsDeleteDeviceNotificationResponse {
- castFunc := func(typ interface{}) *AdsDeleteDeviceNotificationResponse {
- if casted, ok := typ.(AdsDeleteDeviceNotificationResponse); ok {
- return &casted
- }
- if casted, ok := typ.(*AdsDeleteDeviceNotificationResponse); ok {
- return casted
- }
- if casted, ok := typ.(AdsData); ok {
- return CastAdsDeleteDeviceNotificationResponse(casted.Child)
- }
- if casted, ok := typ.(*AdsData); ok {
- return CastAdsDeleteDeviceNotificationResponse(casted.Child)
- }
- return nil
+ if casted, ok := structType.(AdsDeleteDeviceNotificationResponse); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*AdsDeleteDeviceNotificationResponse); ok {
+ return casted
+ }
+ if casted, ok := structType.(AdsData); ok {
+ return CastAdsDeleteDeviceNotificationResponse(casted.Child)
+ }
+ if casted, ok := structType.(*AdsData); ok {
+ return CastAdsDeleteDeviceNotificationResponse(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *AdsDeleteDeviceNotificationResponse) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AdsDeviceNotificationRequest.go b/plc4go/internal/plc4go/ads/readwrite/model/AdsDeviceNotificationRequest.go
index 82508d8..e1a69f3 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AdsDeviceNotificationRequest.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AdsDeviceNotificationRequest.go
@@ -104,22 +104,19 @@ func NewAdsDeviceNotificationRequest(length uint32, stamps uint32, adsStampHeade
}
func CastAdsDeviceNotificationRequest(structType interface{}) *AdsDeviceNotificationRequest {
- castFunc := func(typ interface{}) *AdsDeviceNotificationRequest {
- if casted, ok := typ.(AdsDeviceNotificationRequest); ok {
- return &casted
- }
- if casted, ok := typ.(*AdsDeviceNotificationRequest); ok {
- return casted
- }
- if casted, ok := typ.(AdsData); ok {
- return CastAdsDeviceNotificationRequest(casted.Child)
- }
- if casted, ok := typ.(*AdsData); ok {
- return CastAdsDeviceNotificationRequest(casted.Child)
- }
- return nil
+ if casted, ok := structType.(AdsDeviceNotificationRequest); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*AdsDeviceNotificationRequest); ok {
+ return casted
+ }
+ if casted, ok := structType.(AdsData); ok {
+ return CastAdsDeviceNotificationRequest(casted.Child)
+ }
+ if casted, ok := structType.(*AdsData); ok {
+ return CastAdsDeviceNotificationRequest(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *AdsDeviceNotificationRequest) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AdsDeviceNotificationResponse.go b/plc4go/internal/plc4go/ads/readwrite/model/AdsDeviceNotificationResponse.go
index e667d23..8f10277 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AdsDeviceNotificationResponse.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AdsDeviceNotificationResponse.go
@@ -80,22 +80,19 @@ func NewAdsDeviceNotificationResponse() *AdsData {
}
func CastAdsDeviceNotificationResponse(structType interface{}) *AdsDeviceNotificationResponse {
- castFunc := func(typ interface{}) *AdsDeviceNotificationResponse {
- if casted, ok := typ.(AdsDeviceNotificationResponse); ok {
- return &casted
- }
- if casted, ok := typ.(*AdsDeviceNotificationResponse); ok {
- return casted
- }
- if casted, ok := typ.(AdsData); ok {
- return CastAdsDeviceNotificationResponse(casted.Child)
- }
- if casted, ok := typ.(*AdsData); ok {
- return CastAdsDeviceNotificationResponse(casted.Child)
- }
- return nil
+ if casted, ok := structType.(AdsDeviceNotificationResponse); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*AdsDeviceNotificationResponse); ok {
+ return casted
+ }
+ if casted, ok := structType.(AdsData); ok {
+ return CastAdsDeviceNotificationResponse(casted.Child)
+ }
+ if casted, ok := structType.(*AdsData); ok {
+ return CastAdsDeviceNotificationResponse(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *AdsDeviceNotificationResponse) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AdsInvalidRequest.go b/plc4go/internal/plc4go/ads/readwrite/model/AdsInvalidRequest.go
index f332169..6472422 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AdsInvalidRequest.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AdsInvalidRequest.go
@@ -80,22 +80,19 @@ func NewAdsInvalidRequest() *AdsData {
}
func CastAdsInvalidRequest(structType interface{}) *AdsInvalidRequest {
- castFunc := func(typ interface{}) *AdsInvalidRequest {
- if casted, ok := typ.(AdsInvalidRequest); ok {
- return &casted
- }
- if casted, ok := typ.(*AdsInvalidRequest); ok {
- return casted
- }
- if casted, ok := typ.(AdsData); ok {
- return CastAdsInvalidRequest(casted.Child)
- }
- if casted, ok := typ.(*AdsData); ok {
- return CastAdsInvalidRequest(casted.Child)
- }
- return nil
+ if casted, ok := structType.(AdsInvalidRequest); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*AdsInvalidRequest); ok {
+ return casted
+ }
+ if casted, ok := structType.(AdsData); ok {
+ return CastAdsInvalidRequest(casted.Child)
+ }
+ if casted, ok := structType.(*AdsData); ok {
+ return CastAdsInvalidRequest(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *AdsInvalidRequest) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AdsInvalidResponse.go b/plc4go/internal/plc4go/ads/readwrite/model/AdsInvalidResponse.go
index 65ab232..ac7d08e 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AdsInvalidResponse.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AdsInvalidResponse.go
@@ -80,22 +80,19 @@ func NewAdsInvalidResponse() *AdsData {
}
func CastAdsInvalidResponse(structType interface{}) *AdsInvalidResponse {
- castFunc := func(typ interface{}) *AdsInvalidResponse {
- if casted, ok := typ.(AdsInvalidResponse); ok {
- return &casted
- }
- if casted, ok := typ.(*AdsInvalidResponse); ok {
- return casted
- }
- if casted, ok := typ.(AdsData); ok {
- return CastAdsInvalidResponse(casted.Child)
- }
- if casted, ok := typ.(*AdsData); ok {
- return CastAdsInvalidResponse(casted.Child)
- }
- return nil
+ if casted, ok := structType.(AdsInvalidResponse); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*AdsInvalidResponse); ok {
+ return casted
+ }
+ if casted, ok := structType.(AdsData); ok {
+ return CastAdsInvalidResponse(casted.Child)
+ }
+ if casted, ok := structType.(*AdsData); ok {
+ return CastAdsInvalidResponse(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *AdsInvalidResponse) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AdsMultiRequestItem.go b/plc4go/internal/plc4go/ads/readwrite/model/AdsMultiRequestItem.go
index 20f8f2c..1d858fd 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AdsMultiRequestItem.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AdsMultiRequestItem.go
@@ -69,16 +69,13 @@ func NewAdsMultiRequestItem() *AdsMultiRequestItem {
}
func CastAdsMultiRequestItem(structType interface{}) *AdsMultiRequestItem {
- castFunc := func(typ interface{}) *AdsMultiRequestItem {
- if casted, ok := typ.(AdsMultiRequestItem); ok {
- return &casted
- }
- if casted, ok := typ.(*AdsMultiRequestItem); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(AdsMultiRequestItem); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*AdsMultiRequestItem); ok {
+ return casted
+ }
+ return nil
}
func (m *AdsMultiRequestItem) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AdsMultiRequestItemRead.go b/plc4go/internal/plc4go/ads/readwrite/model/AdsMultiRequestItemRead.go
index 96ec604..e9bf914 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AdsMultiRequestItemRead.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AdsMultiRequestItemRead.go
@@ -96,22 +96,19 @@ func NewAdsMultiRequestItemRead(itemIndexGroup uint32, itemIndexOffset uint32, i
}
func CastAdsMultiRequestItemRead(structType interface{}) *AdsMultiRequestItemRead {
- castFunc := func(typ interface{}) *AdsMultiRequestItemRead {
- if casted, ok := typ.(AdsMultiRequestItemRead); ok {
- return &casted
- }
- if casted, ok := typ.(*AdsMultiRequestItemRead); ok {
- return casted
- }
- if casted, ok := typ.(AdsMultiRequestItem); ok {
- return CastAdsMultiRequestItemRead(casted.Child)
- }
- if casted, ok := typ.(*AdsMultiRequestItem); ok {
- return CastAdsMultiRequestItemRead(casted.Child)
- }
- return nil
+ if casted, ok := structType.(AdsMultiRequestItemRead); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*AdsMultiRequestItemRead); ok {
+ return casted
+ }
+ if casted, ok := structType.(AdsMultiRequestItem); ok {
+ return CastAdsMultiRequestItemRead(casted.Child)
+ }
+ if casted, ok := structType.(*AdsMultiRequestItem); ok {
+ return CastAdsMultiRequestItemRead(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *AdsMultiRequestItemRead) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AdsMultiRequestItemReadWrite.go b/plc4go/internal/plc4go/ads/readwrite/model/AdsMultiRequestItemReadWrite.go
index 866d40d..a08de19 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AdsMultiRequestItemReadWrite.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AdsMultiRequestItemReadWrite.go
@@ -104,22 +104,19 @@ func NewAdsMultiRequestItemReadWrite(itemIndexGroup uint32, itemIndexOffset uint
}
func CastAdsMultiRequestItemReadWrite(structType interface{}) *AdsMultiRequestItemReadWrite {
- castFunc := func(typ interface{}) *AdsMultiRequestItemReadWrite {
- if casted, ok := typ.(AdsMultiRequestItemReadWrite); ok {
- return &casted
- }
- if casted, ok := typ.(*AdsMultiRequestItemReadWrite); ok {
- return casted
- }
- if casted, ok := typ.(AdsMultiRequestItem); ok {
- return CastAdsMultiRequestItemReadWrite(casted.Child)
- }
- if casted, ok := typ.(*AdsMultiRequestItem); ok {
- return CastAdsMultiRequestItemReadWrite(casted.Child)
- }
- return nil
+ if casted, ok := structType.(AdsMultiRequestItemReadWrite); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*AdsMultiRequestItemReadWrite); ok {
+ return casted
+ }
+ if casted, ok := structType.(AdsMultiRequestItem); ok {
+ return CastAdsMultiRequestItemReadWrite(casted.Child)
+ }
+ if casted, ok := structType.(*AdsMultiRequestItem); ok {
+ return CastAdsMultiRequestItemReadWrite(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *AdsMultiRequestItemReadWrite) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AdsMultiRequestItemWrite.go b/plc4go/internal/plc4go/ads/readwrite/model/AdsMultiRequestItemWrite.go
index ec6ce0a..0607379 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AdsMultiRequestItemWrite.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AdsMultiRequestItemWrite.go
@@ -96,22 +96,19 @@ func NewAdsMultiRequestItemWrite(itemIndexGroup uint32, itemIndexOffset uint32,
}
func CastAdsMultiRequestItemWrite(structType interface{}) *AdsMultiRequestItemWrite {
- castFunc := func(typ interface{}) *AdsMultiRequestItemWrite {
- if casted, ok := typ.(AdsMultiRequestItemWrite); ok {
- return &casted
- }
- if casted, ok := typ.(*AdsMultiRequestItemWrite); ok {
- return casted
- }
- if casted, ok := typ.(AdsMultiRequestItem); ok {
- return CastAdsMultiRequestItemWrite(casted.Child)
- }
- if casted, ok := typ.(*AdsMultiRequestItem); ok {
- return CastAdsMultiRequestItemWrite(casted.Child)
- }
- return nil
+ if casted, ok := structType.(AdsMultiRequestItemWrite); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*AdsMultiRequestItemWrite); ok {
+ return casted
+ }
+ if casted, ok := structType.(AdsMultiRequestItem); ok {
+ return CastAdsMultiRequestItemWrite(casted.Child)
+ }
+ if casted, ok := structType.(*AdsMultiRequestItem); ok {
+ return CastAdsMultiRequestItemWrite(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *AdsMultiRequestItemWrite) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AdsNotificationSample.go b/plc4go/internal/plc4go/ads/readwrite/model/AdsNotificationSample.go
index d807abc..c108689 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AdsNotificationSample.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AdsNotificationSample.go
@@ -74,16 +74,13 @@ func NewAdsNotificationSample(notificationHandle uint32, sampleSize uint32, data
}
func CastAdsNotificationSample(structType interface{}) *AdsNotificationSample {
- castFunc := func(typ interface{}) *AdsNotificationSample {
- if casted, ok := typ.(AdsNotificationSample); ok {
- return &casted
- }
- if casted, ok := typ.(*AdsNotificationSample); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(AdsNotificationSample); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*AdsNotificationSample); ok {
+ return casted
+ }
+ return nil
}
func (m *AdsNotificationSample) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AdsReadDeviceInfoRequest.go b/plc4go/internal/plc4go/ads/readwrite/model/AdsReadDeviceInfoRequest.go
index f198de7..7e3f5a3 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AdsReadDeviceInfoRequest.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AdsReadDeviceInfoRequest.go
@@ -80,22 +80,19 @@ func NewAdsReadDeviceInfoRequest() *AdsData {
}
func CastAdsReadDeviceInfoRequest(structType interface{}) *AdsReadDeviceInfoRequest {
- castFunc := func(typ interface{}) *AdsReadDeviceInfoRequest {
- if casted, ok := typ.(AdsReadDeviceInfoRequest); ok {
- return &casted
- }
- if casted, ok := typ.(*AdsReadDeviceInfoRequest); ok {
- return casted
- }
- if casted, ok := typ.(AdsData); ok {
- return CastAdsReadDeviceInfoRequest(casted.Child)
- }
- if casted, ok := typ.(*AdsData); ok {
- return CastAdsReadDeviceInfoRequest(casted.Child)
- }
- return nil
+ if casted, ok := structType.(AdsReadDeviceInfoRequest); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*AdsReadDeviceInfoRequest); ok {
+ return casted
+ }
+ if casted, ok := structType.(AdsData); ok {
+ return CastAdsReadDeviceInfoRequest(casted.Child)
+ }
+ if casted, ok := structType.(*AdsData); ok {
+ return CastAdsReadDeviceInfoRequest(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *AdsReadDeviceInfoRequest) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AdsReadDeviceInfoResponse.go b/plc4go/internal/plc4go/ads/readwrite/model/AdsReadDeviceInfoResponse.go
index 7b00e83..d6f404f 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AdsReadDeviceInfoResponse.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AdsReadDeviceInfoResponse.go
@@ -120,22 +120,19 @@ func NewAdsReadDeviceInfoResponse(result ReturnCode, majorVersion uint8, minorVe
}
func CastAdsReadDeviceInfoResponse(structType interface{}) *AdsReadDeviceInfoResponse {
- castFunc := func(typ interface{}) *AdsReadDeviceInfoResponse {
- if casted, ok := typ.(AdsReadDeviceInfoResponse); ok {
- return &casted
- }
- if casted, ok := typ.(*AdsReadDeviceInfoResponse); ok {
- return casted
- }
- if casted, ok := typ.(AdsData); ok {
- return CastAdsReadDeviceInfoResponse(casted.Child)
- }
- if casted, ok := typ.(*AdsData); ok {
- return CastAdsReadDeviceInfoResponse(casted.Child)
- }
- return nil
+ if casted, ok := structType.(AdsReadDeviceInfoResponse); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*AdsReadDeviceInfoResponse); ok {
+ return casted
+ }
+ if casted, ok := structType.(AdsData); ok {
+ return CastAdsReadDeviceInfoResponse(casted.Child)
+ }
+ if casted, ok := structType.(*AdsData); ok {
+ return CastAdsReadDeviceInfoResponse(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *AdsReadDeviceInfoResponse) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AdsReadRequest.go b/plc4go/internal/plc4go/ads/readwrite/model/AdsReadRequest.go
index a6e62fe..be67744 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AdsReadRequest.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AdsReadRequest.go
@@ -104,22 +104,19 @@ func NewAdsReadRequest(indexGroup uint32, indexOffset uint32, length uint32) *Ad
}
func CastAdsReadRequest(structType interface{}) *AdsReadRequest {
- castFunc := func(typ interface{}) *AdsReadRequest {
- if casted, ok := typ.(AdsReadRequest); ok {
- return &casted
- }
- if casted, ok := typ.(*AdsReadRequest); ok {
- return casted
- }
- if casted, ok := typ.(AdsData); ok {
- return CastAdsReadRequest(casted.Child)
- }
- if casted, ok := typ.(*AdsData); ok {
- return CastAdsReadRequest(casted.Child)
- }
- return nil
+ if casted, ok := structType.(AdsReadRequest); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*AdsReadRequest); ok {
+ return casted
+ }
+ if casted, ok := structType.(AdsData); ok {
+ return CastAdsReadRequest(casted.Child)
+ }
+ if casted, ok := structType.(*AdsData); ok {
+ return CastAdsReadRequest(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *AdsReadRequest) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AdsReadResponse.go b/plc4go/internal/plc4go/ads/readwrite/model/AdsReadResponse.go
index 91d16aa..5734c94 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AdsReadResponse.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AdsReadResponse.go
@@ -96,22 +96,19 @@ func NewAdsReadResponse(result ReturnCode, data []byte) *AdsData {
}
func CastAdsReadResponse(structType interface{}) *AdsReadResponse {
- castFunc := func(typ interface{}) *AdsReadResponse {
- if casted, ok := typ.(AdsReadResponse); ok {
- return &casted
- }
- if casted, ok := typ.(*AdsReadResponse); ok {
- return casted
- }
- if casted, ok := typ.(AdsData); ok {
- return CastAdsReadResponse(casted.Child)
- }
- if casted, ok := typ.(*AdsData); ok {
- return CastAdsReadResponse(casted.Child)
- }
- return nil
+ if casted, ok := structType.(AdsReadResponse); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*AdsReadResponse); ok {
+ return casted
+ }
+ if casted, ok := structType.(AdsData); ok {
+ return CastAdsReadResponse(casted.Child)
+ }
+ if casted, ok := structType.(*AdsData); ok {
+ return CastAdsReadResponse(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *AdsReadResponse) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AdsReadStateRequest.go b/plc4go/internal/plc4go/ads/readwrite/model/AdsReadStateRequest.go
index 1e45481..5000a40 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AdsReadStateRequest.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AdsReadStateRequest.go
@@ -80,22 +80,19 @@ func NewAdsReadStateRequest() *AdsData {
}
func CastAdsReadStateRequest(structType interface{}) *AdsReadStateRequest {
- castFunc := func(typ interface{}) *AdsReadStateRequest {
- if casted, ok := typ.(AdsReadStateRequest); ok {
- return &casted
- }
- if casted, ok := typ.(*AdsReadStateRequest); ok {
- return casted
- }
- if casted, ok := typ.(AdsData); ok {
- return CastAdsReadStateRequest(casted.Child)
- }
- if casted, ok := typ.(*AdsData); ok {
- return CastAdsReadStateRequest(casted.Child)
- }
- return nil
+ if casted, ok := structType.(AdsReadStateRequest); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*AdsReadStateRequest); ok {
+ return casted
+ }
+ if casted, ok := structType.(AdsData); ok {
+ return CastAdsReadStateRequest(casted.Child)
+ }
+ if casted, ok := structType.(*AdsData); ok {
+ return CastAdsReadStateRequest(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *AdsReadStateRequest) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AdsReadStateResponse.go b/plc4go/internal/plc4go/ads/readwrite/model/AdsReadStateResponse.go
index d7d9939..8518d6e 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AdsReadStateResponse.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AdsReadStateResponse.go
@@ -104,22 +104,19 @@ func NewAdsReadStateResponse(result ReturnCode, adsState uint16, deviceState uin
}
func CastAdsReadStateResponse(structType interface{}) *AdsReadStateResponse {
- castFunc := func(typ interface{}) *AdsReadStateResponse {
- if casted, ok := typ.(AdsReadStateResponse); ok {
- return &casted
- }
- if casted, ok := typ.(*AdsReadStateResponse); ok {
- return casted
- }
- if casted, ok := typ.(AdsData); ok {
- return CastAdsReadStateResponse(casted.Child)
- }
- if casted, ok := typ.(*AdsData); ok {
- return CastAdsReadStateResponse(casted.Child)
- }
- return nil
+ if casted, ok := structType.(AdsReadStateResponse); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*AdsReadStateResponse); ok {
+ return casted
+ }
+ if casted, ok := structType.(AdsData); ok {
+ return CastAdsReadStateResponse(casted.Child)
+ }
+ if casted, ok := structType.(*AdsData); ok {
+ return CastAdsReadStateResponse(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *AdsReadStateResponse) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AdsReadWriteRequest.go b/plc4go/internal/plc4go/ads/readwrite/model/AdsReadWriteRequest.go
index a55306c..ab03542 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AdsReadWriteRequest.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AdsReadWriteRequest.go
@@ -120,22 +120,19 @@ func NewAdsReadWriteRequest(indexGroup uint32, indexOffset uint32, readLength ui
}
func CastAdsReadWriteRequest(structType interface{}) *AdsReadWriteRequest {
- castFunc := func(typ interface{}) *AdsReadWriteRequest {
- if casted, ok := typ.(AdsReadWriteRequest); ok {
- return &casted
- }
- if casted, ok := typ.(*AdsReadWriteRequest); ok {
- return casted
- }
- if casted, ok := typ.(AdsData); ok {
- return CastAdsReadWriteRequest(casted.Child)
- }
- if casted, ok := typ.(*AdsData); ok {
- return CastAdsReadWriteRequest(casted.Child)
- }
- return nil
+ if casted, ok := structType.(AdsReadWriteRequest); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*AdsReadWriteRequest); ok {
+ return casted
+ }
+ if casted, ok := structType.(AdsData); ok {
+ return CastAdsReadWriteRequest(casted.Child)
+ }
+ if casted, ok := structType.(*AdsData); ok {
+ return CastAdsReadWriteRequest(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *AdsReadWriteRequest) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AdsReadWriteResponse.go b/plc4go/internal/plc4go/ads/readwrite/model/AdsReadWriteResponse.go
index 00fd996..221c39e 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AdsReadWriteResponse.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AdsReadWriteResponse.go
@@ -96,22 +96,19 @@ func NewAdsReadWriteResponse(result ReturnCode, data []byte) *AdsData {
}
func CastAdsReadWriteResponse(structType interface{}) *AdsReadWriteResponse {
- castFunc := func(typ interface{}) *AdsReadWriteResponse {
- if casted, ok := typ.(AdsReadWriteResponse); ok {
- return &casted
- }
- if casted, ok := typ.(*AdsReadWriteResponse); ok {
- return casted
- }
- if casted, ok := typ.(AdsData); ok {
- return CastAdsReadWriteResponse(casted.Child)
- }
- if casted, ok := typ.(*AdsData); ok {
- return CastAdsReadWriteResponse(casted.Child)
- }
- return nil
+ if casted, ok := structType.(AdsReadWriteResponse); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*AdsReadWriteResponse); ok {
+ return casted
+ }
+ if casted, ok := structType.(AdsData); ok {
+ return CastAdsReadWriteResponse(casted.Child)
+ }
+ if casted, ok := structType.(*AdsData); ok {
+ return CastAdsReadWriteResponse(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *AdsReadWriteResponse) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AdsStampHeader.go b/plc4go/internal/plc4go/ads/readwrite/model/AdsStampHeader.go
index 83c9a44..8e6ce2c 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AdsStampHeader.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AdsStampHeader.go
@@ -74,16 +74,13 @@ func NewAdsStampHeader(timestamp uint64, samples uint32, adsNotificationSamples
}
func CastAdsStampHeader(structType interface{}) *AdsStampHeader {
- castFunc := func(typ interface{}) *AdsStampHeader {
- if casted, ok := typ.(AdsStampHeader); ok {
- return &casted
- }
- if casted, ok := typ.(*AdsStampHeader); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(AdsStampHeader); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*AdsStampHeader); ok {
+ return casted
+ }
+ return nil
}
func (m *AdsStampHeader) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AdsWriteControlRequest.go b/plc4go/internal/plc4go/ads/readwrite/model/AdsWriteControlRequest.go
index 63448b5..77a26cd 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AdsWriteControlRequest.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AdsWriteControlRequest.go
@@ -104,22 +104,19 @@ func NewAdsWriteControlRequest(adsState uint16, deviceState uint16, data []byte)
}
func CastAdsWriteControlRequest(structType interface{}) *AdsWriteControlRequest {
- castFunc := func(typ interface{}) *AdsWriteControlRequest {
- if casted, ok := typ.(AdsWriteControlRequest); ok {
- return &casted
- }
- if casted, ok := typ.(*AdsWriteControlRequest); ok {
- return casted
- }
- if casted, ok := typ.(AdsData); ok {
- return CastAdsWriteControlRequest(casted.Child)
- }
- if casted, ok := typ.(*AdsData); ok {
- return CastAdsWriteControlRequest(casted.Child)
- }
- return nil
+ if casted, ok := structType.(AdsWriteControlRequest); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*AdsWriteControlRequest); ok {
+ return casted
+ }
+ if casted, ok := structType.(AdsData); ok {
+ return CastAdsWriteControlRequest(casted.Child)
+ }
+ if casted, ok := structType.(*AdsData); ok {
+ return CastAdsWriteControlRequest(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *AdsWriteControlRequest) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AdsWriteControlResponse.go b/plc4go/internal/plc4go/ads/readwrite/model/AdsWriteControlResponse.go
index b9de2e5..7d0b7af 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AdsWriteControlResponse.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AdsWriteControlResponse.go
@@ -88,22 +88,19 @@ func NewAdsWriteControlResponse(result ReturnCode) *AdsData {
}
func CastAdsWriteControlResponse(structType interface{}) *AdsWriteControlResponse {
- castFunc := func(typ interface{}) *AdsWriteControlResponse {
- if casted, ok := typ.(AdsWriteControlResponse); ok {
- return &casted
- }
- if casted, ok := typ.(*AdsWriteControlResponse); ok {
- return casted
- }
- if casted, ok := typ.(AdsData); ok {
- return CastAdsWriteControlResponse(casted.Child)
- }
- if casted, ok := typ.(*AdsData); ok {
- return CastAdsWriteControlResponse(casted.Child)
- }
- return nil
+ if casted, ok := structType.(AdsWriteControlResponse); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*AdsWriteControlResponse); ok {
+ return casted
+ }
+ if casted, ok := structType.(AdsData); ok {
+ return CastAdsWriteControlResponse(casted.Child)
+ }
+ if casted, ok := structType.(*AdsData); ok {
+ return CastAdsWriteControlResponse(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *AdsWriteControlResponse) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AdsWriteRequest.go b/plc4go/internal/plc4go/ads/readwrite/model/AdsWriteRequest.go
index 9c48e8f..2c4f966 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AdsWriteRequest.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AdsWriteRequest.go
@@ -104,22 +104,19 @@ func NewAdsWriteRequest(indexGroup uint32, indexOffset uint32, data []byte) *Ads
}
func CastAdsWriteRequest(structType interface{}) *AdsWriteRequest {
- castFunc := func(typ interface{}) *AdsWriteRequest {
- if casted, ok := typ.(AdsWriteRequest); ok {
- return &casted
- }
- if casted, ok := typ.(*AdsWriteRequest); ok {
- return casted
- }
- if casted, ok := typ.(AdsData); ok {
- return CastAdsWriteRequest(casted.Child)
- }
- if casted, ok := typ.(*AdsData); ok {
- return CastAdsWriteRequest(casted.Child)
- }
- return nil
+ if casted, ok := structType.(AdsWriteRequest); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*AdsWriteRequest); ok {
+ return casted
+ }
+ if casted, ok := structType.(AdsData); ok {
+ return CastAdsWriteRequest(casted.Child)
+ }
+ if casted, ok := structType.(*AdsData); ok {
+ return CastAdsWriteRequest(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *AdsWriteRequest) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AdsWriteResponse.go b/plc4go/internal/plc4go/ads/readwrite/model/AdsWriteResponse.go
index 7ad5437..8b29536 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AdsWriteResponse.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AdsWriteResponse.go
@@ -88,22 +88,19 @@ func NewAdsWriteResponse(result ReturnCode) *AdsData {
}
func CastAdsWriteResponse(structType interface{}) *AdsWriteResponse {
- castFunc := func(typ interface{}) *AdsWriteResponse {
- if casted, ok := typ.(AdsWriteResponse); ok {
- return &casted
- }
- if casted, ok := typ.(*AdsWriteResponse); ok {
- return casted
- }
- if casted, ok := typ.(AdsData); ok {
- return CastAdsWriteResponse(casted.Child)
- }
- if casted, ok := typ.(*AdsData); ok {
- return CastAdsWriteResponse(casted.Child)
- }
- return nil
+ if casted, ok := structType.(AdsWriteResponse); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*AdsWriteResponse); ok {
+ return casted
+ }
+ if casted, ok := structType.(AdsData); ok {
+ return CastAdsWriteResponse(casted.Child)
+ }
+ if casted, ok := structType.(*AdsData); ok {
+ return CastAdsWriteResponse(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *AdsWriteResponse) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AmsNetId.go b/plc4go/internal/plc4go/ads/readwrite/model/AmsNetId.go
index bb7efcc..5850c0e 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AmsNetId.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AmsNetId.go
@@ -95,16 +95,13 @@ func NewAmsNetId(octet1 uint8, octet2 uint8, octet3 uint8, octet4 uint8, octet5
}
func CastAmsNetId(structType interface{}) *AmsNetId {
- castFunc := func(typ interface{}) *AmsNetId {
- if casted, ok := typ.(AmsNetId); ok {
- return &casted
- }
- if casted, ok := typ.(*AmsNetId); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(AmsNetId); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*AmsNetId); ok {
+ return casted
+ }
+ return nil
}
func (m *AmsNetId) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AmsPacket.go b/plc4go/internal/plc4go/ads/readwrite/model/AmsPacket.go
index 063caf1..96a1d55 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AmsPacket.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AmsPacket.go
@@ -116,16 +116,13 @@ func NewAmsPacket(targetAmsNetId *AmsNetId, targetAmsPort uint16, sourceAmsNetId
}
func CastAmsPacket(structType interface{}) *AmsPacket {
- castFunc := func(typ interface{}) *AmsPacket {
- if casted, ok := typ.(AmsPacket); ok {
- return &casted
- }
- if casted, ok := typ.(*AmsPacket); ok {
- return casted
- }
- return nil
- }
- return castFunc(structType)
+ if casted, ok := structType.(AmsPacket); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*AmsPacket); ok {
+ return casted
+ }
+ return nil
}
func (m *AmsPacket) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AmsSerialAcknowledgeFrame.go b/plc4go/internal/plc4go/ads/readwrite/model/AmsSerialAcknowledgeFrame.go
index 8494340..113b286 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AmsSerialAcknowledgeFrame.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AmsSerialAcknowledgeFrame.go
@@ -95,16 +95,13 @@ func NewAmsSerialAcknowledgeFrame(magicCookie uint16, transmitterAddress int8, r
}
func CastAmsSerialAcknowledgeFrame(structType interface{}) *AmsSerialAcknowledgeFrame {
- castFunc := func(typ interface{}) *AmsSerialAcknowledgeFrame {
- if casted, ok := typ.(AmsSerialAcknowledgeFrame); ok {
- return &casted
- }
- if casted, ok := typ.(*AmsSerialAcknowledgeFrame); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(AmsSerialAcknowledgeFrame); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*AmsSerialAcknowledgeFrame); ok {
+ return casted
+ }
+ return nil
}
func (m *AmsSerialAcknowledgeFrame) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AmsSerialFrame.go b/plc4go/internal/plc4go/ads/readwrite/model/AmsSerialFrame.go
index e063a23..5133f50 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AmsSerialFrame.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AmsSerialFrame.go
@@ -102,16 +102,13 @@ func NewAmsSerialFrame(magicCookie uint16, transmitterAddress int8, receiverAddr
}
func CastAmsSerialFrame(structType interface{}) *AmsSerialFrame {
- castFunc := func(typ interface{}) *AmsSerialFrame {
- if casted, ok := typ.(AmsSerialFrame); ok {
- return &casted
- }
- if casted, ok := typ.(*AmsSerialFrame); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(AmsSerialFrame); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*AmsSerialFrame); ok {
+ return casted
+ }
+ return nil
}
func (m *AmsSerialFrame) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AmsSerialResetFrame.go b/plc4go/internal/plc4go/ads/readwrite/model/AmsSerialResetFrame.go
index cdc03e1..ed3a8b6 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AmsSerialResetFrame.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AmsSerialResetFrame.go
@@ -95,16 +95,13 @@ func NewAmsSerialResetFrame(magicCookie uint16, transmitterAddress int8, receive
}
func CastAmsSerialResetFrame(structType interface{}) *AmsSerialResetFrame {
- castFunc := func(typ interface{}) *AmsSerialResetFrame {
- if casted, ok := typ.(AmsSerialResetFrame); ok {
- return &casted
- }
- if casted, ok := typ.(*AmsSerialResetFrame); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(AmsSerialResetFrame); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*AmsSerialResetFrame); ok {
+ return casted
+ }
+ return nil
}
func (m *AmsSerialResetFrame) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/AmsTCPPacket.go b/plc4go/internal/plc4go/ads/readwrite/model/AmsTCPPacket.go
index e1e828b..d99e0e6 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/AmsTCPPacket.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/AmsTCPPacket.go
@@ -61,16 +61,13 @@ func NewAmsTCPPacket(userdata *AmsPacket) *AmsTCPPacket {
}
func CastAmsTCPPacket(structType interface{}) *AmsTCPPacket {
- castFunc := func(typ interface{}) *AmsTCPPacket {
- if casted, ok := typ.(AmsTCPPacket); ok {
- return &casted
- }
- if casted, ok := typ.(*AmsTCPPacket); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(AmsTCPPacket); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*AmsTCPPacket); ok {
+ return casted
+ }
+ return nil
}
func (m *AmsTCPPacket) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/ads/readwrite/model/State.go b/plc4go/internal/plc4go/ads/readwrite/model/State.go
index 551c26a..13a15d4 100644
--- a/plc4go/internal/plc4go/ads/readwrite/model/State.go
+++ b/plc4go/internal/plc4go/ads/readwrite/model/State.go
@@ -117,16 +117,13 @@ func NewState(initCommand bool, updCommand bool, timestampAdded bool, highPriori
}
func CastState(structType interface{}) *State {
- castFunc := func(typ interface{}) *State {
- if casted, ok := typ.(State); ok {
- return &casted
- }
- if casted, ok := typ.(*State); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(State); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*State); ok {
+ return casted
+ }
+ return nil
}
func (m *State) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/APDU.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/APDU.go
index 918c2d5..0b819a2 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/APDU.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/APDU.go
@@ -72,16 +72,13 @@ func NewAPDU(apduLength uint16) *APDU {
}
func CastAPDU(structType interface{}) *APDU {
- castFunc := func(typ interface{}) *APDU {
- if casted, ok := typ.(APDU); ok {
- return &casted
- }
- if casted, ok := typ.(*APDU); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(APDU); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*APDU); ok {
+ return casted
+ }
+ return nil
}
func (m *APDU) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUAbort.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUAbort.go
index 1976545..0d945d7 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUAbort.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUAbort.go
@@ -100,22 +100,19 @@ func NewAPDUAbort(server bool, originalInvokeId uint8, abortReason uint8, apduLe
}
func CastAPDUAbort(structType interface{}) *APDUAbort {
- castFunc := func(typ interface{}) *APDUAbort {
- if casted, ok := typ.(APDUAbort); ok {
- return &casted
- }
- if casted, ok := typ.(*APDUAbort); ok {
- return casted
- }
- if casted, ok := typ.(APDU); ok {
- return CastAPDUAbort(casted.Child)
- }
- if casted, ok := typ.(*APDU); ok {
- return CastAPDUAbort(casted.Child)
- }
- return nil
+ if casted, ok := structType.(APDUAbort); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*APDUAbort); ok {
+ return casted
+ }
+ if casted, ok := structType.(APDU); ok {
+ return CastAPDUAbort(casted.Child)
+ }
+ if casted, ok := structType.(*APDU); ok {
+ return CastAPDUAbort(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *APDUAbort) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUComplexAck.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUComplexAck.go
index fc478b9..b391e81 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUComplexAck.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUComplexAck.go
@@ -141,22 +141,19 @@ func NewAPDUComplexAck(segmentedMessage bool, moreFollows bool, originalInvokeId
}
func CastAPDUComplexAck(structType interface{}) *APDUComplexAck {
- castFunc := func(typ interface{}) *APDUComplexAck {
- if casted, ok := typ.(APDUComplexAck); ok {
- return &casted
- }
- if casted, ok := typ.(*APDUComplexAck); ok {
- return casted
- }
- if casted, ok := typ.(APDU); ok {
- return CastAPDUComplexAck(casted.Child)
- }
- if casted, ok := typ.(*APDU); ok {
- return CastAPDUComplexAck(casted.Child)
- }
- return nil
+ if casted, ok := structType.(APDUComplexAck); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*APDUComplexAck); ok {
+ return casted
+ }
+ if casted, ok := structType.(APDU); ok {
+ return CastAPDUComplexAck(casted.Child)
+ }
+ if casted, ok := structType.(*APDU); ok {
+ return CastAPDUComplexAck(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *APDUComplexAck) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUConfirmedRequest.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUConfirmedRequest.go
index bb4d91b..ae6a0ca 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUConfirmedRequest.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUConfirmedRequest.go
@@ -148,22 +148,19 @@ func NewAPDUConfirmedRequest(segmentedMessage bool, moreFollows bool, segmentedR
}
func CastAPDUConfirmedRequest(structType interface{}) *APDUConfirmedRequest {
- castFunc := func(typ interface{}) *APDUConfirmedRequest {
- if casted, ok := typ.(APDUConfirmedRequest); ok {
- return &casted
- }
- if casted, ok := typ.(*APDUConfirmedRequest); ok {
- return casted
- }
- if casted, ok := typ.(APDU); ok {
- return CastAPDUConfirmedRequest(casted.Child)
- }
- if casted, ok := typ.(*APDU); ok {
- return CastAPDUConfirmedRequest(casted.Child)
- }
- return nil
+ if casted, ok := structType.(APDUConfirmedRequest); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*APDUConfirmedRequest); ok {
+ return casted
+ }
+ if casted, ok := structType.(APDU); ok {
+ return CastAPDUConfirmedRequest(casted.Child)
+ }
+ if casted, ok := structType.(*APDU); ok {
+ return CastAPDUConfirmedRequest(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *APDUConfirmedRequest) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUError.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUError.go
index 816f28b..6ba3046 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUError.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUError.go
@@ -92,22 +92,19 @@ func NewAPDUError(originalInvokeId uint8, error *BACnetError, apduLength uint16)
}
func CastAPDUError(structType interface{}) *APDUError {
- castFunc := func(typ interface{}) *APDUError {
- if casted, ok := typ.(APDUError); ok {
- return &casted
- }
- if casted, ok := typ.(*APDUError); ok {
- return casted
- }
- if casted, ok := typ.(APDU); ok {
- return CastAPDUError(casted.Child)
- }
- if casted, ok := typ.(*APDU); ok {
- return CastAPDUError(casted.Child)
- }
- return nil
+ if casted, ok := structType.(APDUError); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*APDUError); ok {
+ return casted
+ }
+ if casted, ok := structType.(APDU); ok {
+ return CastAPDUError(casted.Child)
+ }
+ if casted, ok := structType.(*APDU); ok {
+ return CastAPDUError(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *APDUError) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUReject.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUReject.go
index 4aeea82..2780a7d 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUReject.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUReject.go
@@ -92,22 +92,19 @@ func NewAPDUReject(originalInvokeId uint8, rejectReason uint8, apduLength uint16
}
func CastAPDUReject(structType interface{}) *APDUReject {
- castFunc := func(typ interface{}) *APDUReject {
- if casted, ok := typ.(APDUReject); ok {
- return &casted
- }
- if casted, ok := typ.(*APDUReject); ok {
- return casted
- }
- if casted, ok := typ.(APDU); ok {
- return CastAPDUReject(casted.Child)
- }
- if casted, ok := typ.(*APDU); ok {
- return CastAPDUReject(casted.Child)
- }
- return nil
+ if casted, ok := structType.(APDUReject); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*APDUReject); ok {
+ return casted
+ }
+ if casted, ok := structType.(APDU); ok {
+ return CastAPDUReject(casted.Child)
+ }
+ if casted, ok := structType.(*APDU); ok {
+ return CastAPDUReject(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *APDUReject) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUSegmentAck.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUSegmentAck.go
index 9fe5e2e..385a19d 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUSegmentAck.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUSegmentAck.go
@@ -116,22 +116,19 @@ func NewAPDUSegmentAck(negativeAck bool, server bool, originalInvokeId uint8, se
}
func CastAPDUSegmentAck(structType interface{}) *APDUSegmentAck {
- castFunc := func(typ interface{}) *APDUSegmentAck {
- if casted, ok := typ.(APDUSegmentAck); ok {
- return &casted
- }
- if casted, ok := typ.(*APDUSegmentAck); ok {
- return casted
- }
- if casted, ok := typ.(APDU); ok {
- return CastAPDUSegmentAck(casted.Child)
- }
- if casted, ok := typ.(*APDU); ok {
- return CastAPDUSegmentAck(casted.Child)
- }
- return nil
+ if casted, ok := structType.(APDUSegmentAck); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*APDUSegmentAck); ok {
+ return casted
+ }
+ if casted, ok := structType.(APDU); ok {
+ return CastAPDUSegmentAck(casted.Child)
+ }
+ if casted, ok := structType.(*APDU); ok {
+ return CastAPDUSegmentAck(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *APDUSegmentAck) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUSimpleAck.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUSimpleAck.go
index df096ca..f4c4cf1 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUSimpleAck.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUSimpleAck.go
@@ -92,22 +92,19 @@ func NewAPDUSimpleAck(originalInvokeId uint8, serviceChoice uint8, apduLength ui
}
func CastAPDUSimpleAck(structType interface{}) *APDUSimpleAck {
- castFunc := func(typ interface{}) *APDUSimpleAck {
- if casted, ok := typ.(APDUSimpleAck); ok {
- return &casted
- }
- if casted, ok := typ.(*APDUSimpleAck); ok {
- return casted
- }
- if casted, ok := typ.(APDU); ok {
- return CastAPDUSimpleAck(casted.Child)
- }
- if casted, ok := typ.(*APDU); ok {
- return CastAPDUSimpleAck(casted.Child)
- }
- return nil
+ if casted, ok := structType.(APDUSimpleAck); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*APDUSimpleAck); ok {
+ return casted
+ }
+ if casted, ok := structType.(APDU); ok {
+ return CastAPDUSimpleAck(casted.Child)
+ }
+ if casted, ok := structType.(*APDU); ok {
+ return CastAPDUSimpleAck(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *APDUSimpleAck) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUUnconfirmedRequest.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUUnconfirmedRequest.go
index b9ac4c3..55f7f71 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUUnconfirmedRequest.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUUnconfirmedRequest.go
@@ -84,22 +84,19 @@ func NewAPDUUnconfirmedRequest(serviceRequest *BACnetUnconfirmedServiceRequest,
}
func CastAPDUUnconfirmedRequest(structType interface{}) *APDUUnconfirmedRequest {
- castFunc := func(typ interface{}) *APDUUnconfirmedRequest {
- if casted, ok := typ.(APDUUnconfirmedRequest); ok {
- return &casted
- }
- if casted, ok := typ.(*APDUUnconfirmedRequest); ok {
- return casted
- }
- if casted, ok := typ.(APDU); ok {
- return CastAPDUUnconfirmedRequest(casted.Child)
- }
- if casted, ok := typ.(*APDU); ok {
- return CastAPDUUnconfirmedRequest(casted.Child)
- }
- return nil
+ if casted, ok := structType.(APDUUnconfirmedRequest); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*APDUUnconfirmedRequest); ok {
+ return casted
+ }
+ if casted, ok := structType.(APDU); ok {
+ return CastAPDUUnconfirmedRequest(casted.Child)
+ }
+ if casted, ok := structType.(*APDU); ok {
+ return CastAPDUUnconfirmedRequest(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *APDUUnconfirmedRequest) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUUnknown.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUUnknown.go
index 4bdd81d..717124c 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUUnknown.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/APDUUnknown.go
@@ -83,22 +83,19 @@ func NewAPDUUnknown(unknownBytes []byte, apduLength uint16) *APDU {
}
func CastAPDUUnknown(structType interface{}) *APDUUnknown {
- castFunc := func(typ interface{}) *APDUUnknown {
- if casted, ok := typ.(APDUUnknown); ok {
- return &casted
- }
- if casted, ok := typ.(*APDUUnknown); ok {
- return casted
- }
- if casted, ok := typ.(APDU); ok {
- return CastAPDUUnknown(casted.Child)
- }
- if casted, ok := typ.(*APDU); ok {
- return CastAPDUUnknown(casted.Child)
- }
- return nil
+ if casted, ok := structType.(APDUUnknown); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*APDUUnknown); ok {
+ return casted
+ }
+ if casted, ok := structType.(APDU); ok {
+ return CastAPDUUnknown(casted.Child)
+ }
+ if casted, ok := structType.(*APDU); ok {
+ return CastAPDUUnknown(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *APDUUnknown) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetAction.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetAction.go
index 23021dd..ff4b165 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetAction.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetAction.go
@@ -79,16 +79,13 @@ func NewBACnetAction(rawData *BACnetContextTagEnumerated, tagNumber uint8) *BACn
}
func CastBACnetAction(structType interface{}) *BACnetAction {
- castFunc := func(typ interface{}) *BACnetAction {
- if casted, ok := typ.(BACnetAction); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetAction); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetAction); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetAction); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetAction) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetActionCommand.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetActionCommand.go
index d1a7164..0da42e4 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetActionCommand.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetActionCommand.go
@@ -117,16 +117,13 @@ func NewBACnetActionCommand(deviceIdentifier *BACnetContextTagObjectIdentifier,
}
func CastBACnetActionCommand(structType interface{}) *BACnetActionCommand {
- castFunc := func(typ interface{}) *BACnetActionCommand {
- if casted, ok := typ.(BACnetActionCommand); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetActionCommand); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetActionCommand); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetActionCommand); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetActionCommand) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetAddress.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetAddress.go
index afcccab..a0669cc 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetAddress.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetAddress.go
@@ -67,16 +67,13 @@ func NewBACnetAddress(address []uint8, port uint16) *BACnetAddress {
}
func CastBACnetAddress(structType interface{}) *BACnetAddress {
- castFunc := func(typ interface{}) *BACnetAddress {
- if casted, ok := typ.(BACnetAddress); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetAddress); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetAddress); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetAddress); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetAddress) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTag.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTag.go
index 45fcc12..cee9412 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTag.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTag.go
@@ -86,16 +86,13 @@ func NewBACnetApplicationTag(header *BACnetTagHeader) *BACnetApplicationTag {
}
func CastBACnetApplicationTag(structType interface{}) *BACnetApplicationTag {
- castFunc := func(typ interface{}) *BACnetApplicationTag {
- if casted, ok := typ.(BACnetApplicationTag); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetApplicationTag); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetApplicationTag); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetApplicationTag); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetApplicationTag) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagBitString.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagBitString.go
index 697809b..019404d 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagBitString.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagBitString.go
@@ -82,22 +82,19 @@ func NewBACnetApplicationTagBitString(payload *BACnetTagPayloadBitString, header
}
func CastBACnetApplicationTagBitString(structType interface{}) *BACnetApplicationTagBitString {
- castFunc := func(typ interface{}) *BACnetApplicationTagBitString {
- if casted, ok := typ.(BACnetApplicationTagBitString); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetApplicationTagBitString); ok {
- return casted
- }
- if casted, ok := typ.(BACnetApplicationTag); ok {
- return CastBACnetApplicationTagBitString(casted.Child)
- }
- if casted, ok := typ.(*BACnetApplicationTag); ok {
- return CastBACnetApplicationTagBitString(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetApplicationTagBitString); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetApplicationTagBitString); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetApplicationTag); ok {
+ return CastBACnetApplicationTagBitString(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetApplicationTag); ok {
+ return CastBACnetApplicationTagBitString(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetApplicationTagBitString) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagBoolean.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagBoolean.go
index 47ec10d..dd2844a 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagBoolean.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagBoolean.go
@@ -87,22 +87,19 @@ func NewBACnetApplicationTagBoolean(payload *BACnetTagPayloadBoolean, header *BA
}
func CastBACnetApplicationTagBoolean(structType interface{}) *BACnetApplicationTagBoolean {
- castFunc := func(typ interface{}) *BACnetApplicationTagBoolean {
- if casted, ok := typ.(BACnetApplicationTagBoolean); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetApplicationTagBoolean); ok {
- return casted
- }
- if casted, ok := typ.(BACnetApplicationTag); ok {
- return CastBACnetApplicationTagBoolean(casted.Child)
- }
- if casted, ok := typ.(*BACnetApplicationTag); ok {
- return CastBACnetApplicationTagBoolean(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetApplicationTagBoolean); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetApplicationTagBoolean); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetApplicationTag); ok {
+ return CastBACnetApplicationTagBoolean(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetApplicationTag); ok {
+ return CastBACnetApplicationTagBoolean(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetApplicationTagBoolean) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagCharacterString.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagCharacterString.go
index 59d8faf..f0d738f 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagCharacterString.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagCharacterString.go
@@ -87,22 +87,19 @@ func NewBACnetApplicationTagCharacterString(payload *BACnetTagPayloadCharacterSt
}
func CastBACnetApplicationTagCharacterString(structType interface{}) *BACnetApplicationTagCharacterString {
- castFunc := func(typ interface{}) *BACnetApplicationTagCharacterString {
- if casted, ok := typ.(BACnetApplicationTagCharacterString); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetApplicationTagCharacterString); ok {
- return casted
- }
- if casted, ok := typ.(BACnetApplicationTag); ok {
- return CastBACnetApplicationTagCharacterString(casted.Child)
- }
- if casted, ok := typ.(*BACnetApplicationTag); ok {
- return CastBACnetApplicationTagCharacterString(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetApplicationTagCharacterString); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetApplicationTagCharacterString); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetApplicationTag); ok {
+ return CastBACnetApplicationTagCharacterString(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetApplicationTag); ok {
+ return CastBACnetApplicationTagCharacterString(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetApplicationTagCharacterString) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagDate.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagDate.go
index e6b091a..b54c477 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagDate.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagDate.go
@@ -82,22 +82,19 @@ func NewBACnetApplicationTagDate(payload *BACnetTagPayloadDate, header *BACnetTa
}
func CastBACnetApplicationTagDate(structType interface{}) *BACnetApplicationTagDate {
- castFunc := func(typ interface{}) *BACnetApplicationTagDate {
- if casted, ok := typ.(BACnetApplicationTagDate); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetApplicationTagDate); ok {
- return casted
- }
- if casted, ok := typ.(BACnetApplicationTag); ok {
- return CastBACnetApplicationTagDate(casted.Child)
- }
- if casted, ok := typ.(*BACnetApplicationTag); ok {
- return CastBACnetApplicationTagDate(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetApplicationTagDate); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetApplicationTagDate); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetApplicationTag); ok {
+ return CastBACnetApplicationTagDate(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetApplicationTag); ok {
+ return CastBACnetApplicationTagDate(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetApplicationTagDate) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagDouble.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagDouble.go
index f3abaa6..d42f629 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagDouble.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagDouble.go
@@ -87,22 +87,19 @@ func NewBACnetApplicationTagDouble(payload *BACnetTagPayloadDouble, header *BACn
}
func CastBACnetApplicationTagDouble(structType interface{}) *BACnetApplicationTagDouble {
- castFunc := func(typ interface{}) *BACnetApplicationTagDouble {
- if casted, ok := typ.(BACnetApplicationTagDouble); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetApplicationTagDouble); ok {
- return casted
- }
- if casted, ok := typ.(BACnetApplicationTag); ok {
- return CastBACnetApplicationTagDouble(casted.Child)
- }
- if casted, ok := typ.(*BACnetApplicationTag); ok {
- return CastBACnetApplicationTagDouble(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetApplicationTagDouble); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetApplicationTagDouble); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetApplicationTag); ok {
+ return CastBACnetApplicationTagDouble(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetApplicationTag); ok {
+ return CastBACnetApplicationTagDouble(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetApplicationTagDouble) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagEnumerated.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagEnumerated.go
index e48d674..11323a3 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagEnumerated.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagEnumerated.go
@@ -87,22 +87,19 @@ func NewBACnetApplicationTagEnumerated(payload *BACnetTagPayloadEnumerated, head
}
func CastBACnetApplicationTagEnumerated(structType interface{}) *BACnetApplicationTagEnumerated {
- castFunc := func(typ interface{}) *BACnetApplicationTagEnumerated {
- if casted, ok := typ.(BACnetApplicationTagEnumerated); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetApplicationTagEnumerated); ok {
- return casted
- }
- if casted, ok := typ.(BACnetApplicationTag); ok {
- return CastBACnetApplicationTagEnumerated(casted.Child)
- }
- if casted, ok := typ.(*BACnetApplicationTag); ok {
- return CastBACnetApplicationTagEnumerated(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetApplicationTagEnumerated); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetApplicationTagEnumerated); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetApplicationTag); ok {
+ return CastBACnetApplicationTagEnumerated(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetApplicationTag); ok {
+ return CastBACnetApplicationTagEnumerated(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetApplicationTagEnumerated) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagNull.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagNull.go
index 8055857..e8c0f7f 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagNull.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagNull.go
@@ -74,22 +74,19 @@ func NewBACnetApplicationTagNull(header *BACnetTagHeader) *BACnetApplicationTag
}
func CastBACnetApplicationTagNull(structType interface{}) *BACnetApplicationTagNull {
- castFunc := func(typ interface{}) *BACnetApplicationTagNull {
- if casted, ok := typ.(BACnetApplicationTagNull); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetApplicationTagNull); ok {
- return casted
- }
- if casted, ok := typ.(BACnetApplicationTag); ok {
- return CastBACnetApplicationTagNull(casted.Child)
- }
- if casted, ok := typ.(*BACnetApplicationTag); ok {
- return CastBACnetApplicationTagNull(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetApplicationTagNull); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetApplicationTagNull); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetApplicationTag); ok {
+ return CastBACnetApplicationTagNull(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetApplicationTag); ok {
+ return CastBACnetApplicationTagNull(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetApplicationTagNull) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagObjectIdentifier.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagObjectIdentifier.go
index 01396d9..991d5a6 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagObjectIdentifier.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagObjectIdentifier.go
@@ -93,22 +93,19 @@ func NewBACnetApplicationTagObjectIdentifier(payload *BACnetTagPayloadObjectIden
}
func CastBACnetApplicationTagObjectIdentifier(structType interface{}) *BACnetApplicationTagObjectIdentifier {
- castFunc := func(typ interface{}) *BACnetApplicationTagObjectIdentifier {
- if casted, ok := typ.(BACnetApplicationTagObjectIdentifier); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetApplicationTagObjectIdentifier); ok {
- return casted
- }
- if casted, ok := typ.(BACnetApplicationTag); ok {
- return CastBACnetApplicationTagObjectIdentifier(casted.Child)
- }
- if casted, ok := typ.(*BACnetApplicationTag); ok {
- return CastBACnetApplicationTagObjectIdentifier(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetApplicationTagObjectIdentifier); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetApplicationTagObjectIdentifier); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetApplicationTag); ok {
+ return CastBACnetApplicationTagObjectIdentifier(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetApplicationTag); ok {
+ return CastBACnetApplicationTagObjectIdentifier(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetApplicationTagObjectIdentifier) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagOctetString.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagOctetString.go
index 3d3ecf7..1992a95 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagOctetString.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagOctetString.go
@@ -87,22 +87,19 @@ func NewBACnetApplicationTagOctetString(payload *BACnetTagPayloadOctetString, he
}
func CastBACnetApplicationTagOctetString(structType interface{}) *BACnetApplicationTagOctetString {
- castFunc := func(typ interface{}) *BACnetApplicationTagOctetString {
- if casted, ok := typ.(BACnetApplicationTagOctetString); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetApplicationTagOctetString); ok {
- return casted
- }
- if casted, ok := typ.(BACnetApplicationTag); ok {
- return CastBACnetApplicationTagOctetString(casted.Child)
- }
- if casted, ok := typ.(*BACnetApplicationTag); ok {
- return CastBACnetApplicationTagOctetString(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetApplicationTagOctetString); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetApplicationTagOctetString); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetApplicationTag); ok {
+ return CastBACnetApplicationTagOctetString(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetApplicationTag); ok {
+ return CastBACnetApplicationTagOctetString(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetApplicationTagOctetString) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagReal.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagReal.go
index 98b9d1c..90033c6 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagReal.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagReal.go
@@ -87,22 +87,19 @@ func NewBACnetApplicationTagReal(payload *BACnetTagPayloadReal, header *BACnetTa
}
func CastBACnetApplicationTagReal(structType interface{}) *BACnetApplicationTagReal {
- castFunc := func(typ interface{}) *BACnetApplicationTagReal {
- if casted, ok := typ.(BACnetApplicationTagReal); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetApplicationTagReal); ok {
- return casted
- }
- if casted, ok := typ.(BACnetApplicationTag); ok {
- return CastBACnetApplicationTagReal(casted.Child)
- }
- if casted, ok := typ.(*BACnetApplicationTag); ok {
- return CastBACnetApplicationTagReal(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetApplicationTagReal); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetApplicationTagReal); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetApplicationTag); ok {
+ return CastBACnetApplicationTagReal(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetApplicationTag); ok {
+ return CastBACnetApplicationTagReal(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetApplicationTagReal) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagSignedInteger.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagSignedInteger.go
index 4476b17..a6b010e 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagSignedInteger.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagSignedInteger.go
@@ -87,22 +87,19 @@ func NewBACnetApplicationTagSignedInteger(payload *BACnetTagPayloadSignedInteger
}
func CastBACnetApplicationTagSignedInteger(structType interface{}) *BACnetApplicationTagSignedInteger {
- castFunc := func(typ interface{}) *BACnetApplicationTagSignedInteger {
- if casted, ok := typ.(BACnetApplicationTagSignedInteger); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetApplicationTagSignedInteger); ok {
- return casted
- }
- if casted, ok := typ.(BACnetApplicationTag); ok {
- return CastBACnetApplicationTagSignedInteger(casted.Child)
- }
- if casted, ok := typ.(*BACnetApplicationTag); ok {
- return CastBACnetApplicationTagSignedInteger(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetApplicationTagSignedInteger); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetApplicationTagSignedInteger); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetApplicationTag); ok {
+ return CastBACnetApplicationTagSignedInteger(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetApplicationTag); ok {
+ return CastBACnetApplicationTagSignedInteger(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetApplicationTagSignedInteger) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagTime.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagTime.go
index 8e8690c..accb73f 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagTime.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagTime.go
@@ -82,22 +82,19 @@ func NewBACnetApplicationTagTime(payload *BACnetTagPayloadTime, header *BACnetTa
}
func CastBACnetApplicationTagTime(structType interface{}) *BACnetApplicationTagTime {
- castFunc := func(typ interface{}) *BACnetApplicationTagTime {
- if casted, ok := typ.(BACnetApplicationTagTime); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetApplicationTagTime); ok {
- return casted
- }
- if casted, ok := typ.(BACnetApplicationTag); ok {
- return CastBACnetApplicationTagTime(casted.Child)
- }
- if casted, ok := typ.(*BACnetApplicationTag); ok {
- return CastBACnetApplicationTagTime(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetApplicationTagTime); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetApplicationTagTime); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetApplicationTag); ok {
+ return CastBACnetApplicationTagTime(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetApplicationTag); ok {
+ return CastBACnetApplicationTagTime(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetApplicationTagTime) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagUnsignedInteger.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagUnsignedInteger.go
index baf8ffd..5dc8602 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagUnsignedInteger.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetApplicationTagUnsignedInteger.go
@@ -87,22 +87,19 @@ func NewBACnetApplicationTagUnsignedInteger(payload *BACnetTagPayloadUnsignedInt
}
func CastBACnetApplicationTagUnsignedInteger(structType interface{}) *BACnetApplicationTagUnsignedInteger {
- castFunc := func(typ interface{}) *BACnetApplicationTagUnsignedInteger {
- if casted, ok := typ.(BACnetApplicationTagUnsignedInteger); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetApplicationTagUnsignedInteger); ok {
- return casted
- }
- if casted, ok := typ.(BACnetApplicationTag); ok {
- return CastBACnetApplicationTagUnsignedInteger(casted.Child)
- }
- if casted, ok := typ.(*BACnetApplicationTag); ok {
- return CastBACnetApplicationTagUnsignedInteger(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetApplicationTagUnsignedInteger); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetApplicationTagUnsignedInteger); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetApplicationTag); ok {
+ return CastBACnetApplicationTagUnsignedInteger(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetApplicationTag); ok {
+ return CastBACnetApplicationTagUnsignedInteger(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetApplicationTagUnsignedInteger) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetBinaryPV.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetBinaryPV.go
index 00dc60c..03d6302 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetBinaryPV.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetBinaryPV.go
@@ -79,16 +79,13 @@ func NewBACnetBinaryPV(rawData *BACnetContextTagEnumerated, tagNumber uint8) *BA
}
func CastBACnetBinaryPV(structType interface{}) *BACnetBinaryPV {
- castFunc := func(typ interface{}) *BACnetBinaryPV {
- if casted, ok := typ.(BACnetBinaryPV); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetBinaryPV); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetBinaryPV); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetBinaryPV); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetBinaryPV) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetClosingTag.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetClosingTag.go
index 529f772..7b6cddb 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetClosingTag.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetClosingTag.go
@@ -78,22 +78,19 @@ func NewBACnetClosingTag(header *BACnetTagHeader, tagNumberArgument uint8, actua
}
func CastBACnetClosingTag(structType interface{}) *BACnetClosingTag {
- castFunc := func(typ interface{}) *BACnetClosingTag {
- if casted, ok := typ.(BACnetClosingTag); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetClosingTag); ok {
- return casted
- }
- if casted, ok := typ.(BACnetContextTag); ok {
- return CastBACnetClosingTag(casted.Child)
- }
- if casted, ok := typ.(*BACnetContextTag); ok {
- return CastBACnetClosingTag(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetClosingTag); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetClosingTag); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetContextTag); ok {
+ return CastBACnetClosingTag(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetContextTag); ok {
+ return CastBACnetClosingTag(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetClosingTag) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACK.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACK.go
index 4a0369e..7f4f916 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACK.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACK.go
@@ -69,16 +69,13 @@ func NewBACnetConfirmedServiceACK() *BACnetConfirmedServiceACK {
}
func CastBACnetConfirmedServiceACK(structType interface{}) *BACnetConfirmedServiceACK {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceACK {
- if casted, ok := typ.(BACnetConfirmedServiceACK); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceACK); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceACK); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetConfirmedServiceACK); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetConfirmedServiceACK) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKAtomicReadFile.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKAtomicReadFile.go
index e9e4855..19086b7 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKAtomicReadFile.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKAtomicReadFile.go
@@ -73,22 +73,19 @@ func NewBACnetConfirmedServiceACKAtomicReadFile() *BACnetConfirmedServiceACK {
}
func CastBACnetConfirmedServiceACKAtomicReadFile(structType interface{}) *BACnetConfirmedServiceACKAtomicReadFile {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceACKAtomicReadFile {
- if casted, ok := typ.(BACnetConfirmedServiceACKAtomicReadFile); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceACKAtomicReadFile); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceACK); ok {
- return CastBACnetConfirmedServiceACKAtomicReadFile(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceACK); ok {
- return CastBACnetConfirmedServiceACKAtomicReadFile(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceACKAtomicReadFile); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceACKAtomicReadFile); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceACK); ok {
+ return CastBACnetConfirmedServiceACKAtomicReadFile(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceACK); ok {
+ return CastBACnetConfirmedServiceACKAtomicReadFile(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceACKAtomicReadFile) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKAtomicWriteFile.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKAtomicWriteFile.go
index 6045a4d..0b1ae2e 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKAtomicWriteFile.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKAtomicWriteFile.go
@@ -73,22 +73,19 @@ func NewBACnetConfirmedServiceACKAtomicWriteFile() *BACnetConfirmedServiceACK {
}
func CastBACnetConfirmedServiceACKAtomicWriteFile(structType interface{}) *BACnetConfirmedServiceACKAtomicWriteFile {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceACKAtomicWriteFile {
- if casted, ok := typ.(BACnetConfirmedServiceACKAtomicWriteFile); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceACKAtomicWriteFile); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceACK); ok {
- return CastBACnetConfirmedServiceACKAtomicWriteFile(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceACK); ok {
- return CastBACnetConfirmedServiceACKAtomicWriteFile(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceACKAtomicWriteFile); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceACKAtomicWriteFile); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceACK); ok {
+ return CastBACnetConfirmedServiceACKAtomicWriteFile(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceACK); ok {
+ return CastBACnetConfirmedServiceACKAtomicWriteFile(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceACKAtomicWriteFile) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKConfirmedPrivateTransfer.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKConfirmedPrivateTransfer.go
index 259df4f..f63921c 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKConfirmedPrivateTransfer.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKConfirmedPrivateTransfer.go
@@ -73,22 +73,19 @@ func NewBACnetConfirmedServiceACKConfirmedPrivateTransfer() *BACnetConfirmedServ
}
func CastBACnetConfirmedServiceACKConfirmedPrivateTransfer(structType interface{}) *BACnetConfirmedServiceACKConfirmedPrivateTransfer {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceACKConfirmedPrivateTransfer {
- if casted, ok := typ.(BACnetConfirmedServiceACKConfirmedPrivateTransfer); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceACKConfirmedPrivateTransfer); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceACK); ok {
- return CastBACnetConfirmedServiceACKConfirmedPrivateTransfer(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceACK); ok {
- return CastBACnetConfirmedServiceACKConfirmedPrivateTransfer(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceACKConfirmedPrivateTransfer); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceACKConfirmedPrivateTransfer); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceACK); ok {
+ return CastBACnetConfirmedServiceACKConfirmedPrivateTransfer(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceACK); ok {
+ return CastBACnetConfirmedServiceACKConfirmedPrivateTransfer(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceACKConfirmedPrivateTransfer) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKCreateObject.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKCreateObject.go
index b322300..c5c4dcf 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKCreateObject.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKCreateObject.go
@@ -72,22 +72,19 @@ func NewBACnetConfirmedServiceACKCreateObject() *BACnetConfirmedServiceACK {
}
func CastBACnetConfirmedServiceACKCreateObject(structType interface{}) *BACnetConfirmedServiceACKCreateObject {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceACKCreateObject {
- if casted, ok := typ.(BACnetConfirmedServiceACKCreateObject); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceACKCreateObject); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceACK); ok {
- return CastBACnetConfirmedServiceACKCreateObject(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceACK); ok {
- return CastBACnetConfirmedServiceACKCreateObject(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceACKCreateObject); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceACKCreateObject); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceACK); ok {
+ return CastBACnetConfirmedServiceACKCreateObject(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceACK); ok {
+ return CastBACnetConfirmedServiceACKCreateObject(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceACKCreateObject) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKGetAlarmSummary.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKGetAlarmSummary.go
index 507ae14..d025c82 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKGetAlarmSummary.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKGetAlarmSummary.go
@@ -73,22 +73,19 @@ func NewBACnetConfirmedServiceACKGetAlarmSummary() *BACnetConfirmedServiceACK {
}
func CastBACnetConfirmedServiceACKGetAlarmSummary(structType interface{}) *BACnetConfirmedServiceACKGetAlarmSummary {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceACKGetAlarmSummary {
- if casted, ok := typ.(BACnetConfirmedServiceACKGetAlarmSummary); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceACKGetAlarmSummary); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceACK); ok {
- return CastBACnetConfirmedServiceACKGetAlarmSummary(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceACK); ok {
- return CastBACnetConfirmedServiceACKGetAlarmSummary(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceACKGetAlarmSummary); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceACKGetAlarmSummary); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceACK); ok {
+ return CastBACnetConfirmedServiceACKGetAlarmSummary(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceACK); ok {
+ return CastBACnetConfirmedServiceACKGetAlarmSummary(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceACKGetAlarmSummary) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKGetEnrollmentSummary.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKGetEnrollmentSummary.go
index 6ad4a4e..7a21a7c 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKGetEnrollmentSummary.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKGetEnrollmentSummary.go
@@ -73,22 +73,19 @@ func NewBACnetConfirmedServiceACKGetEnrollmentSummary() *BACnetConfirmedServiceA
}
func CastBACnetConfirmedServiceACKGetEnrollmentSummary(structType interface{}) *BACnetConfirmedServiceACKGetEnrollmentSummary {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceACKGetEnrollmentSummary {
- if casted, ok := typ.(BACnetConfirmedServiceACKGetEnrollmentSummary); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceACKGetEnrollmentSummary); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceACK); ok {
- return CastBACnetConfirmedServiceACKGetEnrollmentSummary(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceACK); ok {
- return CastBACnetConfirmedServiceACKGetEnrollmentSummary(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceACKGetEnrollmentSummary); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceACKGetEnrollmentSummary); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceACK); ok {
+ return CastBACnetConfirmedServiceACKGetEnrollmentSummary(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceACK); ok {
+ return CastBACnetConfirmedServiceACKGetEnrollmentSummary(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceACKGetEnrollmentSummary) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKGetEventInformation.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKGetEventInformation.go
index 0bd557d..37d9e57 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKGetEventInformation.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKGetEventInformation.go
@@ -73,22 +73,19 @@ func NewBACnetConfirmedServiceACKGetEventInformation() *BACnetConfirmedServiceAC
}
func CastBACnetConfirmedServiceACKGetEventInformation(structType interface{}) *BACnetConfirmedServiceACKGetEventInformation {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceACKGetEventInformation {
- if casted, ok := typ.(BACnetConfirmedServiceACKGetEventInformation); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceACKGetEventInformation); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceACK); ok {
- return CastBACnetConfirmedServiceACKGetEventInformation(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceACK); ok {
- return CastBACnetConfirmedServiceACKGetEventInformation(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceACKGetEventInformation); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceACKGetEventInformation); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceACK); ok {
+ return CastBACnetConfirmedServiceACKGetEventInformation(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceACK); ok {
+ return CastBACnetConfirmedServiceACKGetEventInformation(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceACKGetEventInformation) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKReadProperty.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKReadProperty.go
index 8ab1041..b5514e3 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKReadProperty.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKReadProperty.go
@@ -72,22 +72,19 @@ func NewBACnetConfirmedServiceACKReadProperty() *BACnetConfirmedServiceACK {
}
func CastBACnetConfirmedServiceACKReadProperty(structType interface{}) *BACnetConfirmedServiceACKReadProperty {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceACKReadProperty {
- if casted, ok := typ.(BACnetConfirmedServiceACKReadProperty); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceACKReadProperty); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceACK); ok {
- return CastBACnetConfirmedServiceACKReadProperty(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceACK); ok {
- return CastBACnetConfirmedServiceACKReadProperty(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceACKReadProperty); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceACKReadProperty); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceACK); ok {
+ return CastBACnetConfirmedServiceACKReadProperty(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceACK); ok {
+ return CastBACnetConfirmedServiceACKReadProperty(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceACKReadProperty) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKReadPropertyMultiple.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKReadPropertyMultiple.go
index c7ca0b6..d5992a0 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKReadPropertyMultiple.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKReadPropertyMultiple.go
@@ -73,22 +73,19 @@ func NewBACnetConfirmedServiceACKReadPropertyMultiple() *BACnetConfirmedServiceA
}
func CastBACnetConfirmedServiceACKReadPropertyMultiple(structType interface{}) *BACnetConfirmedServiceACKReadPropertyMultiple {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceACKReadPropertyMultiple {
- if casted, ok := typ.(BACnetConfirmedServiceACKReadPropertyMultiple); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceACKReadPropertyMultiple); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceACK); ok {
- return CastBACnetConfirmedServiceACKReadPropertyMultiple(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceACK); ok {
- return CastBACnetConfirmedServiceACKReadPropertyMultiple(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceACKReadPropertyMultiple); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceACKReadPropertyMultiple); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceACK); ok {
+ return CastBACnetConfirmedServiceACKReadPropertyMultiple(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceACK); ok {
+ return CastBACnetConfirmedServiceACKReadPropertyMultiple(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceACKReadPropertyMultiple) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKReadRange.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKReadRange.go
index f06da5d..520c15c 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKReadRange.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKReadRange.go
@@ -72,22 +72,19 @@ func NewBACnetConfirmedServiceACKReadRange() *BACnetConfirmedServiceACK {
}
func CastBACnetConfirmedServiceACKReadRange(structType interface{}) *BACnetConfirmedServiceACKReadRange {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceACKReadRange {
- if casted, ok := typ.(BACnetConfirmedServiceACKReadRange); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceACKReadRange); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceACK); ok {
- return CastBACnetConfirmedServiceACKReadRange(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceACK); ok {
- return CastBACnetConfirmedServiceACKReadRange(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceACKReadRange); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceACKReadRange); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceACK); ok {
+ return CastBACnetConfirmedServiceACKReadRange(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceACK); ok {
+ return CastBACnetConfirmedServiceACKReadRange(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceACKReadRange) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKRemovedAuthenticate.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKRemovedAuthenticate.go
index 928860c..c525297 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKRemovedAuthenticate.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKRemovedAuthenticate.go
@@ -73,22 +73,19 @@ func NewBACnetConfirmedServiceACKRemovedAuthenticate() *BACnetConfirmedServiceAC
}
func CastBACnetConfirmedServiceACKRemovedAuthenticate(structType interface{}) *BACnetConfirmedServiceACKRemovedAuthenticate {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceACKRemovedAuthenticate {
- if casted, ok := typ.(BACnetConfirmedServiceACKRemovedAuthenticate); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceACKRemovedAuthenticate); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceACK); ok {
- return CastBACnetConfirmedServiceACKRemovedAuthenticate(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceACK); ok {
- return CastBACnetConfirmedServiceACKRemovedAuthenticate(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceACKRemovedAuthenticate); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceACKRemovedAuthenticate); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceACK); ok {
+ return CastBACnetConfirmedServiceACKRemovedAuthenticate(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceACK); ok {
+ return CastBACnetConfirmedServiceACKRemovedAuthenticate(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceACKRemovedAuthenticate) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKRemovedReadPropertyConditional.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKRemovedReadPropertyConditional.go
index 406c221..1826e41 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKRemovedReadPropertyConditional.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKRemovedReadPropertyConditional.go
@@ -73,22 +73,19 @@ func NewBACnetConfirmedServiceACKRemovedReadPropertyConditional() *BACnetConfirm
}
func CastBACnetConfirmedServiceACKRemovedReadPropertyConditional(structType interface{}) *BACnetConfirmedServiceACKRemovedReadPropertyConditional {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceACKRemovedReadPropertyConditional {
- if casted, ok := typ.(BACnetConfirmedServiceACKRemovedReadPropertyConditional); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceACKRemovedReadPropertyConditional); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceACK); ok {
- return CastBACnetConfirmedServiceACKRemovedReadPropertyConditional(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceACK); ok {
- return CastBACnetConfirmedServiceACKRemovedReadPropertyConditional(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceACKRemovedReadPropertyConditional); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceACKRemovedReadPropertyConditional); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceACK); ok {
+ return CastBACnetConfirmedServiceACKRemovedReadPropertyConditional(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceACK); ok {
+ return CastBACnetConfirmedServiceACKRemovedReadPropertyConditional(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceACKRemovedReadPropertyConditional) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKVTData.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKVTData.go
index 95e4757..63e6084 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKVTData.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKVTData.go
@@ -72,22 +72,19 @@ func NewBACnetConfirmedServiceACKVTData() *BACnetConfirmedServiceACK {
}
func CastBACnetConfirmedServiceACKVTData(structType interface{}) *BACnetConfirmedServiceACKVTData {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceACKVTData {
- if casted, ok := typ.(BACnetConfirmedServiceACKVTData); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceACKVTData); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceACK); ok {
- return CastBACnetConfirmedServiceACKVTData(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceACK); ok {
- return CastBACnetConfirmedServiceACKVTData(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceACKVTData); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceACKVTData); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceACK); ok {
+ return CastBACnetConfirmedServiceACKVTData(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceACK); ok {
+ return CastBACnetConfirmedServiceACKVTData(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceACKVTData) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKVTOpen.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKVTOpen.go
index f4d68f4..ca131d1 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKVTOpen.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceACKVTOpen.go
@@ -72,22 +72,19 @@ func NewBACnetConfirmedServiceACKVTOpen() *BACnetConfirmedServiceACK {
}
func CastBACnetConfirmedServiceACKVTOpen(structType interface{}) *BACnetConfirmedServiceACKVTOpen {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceACKVTOpen {
- if casted, ok := typ.(BACnetConfirmedServiceACKVTOpen); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceACKVTOpen); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceACK); ok {
- return CastBACnetConfirmedServiceACKVTOpen(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceACK); ok {
- return CastBACnetConfirmedServiceACKVTOpen(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceACKVTOpen); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceACKVTOpen); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceACK); ok {
+ return CastBACnetConfirmedServiceACKVTOpen(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceACK); ok {
+ return CastBACnetConfirmedServiceACKVTOpen(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceACKVTOpen) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceAddListElement.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceAddListElement.go
index 705280a..a6d5641 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceAddListElement.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceAddListElement.go
@@ -72,22 +72,19 @@ func NewBACnetConfirmedServiceAddListElement() *BACnetConfirmedServiceACK {
}
func CastBACnetConfirmedServiceAddListElement(structType interface{}) *BACnetConfirmedServiceAddListElement {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceAddListElement {
- if casted, ok := typ.(BACnetConfirmedServiceAddListElement); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceAddListElement); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceACK); ok {
- return CastBACnetConfirmedServiceAddListElement(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceACK); ok {
- return CastBACnetConfirmedServiceAddListElement(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceAddListElement); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceAddListElement); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceACK); ok {
+ return CastBACnetConfirmedServiceAddListElement(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceACK); ok {
+ return CastBACnetConfirmedServiceAddListElement(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceAddListElement) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequest.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequest.go
index 793f8c6..bb395dd 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequest.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequest.go
@@ -72,16 +72,13 @@ func NewBACnetConfirmedServiceRequest(len uint16) *BACnetConfirmedServiceRequest
}
func CastBACnetConfirmedServiceRequest(structType interface{}) *BACnetConfirmedServiceRequest {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequest {
- if casted, ok := typ.(BACnetConfirmedServiceRequest); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequest); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequest); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetConfirmedServiceRequest); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetConfirmedServiceRequest) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAcknowledgeAlarm.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAcknowledgeAlarm.go
index 42fa3c8..bfd3671 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAcknowledgeAlarm.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAcknowledgeAlarm.go
@@ -76,22 +76,19 @@ func NewBACnetConfirmedServiceRequestAcknowledgeAlarm(len uint16) *BACnetConfirm
}
func CastBACnetConfirmedServiceRequestAcknowledgeAlarm(structType interface{}) *BACnetConfirmedServiceRequestAcknowledgeAlarm {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestAcknowledgeAlarm {
- if casted, ok := typ.(BACnetConfirmedServiceRequestAcknowledgeAlarm); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestAcknowledgeAlarm); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestAcknowledgeAlarm(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestAcknowledgeAlarm(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestAcknowledgeAlarm); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestAcknowledgeAlarm); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestAcknowledgeAlarm(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestAcknowledgeAlarm(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestAcknowledgeAlarm) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAddListElement.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAddListElement.go
index b952ef9..29102d9 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAddListElement.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAddListElement.go
@@ -76,22 +76,19 @@ func NewBACnetConfirmedServiceRequestAddListElement(len uint16) *BACnetConfirmed
}
func CastBACnetConfirmedServiceRequestAddListElement(structType interface{}) *BACnetConfirmedServiceRequestAddListElement {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestAddListElement {
- if casted, ok := typ.(BACnetConfirmedServiceRequestAddListElement); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestAddListElement); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestAddListElement(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestAddListElement(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestAddListElement); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestAddListElement); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestAddListElement(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestAddListElement(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestAddListElement) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicReadFile.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicReadFile.go
index 39ff5ef..841ae1b 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicReadFile.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicReadFile.go
@@ -92,22 +92,19 @@ func NewBACnetConfirmedServiceRequestAtomicReadFile(fileIdentifier *BACnetApplic
}
func CastBACnetConfirmedServiceRequestAtomicReadFile(structType interface{}) *BACnetConfirmedServiceRequestAtomicReadFile {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestAtomicReadFile {
- if casted, ok := typ.(BACnetConfirmedServiceRequestAtomicReadFile); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestAtomicReadFile); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestAtomicReadFile(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestAtomicReadFile(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestAtomicReadFile); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestAtomicReadFile); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestAtomicReadFile(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestAtomicReadFile(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestAtomicReadFile) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicReadFileRecord.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicReadFileRecord.go
index 24da8dd..1ffc2b3 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicReadFileRecord.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicReadFileRecord.go
@@ -92,22 +92,19 @@ func NewBACnetConfirmedServiceRequestAtomicReadFileRecord(fileStartRecord *BACne
}
func CastBACnetConfirmedServiceRequestAtomicReadFileRecord(structType interface{}) *BACnetConfirmedServiceRequestAtomicReadFileRecord {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestAtomicReadFileRecord {
- if casted, ok := typ.(BACnetConfirmedServiceRequestAtomicReadFileRecord); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestAtomicReadFileRecord); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord); ok {
- return CastBACnetConfirmedServiceRequestAtomicReadFileRecord(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord); ok {
- return CastBACnetConfirmedServiceRequestAtomicReadFileRecord(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestAtomicReadFileRecord); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestAtomicReadFileRecord); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord); ok {
+ return CastBACnetConfirmedServiceRequestAtomicReadFileRecord(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord); ok {
+ return CastBACnetConfirmedServiceRequestAtomicReadFileRecord(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestAtomicReadFileRecord) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicReadFileStream.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicReadFileStream.go
index 9e16918..944bfc6 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicReadFileStream.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicReadFileStream.go
@@ -92,22 +92,19 @@ func NewBACnetConfirmedServiceRequestAtomicReadFileStream(fileStartPosition *BAC
}
func CastBACnetConfirmedServiceRequestAtomicReadFileStream(structType interface{}) *BACnetConfirmedServiceRequestAtomicReadFileStream {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestAtomicReadFileStream {
- if casted, ok := typ.(BACnetConfirmedServiceRequestAtomicReadFileStream); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestAtomicReadFileStream); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord); ok {
- return CastBACnetConfirmedServiceRequestAtomicReadFileStream(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord); ok {
- return CastBACnetConfirmedServiceRequestAtomicReadFileStream(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestAtomicReadFileStream); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestAtomicReadFileStream); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord); ok {
+ return CastBACnetConfirmedServiceRequestAtomicReadFileStream(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord); ok {
+ return CastBACnetConfirmedServiceRequestAtomicReadFileStream(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestAtomicReadFileStream) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord.go
index af5ec53..9a45a20 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord.go
@@ -94,16 +94,13 @@ func NewBACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord(peekedTagHeade
}
func CastBACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord(structType interface{}) *BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord {
- if casted, ok := typ.(BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetConfirmedServiceRequestAtomicReadFileStreamOrRecord) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicWriteFile.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicWriteFile.go
index c201297..fb547ab 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicWriteFile.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestAtomicWriteFile.go
@@ -117,22 +117,19 @@ func NewBACnetConfirmedServiceRequestAtomicWriteFile(deviceIdentifier *BACnetApp
}
func CastBACnetConfirmedServiceRequestAtomicWriteFile(structType interface{}) *BACnetConfirmedServiceRequestAtomicWriteFile {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestAtomicWriteFile {
- if casted, ok := typ.(BACnetConfirmedServiceRequestAtomicWriteFile); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestAtomicWriteFile); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestAtomicWriteFile(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestAtomicWriteFile(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestAtomicWriteFile); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestAtomicWriteFile); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestAtomicWriteFile(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestAtomicWriteFile(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestAtomicWriteFile) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedCOVNotification.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedCOVNotification.go
index 9f87353..d20b0f4 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedCOVNotification.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedCOVNotification.go
@@ -116,22 +116,19 @@ func NewBACnetConfirmedServiceRequestConfirmedCOVNotification(subscriberProcessI
}
func CastBACnetConfirmedServiceRequestConfirmedCOVNotification(structType interface{}) *BACnetConfirmedServiceRequestConfirmedCOVNotification {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestConfirmedCOVNotification {
- if casted, ok := typ.(BACnetConfirmedServiceRequestConfirmedCOVNotification); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestConfirmedCOVNotification); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestConfirmedCOVNotification(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestConfirmedCOVNotification(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestConfirmedCOVNotification); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestConfirmedCOVNotification); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestConfirmedCOVNotification(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestConfirmedCOVNotification(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestConfirmedCOVNotification) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple.go
index 3bf1968..c4b0792 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple.go
@@ -76,22 +76,19 @@ func NewBACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple(len uint16
}
func CastBACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple(structType interface{}) *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple {
- if casted, ok := typ.(BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestConfirmedCOVNotificationMultiple) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedEventNotification.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedEventNotification.go
index 470f15f..6a38909 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedEventNotification.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedEventNotification.go
@@ -181,22 +181,19 @@ func NewBACnetConfirmedServiceRequestConfirmedEventNotification(processIdentifie
}
func CastBACnetConfirmedServiceRequestConfirmedEventNotification(structType interface{}) *BACnetConfirmedServiceRequestConfirmedEventNotification {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestConfirmedEventNotification {
- if casted, ok := typ.(BACnetConfirmedServiceRequestConfirmedEventNotification); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestConfirmedEventNotification); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestConfirmedEventNotification(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestConfirmedEventNotification(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestConfirmedEventNotification); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestConfirmedEventNotification); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestConfirmedEventNotification(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestConfirmedEventNotification(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestConfirmedEventNotification) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedPrivateTransfer.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedPrivateTransfer.go
index aecba66..ff98606 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedPrivateTransfer.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedPrivateTransfer.go
@@ -76,22 +76,19 @@ func NewBACnetConfirmedServiceRequestConfirmedPrivateTransfer(len uint16) *BACne
}
func CastBACnetConfirmedServiceRequestConfirmedPrivateTransfer(structType interface{}) *BACnetConfirmedServiceRequestConfirmedPrivateTransfer {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestConfirmedPrivateTransfer {
- if casted, ok := typ.(BACnetConfirmedServiceRequestConfirmedPrivateTransfer); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestConfirmedPrivateTransfer); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestConfirmedPrivateTransfer(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestConfirmedPrivateTransfer(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestConfirmedPrivateTransfer); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestConfirmedPrivateTransfer); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestConfirmedPrivateTransfer(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestConfirmedPrivateTransfer(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestConfirmedPrivateTransfer) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedTextMessage.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedTextMessage.go
index 5c839dc..9954389 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedTextMessage.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedTextMessage.go
@@ -76,22 +76,19 @@ func NewBACnetConfirmedServiceRequestConfirmedTextMessage(len uint16) *BACnetCon
}
func CastBACnetConfirmedServiceRequestConfirmedTextMessage(structType interface{}) *BACnetConfirmedServiceRequestConfirmedTextMessage {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestConfirmedTextMessage {
- if casted, ok := typ.(BACnetConfirmedServiceRequestConfirmedTextMessage); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestConfirmedTextMessage); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestConfirmedTextMessage(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestConfirmedTextMessage(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestConfirmedTextMessage); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestConfirmedTextMessage); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestConfirmedTextMessage(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestConfirmedTextMessage(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestConfirmedTextMessage) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedUnknown.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedUnknown.go
index 6994a55..c5af8a1 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedUnknown.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestConfirmedUnknown.go
@@ -84,22 +84,19 @@ func NewBACnetConfirmedServiceRequestConfirmedUnknown(unknownBytes []byte, len u
}
func CastBACnetConfirmedServiceRequestConfirmedUnknown(structType interface{}) *BACnetConfirmedServiceRequestConfirmedUnknown {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestConfirmedUnknown {
- if casted, ok := typ.(BACnetConfirmedServiceRequestConfirmedUnknown); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestConfirmedUnknown); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestConfirmedUnknown(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestConfirmedUnknown(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestConfirmedUnknown); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestConfirmedUnknown); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestConfirmedUnknown(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestConfirmedUnknown(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestConfirmedUnknown) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestCreateObject.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestCreateObject.go
index 7d1e20a..249faee 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestCreateObject.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestCreateObject.go
@@ -76,22 +76,19 @@ func NewBACnetConfirmedServiceRequestCreateObject(len uint16) *BACnetConfirmedSe
}
func CastBACnetConfirmedServiceRequestCreateObject(structType interface{}) *BACnetConfirmedServiceRequestCreateObject {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestCreateObject {
- if casted, ok := typ.(BACnetConfirmedServiceRequestCreateObject); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestCreateObject); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestCreateObject(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestCreateObject(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestCreateObject); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestCreateObject); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestCreateObject(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestCreateObject(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestCreateObject) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestDeleteObject.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestDeleteObject.go
index bc67e88..9172165 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestDeleteObject.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestDeleteObject.go
@@ -76,22 +76,19 @@ func NewBACnetConfirmedServiceRequestDeleteObject(len uint16) *BACnetConfirmedSe
}
func CastBACnetConfirmedServiceRequestDeleteObject(structType interface{}) *BACnetConfirmedServiceRequestDeleteObject {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestDeleteObject {
- if casted, ok := typ.(BACnetConfirmedServiceRequestDeleteObject); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestDeleteObject); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestDeleteObject(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestDeleteObject(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestDeleteObject); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestDeleteObject); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestDeleteObject(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestDeleteObject(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestDeleteObject) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestDeviceCommunicationControl.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestDeviceCommunicationControl.go
index bde35bc..c9e21f5 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestDeviceCommunicationControl.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestDeviceCommunicationControl.go
@@ -101,22 +101,19 @@ func NewBACnetConfirmedServiceRequestDeviceCommunicationControl(timeDuration *BA
}
func CastBACnetConfirmedServiceRequestDeviceCommunicationControl(structType interface{}) *BACnetConfirmedServiceRequestDeviceCommunicationControl {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestDeviceCommunicationControl {
- if casted, ok := typ.(BACnetConfirmedServiceRequestDeviceCommunicationControl); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestDeviceCommunicationControl); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestDeviceCommunicationControl(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestDeviceCommunicationControl(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestDeviceCommunicationControl); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestDeviceCommunicationControl); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestDeviceCommunicationControl(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestDeviceCommunicationControl(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestDeviceCommunicationControl) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestGetEnrollmentSummary.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestGetEnrollmentSummary.go
index 2a5c5c0..c5fba7f 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestGetEnrollmentSummary.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestGetEnrollmentSummary.go
@@ -76,22 +76,19 @@ func NewBACnetConfirmedServiceRequestGetEnrollmentSummary(len uint16) *BACnetCon
}
func CastBACnetConfirmedServiceRequestGetEnrollmentSummary(structType interface{}) *BACnetConfirmedServiceRequestGetEnrollmentSummary {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestGetEnrollmentSummary {
- if casted, ok := typ.(BACnetConfirmedServiceRequestGetEnrollmentSummary); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestGetEnrollmentSummary); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestGetEnrollmentSummary(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestGetEnrollmentSummary(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestGetEnrollmentSummary); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestGetEnrollmentSummary); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestGetEnrollmentSummary(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestGetEnrollmentSummary(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestGetEnrollmentSummary) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestGetEventInformation.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestGetEventInformation.go
index e0d659d..2659f6a 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestGetEventInformation.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestGetEventInformation.go
@@ -76,22 +76,19 @@ func NewBACnetConfirmedServiceRequestGetEventInformation(len uint16) *BACnetConf
}
func CastBACnetConfirmedServiceRequestGetEventInformation(structType interface{}) *BACnetConfirmedServiceRequestGetEventInformation {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestGetEventInformation {
- if casted, ok := typ.(BACnetConfirmedServiceRequestGetEventInformation); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestGetEventInformation); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestGetEventInformation(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestGetEventInformation(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestGetEventInformation); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestGetEventInformation); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestGetEventInformation(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestGetEventInformation(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestGetEventInformation) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestLifeSafetyOperation.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestLifeSafetyOperation.go
index 8dfeac7..184dff9 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestLifeSafetyOperation.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestLifeSafetyOperation.go
@@ -76,22 +76,19 @@ func NewBACnetConfirmedServiceRequestLifeSafetyOperation(len uint16) *BACnetConf
}
func CastBACnetConfirmedServiceRequestLifeSafetyOperation(structType interface{}) *BACnetConfirmedServiceRequestLifeSafetyOperation {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestLifeSafetyOperation {
- if casted, ok := typ.(BACnetConfirmedServiceRequestLifeSafetyOperation); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestLifeSafetyOperation); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestLifeSafetyOperation(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestLifeSafetyOperation(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestLifeSafetyOperation); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestLifeSafetyOperation); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestLifeSafetyOperation(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestLifeSafetyOperation(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestLifeSafetyOperation) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadProperty.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadProperty.go
index 413e91d..b86820b 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadProperty.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadProperty.go
@@ -101,22 +101,19 @@ func NewBACnetConfirmedServiceRequestReadProperty(objectIdentifier *BACnetContex
}
func CastBACnetConfirmedServiceRequestReadProperty(structType interface{}) *BACnetConfirmedServiceRequestReadProperty {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestReadProperty {
- if casted, ok := typ.(BACnetConfirmedServiceRequestReadProperty); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestReadProperty); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestReadProperty(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestReadProperty(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestReadProperty); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestReadProperty); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestReadProperty(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestReadProperty(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestReadProperty) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadPropertyMultiple.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadPropertyMultiple.go
index db138dd..1aa05ce 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadPropertyMultiple.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadPropertyMultiple.go
@@ -84,22 +84,19 @@ func NewBACnetConfirmedServiceRequestReadPropertyMultiple(data []*BACnetReadAcce
}
func CastBACnetConfirmedServiceRequestReadPropertyMultiple(structType interface{}) *BACnetConfirmedServiceRequestReadPropertyMultiple {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestReadPropertyMultiple {
- if casted, ok := typ.(BACnetConfirmedServiceRequestReadPropertyMultiple); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestReadPropertyMultiple); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestReadPropertyMultiple(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestReadPropertyMultiple(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestReadPropertyMultiple); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestReadPropertyMultiple); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestReadPropertyMultiple(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestReadPropertyMultiple(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestReadPropertyMultiple) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadRange.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadRange.go
index a0d1f1b..9570d26 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadRange.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReadRange.go
@@ -76,22 +76,19 @@ func NewBACnetConfirmedServiceRequestReadRange(len uint16) *BACnetConfirmedServi
}
func CastBACnetConfirmedServiceRequestReadRange(structType interface{}) *BACnetConfirmedServiceRequestReadRange {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestReadRange {
- if casted, ok := typ.(BACnetConfirmedServiceRequestReadRange); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestReadRange); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestReadRange(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestReadRange(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestReadRange); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestReadRange); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestReadRange(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestReadRange(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestReadRange) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReinitializeDevice.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReinitializeDevice.go
index 0ebd882..9485aea 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReinitializeDevice.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReinitializeDevice.go
@@ -93,22 +93,19 @@ func NewBACnetConfirmedServiceRequestReinitializeDevice(reinitializedStateOfDevi
}
func CastBACnetConfirmedServiceRequestReinitializeDevice(structType interface{}) *BACnetConfirmedServiceRequestReinitializeDevice {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestReinitializeDevice {
- if casted, ok := typ.(BACnetConfirmedServiceRequestReinitializeDevice); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestReinitializeDevice); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestReinitializeDevice(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestReinitializeDevice(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestReinitializeDevice); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestReinitializeDevice); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestReinitializeDevice(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestReinitializeDevice(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestReinitializeDevice) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReinitializeDeviceEnableDisable.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReinitializeDeviceEnableDisable.go
index baf461d..e58e3e0 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReinitializeDeviceEnableDisable.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestReinitializeDeviceEnableDisable.go
@@ -87,16 +87,13 @@ func NewBACnetConfirmedServiceRequestReinitializeDeviceEnableDisable(rawData *BA
}
func CastBACnetConfirmedServiceRequestReinitializeDeviceEnableDisable(structType interface{}) *BACnetConfirmedServiceRequestReinitializeDeviceEnableDisable {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestReinitializeDeviceEnableDisable {
- if casted, ok := typ.(BACnetConfirmedServiceRequestReinitializeDeviceEnableDisable); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestReinitializeDeviceEnableDisable); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestReinitializeDeviceEnableDisable); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestReinitializeDeviceEnableDisable); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetConfirmedServiceRequestReinitializeDeviceEnableDisable) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestRemoveListElement.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestRemoveListElement.go
index 2d3d270..52796fa 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestRemoveListElement.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestRemoveListElement.go
@@ -76,22 +76,19 @@ func NewBACnetConfirmedServiceRequestRemoveListElement(len uint16) *BACnetConfir
}
func CastBACnetConfirmedServiceRequestRemoveListElement(structType interface{}) *BACnetConfirmedServiceRequestRemoveListElement {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestRemoveListElement {
- if casted, ok := typ.(BACnetConfirmedServiceRequestRemoveListElement); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestRemoveListElement); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestRemoveListElement(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestRemoveListElement(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestRemoveListElement); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestRemoveListElement); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestRemoveListElement(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestRemoveListElement(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestRemoveListElement) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestRemovedAuthenticate.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestRemovedAuthenticate.go
index 15c0923..d9d61bd 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestRemovedAuthenticate.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestRemovedAuthenticate.go
@@ -76,22 +76,19 @@ func NewBACnetConfirmedServiceRequestRemovedAuthenticate(len uint16) *BACnetConf
}
func CastBACnetConfirmedServiceRequestRemovedAuthenticate(structType interface{}) *BACnetConfirmedServiceRequestRemovedAuthenticate {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestRemovedAuthenticate {
- if casted, ok := typ.(BACnetConfirmedServiceRequestRemovedAuthenticate); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestRemovedAuthenticate); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestRemovedAuthenticate(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestRemovedAuthenticate(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestRemovedAuthenticate); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestRemovedAuthenticate); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestRemovedAuthenticate(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestRemovedAuthenticate(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestRemovedAuthenticate) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestRemovedReadPropertyConditional.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestRemovedReadPropertyConditional.go
index 2bd5eee..5a96a39 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestRemovedReadPropertyConditional.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestRemovedReadPropertyConditional.go
@@ -76,22 +76,19 @@ func NewBACnetConfirmedServiceRequestRemovedReadPropertyConditional(len uint16)
}
func CastBACnetConfirmedServiceRequestRemovedReadPropertyConditional(structType interface{}) *BACnetConfirmedServiceRequestRemovedReadPropertyConditional {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestRemovedReadPropertyConditional {
- if casted, ok := typ.(BACnetConfirmedServiceRequestRemovedReadPropertyConditional); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestRemovedReadPropertyConditional); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestRemovedReadPropertyConditional(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestRemovedReadPropertyConditional(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestRemovedReadPropertyConditional); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestRemovedReadPropertyConditional); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestRemovedReadPropertyConditional(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestRemovedReadPropertyConditional(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestRemovedReadPropertyConditional) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestRemovedRequestKey.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestRemovedRequestKey.go
index 37b96f1..0646ff4 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestRemovedRequestKey.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestRemovedRequestKey.go
@@ -76,22 +76,19 @@ func NewBACnetConfirmedServiceRequestRemovedRequestKey(len uint16) *BACnetConfir
}
func CastBACnetConfirmedServiceRequestRemovedRequestKey(structType interface{}) *BACnetConfirmedServiceRequestRemovedRequestKey {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestRemovedRequestKey {
- if casted, ok := typ.(BACnetConfirmedServiceRequestRemovedRequestKey); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestRemovedRequestKey); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestRemovedRequestKey(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestRemovedRequestKey(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestRemovedRequestKey); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestRemovedRequestKey); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestRemovedRequestKey(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestRemovedRequestKey(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestRemovedRequestKey) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOV.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOV.go
index bdd031d..a80af7d 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOV.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOV.go
@@ -108,22 +108,19 @@ func NewBACnetConfirmedServiceRequestSubscribeCOV(subscriberProcessIdentifier *B
}
func CastBACnetConfirmedServiceRequestSubscribeCOV(structType interface{}) *BACnetConfirmedServiceRequestSubscribeCOV {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestSubscribeCOV {
- if casted, ok := typ.(BACnetConfirmedServiceRequestSubscribeCOV); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestSubscribeCOV); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestSubscribeCOV(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestSubscribeCOV(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestSubscribeCOV); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestSubscribeCOV); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestSubscribeCOV(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestSubscribeCOV(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestSubscribeCOV) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOVProperty.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOVProperty.go
index ed6b853..6760b12 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOVProperty.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOVProperty.go
@@ -76,22 +76,19 @@ func NewBACnetConfirmedServiceRequestSubscribeCOVProperty(len uint16) *BACnetCon
}
func CastBACnetConfirmedServiceRequestSubscribeCOVProperty(structType interface{}) *BACnetConfirmedServiceRequestSubscribeCOVProperty {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestSubscribeCOVProperty {
- if casted, ok := typ.(BACnetConfirmedServiceRequestSubscribeCOVProperty); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestSubscribeCOVProperty); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestSubscribeCOVProperty(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestSubscribeCOVProperty(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestSubscribeCOVProperty); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestSubscribeCOVProperty); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestSubscribeCOVProperty(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestSubscribeCOVProperty(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestSubscribeCOVProperty) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOVPropertyMultiple.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOVPropertyMultiple.go
index 0075656..54150ab 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOVPropertyMultiple.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestSubscribeCOVPropertyMultiple.go
@@ -76,22 +76,19 @@ func NewBACnetConfirmedServiceRequestSubscribeCOVPropertyMultiple(len uint16) *B
}
func CastBACnetConfirmedServiceRequestSubscribeCOVPropertyMultiple(structType interface{}) *BACnetConfirmedServiceRequestSubscribeCOVPropertyMultiple {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestSubscribeCOVPropertyMultiple {
- if casted, ok := typ.(BACnetConfirmedServiceRequestSubscribeCOVPropertyMultiple); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestSubscribeCOVPropertyMultiple); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestSubscribeCOVPropertyMultiple(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestSubscribeCOVPropertyMultiple(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestSubscribeCOVPropertyMultiple); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestSubscribeCOVPropertyMultiple); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestSubscribeCOVPropertyMultiple(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestSubscribeCOVPropertyMultiple(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestSubscribeCOVPropertyMultiple) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestVTClose.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestVTClose.go
index 3b39fca..f99faab 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestVTClose.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestVTClose.go
@@ -76,22 +76,19 @@ func NewBACnetConfirmedServiceRequestVTClose(len uint16) *BACnetConfirmedService
}
func CastBACnetConfirmedServiceRequestVTClose(structType interface{}) *BACnetConfirmedServiceRequestVTClose {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestVTClose {
- if casted, ok := typ.(BACnetConfirmedServiceRequestVTClose); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestVTClose); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestVTClose(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestVTClose(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestVTClose); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestVTClose); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestVTClose(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestVTClose(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestVTClose) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestVTData.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestVTData.go
index 832b86e..b92dbe1 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestVTData.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestVTData.go
@@ -76,22 +76,19 @@ func NewBACnetConfirmedServiceRequestVTData(len uint16) *BACnetConfirmedServiceR
}
func CastBACnetConfirmedServiceRequestVTData(structType interface{}) *BACnetConfirmedServiceRequestVTData {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestVTData {
- if casted, ok := typ.(BACnetConfirmedServiceRequestVTData); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestVTData); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestVTData(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestVTData(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestVTData); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestVTData); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestVTData(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestVTData(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestVTData) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestVTOpen.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestVTOpen.go
index 550af38..f258369 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestVTOpen.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestVTOpen.go
@@ -76,22 +76,19 @@ func NewBACnetConfirmedServiceRequestVTOpen(len uint16) *BACnetConfirmedServiceR
}
func CastBACnetConfirmedServiceRequestVTOpen(structType interface{}) *BACnetConfirmedServiceRequestVTOpen {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestVTOpen {
- if casted, ok := typ.(BACnetConfirmedServiceRequestVTOpen); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestVTOpen); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestVTOpen(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestVTOpen(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestVTOpen); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestVTOpen); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestVTOpen(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestVTOpen(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestVTOpen) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestWriteProperty.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestWriteProperty.go
index 654ade6..9c7039a 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestWriteProperty.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestWriteProperty.go
@@ -117,22 +117,19 @@ func NewBACnetConfirmedServiceRequestWriteProperty(objectIdentifier *BACnetConte
}
func CastBACnetConfirmedServiceRequestWriteProperty(structType interface{}) *BACnetConfirmedServiceRequestWriteProperty {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestWriteProperty {
- if casted, ok := typ.(BACnetConfirmedServiceRequestWriteProperty); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestWriteProperty); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestWriteProperty(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestWriteProperty(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestWriteProperty); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestWriteProperty); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestWriteProperty(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestWriteProperty(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestWriteProperty) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestWritePropertyMultiple.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestWritePropertyMultiple.go
index c639779..fc8ed0c 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestWritePropertyMultiple.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConfirmedServiceRequestWritePropertyMultiple.go
@@ -76,22 +76,19 @@ func NewBACnetConfirmedServiceRequestWritePropertyMultiple(len uint16) *BACnetCo
}
func CastBACnetConfirmedServiceRequestWritePropertyMultiple(structType interface{}) *BACnetConfirmedServiceRequestWritePropertyMultiple {
- castFunc := func(typ interface{}) *BACnetConfirmedServiceRequestWritePropertyMultiple {
- if casted, ok := typ.(BACnetConfirmedServiceRequestWritePropertyMultiple); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequestWritePropertyMultiple); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestWritePropertyMultiple(casted.Child)
- }
- if casted, ok := typ.(*BACnetConfirmedServiceRequest); ok {
- return CastBACnetConfirmedServiceRequestWritePropertyMultiple(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConfirmedServiceRequestWritePropertyMultiple); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequestWritePropertyMultiple); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestWritePropertyMultiple(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConfirmedServiceRequest); ok {
+ return CastBACnetConfirmedServiceRequestWritePropertyMultiple(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConfirmedServiceRequestWritePropertyMultiple) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConstructedData.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConstructedData.go
index 8fd7f0c..3771c8f 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConstructedData.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConstructedData.go
@@ -93,16 +93,13 @@ func NewBACnetConstructedData(openingTag *BACnetOpeningTag, closingTag *BACnetCl
}
func CastBACnetConstructedData(structType interface{}) *BACnetConstructedData {
- castFunc := func(typ interface{}) *BACnetConstructedData {
- if casted, ok := typ.(BACnetConstructedData); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConstructedData); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetConstructedData); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetConstructedData); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetConstructedData) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConstructedDataCommand.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConstructedDataCommand.go
index 1f85102..c3bd3dd 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConstructedDataCommand.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConstructedDataCommand.go
@@ -111,22 +111,19 @@ func NewBACnetConstructedDataCommand(innerOpeningTag *BACnetOpeningTag, action [
}
func CastBACnetConstructedDataCommand(structType interface{}) *BACnetConstructedDataCommand {
- castFunc := func(typ interface{}) *BACnetConstructedDataCommand {
- if casted, ok := typ.(BACnetConstructedDataCommand); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConstructedDataCommand); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConstructedData); ok {
- return CastBACnetConstructedDataCommand(casted.Child)
- }
- if casted, ok := typ.(*BACnetConstructedData); ok {
- return CastBACnetConstructedDataCommand(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConstructedDataCommand); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConstructedDataCommand); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConstructedData); ok {
+ return CastBACnetConstructedDataCommand(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConstructedData); ok {
+ return CastBACnetConstructedDataCommand(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConstructedDataCommand) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConstructedDataElement.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConstructedDataElement.go
index 57b4352..0bcb9b8 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConstructedDataElement.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConstructedDataElement.go
@@ -133,16 +133,13 @@ func NewBACnetConstructedDataElement(peekedTagHeader *BACnetTagHeader, applicati
}
func CastBACnetConstructedDataElement(structType interface{}) *BACnetConstructedDataElement {
- castFunc := func(typ interface{}) *BACnetConstructedDataElement {
- if casted, ok := typ.(BACnetConstructedDataElement); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConstructedDataElement); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetConstructedDataElement); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetConstructedDataElement); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetConstructedDataElement) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConstructedDataEventTimestamps.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConstructedDataEventTimestamps.go
index c3162c4..4fd04e0 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConstructedDataEventTimestamps.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConstructedDataEventTimestamps.go
@@ -111,22 +111,19 @@ func NewBACnetConstructedDataEventTimestamps(toOffnormal *BACnetContextTagTime,
}
func CastBACnetConstructedDataEventTimestamps(structType interface{}) *BACnetConstructedDataEventTimestamps {
- castFunc := func(typ interface{}) *BACnetConstructedDataEventTimestamps {
- if casted, ok := typ.(BACnetConstructedDataEventTimestamps); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConstructedDataEventTimestamps); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConstructedData); ok {
- return CastBACnetConstructedDataEventTimestamps(casted.Child)
- }
- if casted, ok := typ.(*BACnetConstructedData); ok {
- return CastBACnetConstructedDataEventTimestamps(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConstructedDataEventTimestamps); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConstructedDataEventTimestamps); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConstructedData); ok {
+ return CastBACnetConstructedDataEventTimestamps(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConstructedData); ok {
+ return CastBACnetConstructedDataEventTimestamps(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConstructedDataEventTimestamps) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConstructedDataLifeSafetyZone.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConstructedDataLifeSafetyZone.go
index e0e8d1a..5226d4f 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConstructedDataLifeSafetyZone.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConstructedDataLifeSafetyZone.go
@@ -95,22 +95,19 @@ func NewBACnetConstructedDataLifeSafetyZone(zones []*BACnetContextTagObjectIdent
}
func CastBACnetConstructedDataLifeSafetyZone(structType interface{}) *BACnetConstructedDataLifeSafetyZone {
- castFunc := func(typ interface{}) *BACnetConstructedDataLifeSafetyZone {
- if casted, ok := typ.(BACnetConstructedDataLifeSafetyZone); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConstructedDataLifeSafetyZone); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConstructedData); ok {
- return CastBACnetConstructedDataLifeSafetyZone(casted.Child)
- }
- if casted, ok := typ.(*BACnetConstructedData); ok {
- return CastBACnetConstructedDataLifeSafetyZone(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConstructedDataLifeSafetyZone); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConstructedDataLifeSafetyZone); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConstructedData); ok {
+ return CastBACnetConstructedDataLifeSafetyZone(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConstructedData); ok {
+ return CastBACnetConstructedDataLifeSafetyZone(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConstructedDataLifeSafetyZone) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConstructedDataUnspecified.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConstructedDataUnspecified.go
index 8fdb5fb..2c73d5d 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConstructedDataUnspecified.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetConstructedDataUnspecified.go
@@ -121,22 +121,19 @@ func NewBACnetConstructedDataUnspecified(data []*BACnetConstructedDataElement, p
}
func CastBACnetConstructedDataUnspecified(structType interface{}) *BACnetConstructedDataUnspecified {
- castFunc := func(typ interface{}) *BACnetConstructedDataUnspecified {
- if casted, ok := typ.(BACnetConstructedDataUnspecified); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetConstructedDataUnspecified); ok {
- return casted
- }
- if casted, ok := typ.(BACnetConstructedData); ok {
- return CastBACnetConstructedDataUnspecified(casted.Child)
- }
- if casted, ok := typ.(*BACnetConstructedData); ok {
- return CastBACnetConstructedDataUnspecified(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetConstructedDataUnspecified); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetConstructedDataUnspecified); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetConstructedData); ok {
+ return CastBACnetConstructedDataUnspecified(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetConstructedData); ok {
+ return CastBACnetConstructedDataUnspecified(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetConstructedDataUnspecified) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTag.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTag.go
index e20b442..f02781b 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTag.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTag.go
@@ -95,16 +95,13 @@ func NewBACnetContextTag(header *BACnetTagHeader, tagNumberArgument uint8) *BACn
}
func CastBACnetContextTag(structType interface{}) *BACnetContextTag {
- castFunc := func(typ interface{}) *BACnetContextTag {
- if casted, ok := typ.(BACnetContextTag); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetContextTag); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetContextTag); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetContextTag); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetContextTag) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagBitString.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagBitString.go
index 2f52b31..41b7c34 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagBitString.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagBitString.go
@@ -86,22 +86,19 @@ func NewBACnetContextTagBitString(payload *BACnetTagPayloadBitString, header *BA
}
func CastBACnetContextTagBitString(structType interface{}) *BACnetContextTagBitString {
- castFunc := func(typ interface{}) *BACnetContextTagBitString {
- if casted, ok := typ.(BACnetContextTagBitString); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetContextTagBitString); ok {
- return casted
- }
- if casted, ok := typ.(BACnetContextTag); ok {
- return CastBACnetContextTagBitString(casted.Child)
- }
- if casted, ok := typ.(*BACnetContextTag); ok {
- return CastBACnetContextTagBitString(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetContextTagBitString); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetContextTagBitString); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetContextTag); ok {
+ return CastBACnetContextTagBitString(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetContextTag); ok {
+ return CastBACnetContextTagBitString(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetContextTagBitString) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagBoolean.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagBoolean.go
index 5db0e54..fd281d5 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagBoolean.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagBoolean.go
@@ -99,22 +99,19 @@ func NewBACnetContextTagBoolean(value uint8, payload *BACnetTagPayloadBoolean, h
}
func CastBACnetContextTagBoolean(structType interface{}) *BACnetContextTagBoolean {
- castFunc := func(typ interface{}) *BACnetContextTagBoolean {
- if casted, ok := typ.(BACnetContextTagBoolean); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetContextTagBoolean); ok {
- return casted
- }
- if casted, ok := typ.(BACnetContextTag); ok {
- return CastBACnetContextTagBoolean(casted.Child)
- }
- if casted, ok := typ.(*BACnetContextTag); ok {
- return CastBACnetContextTagBoolean(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetContextTagBoolean); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetContextTagBoolean); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetContextTag); ok {
+ return CastBACnetContextTagBoolean(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetContextTag); ok {
+ return CastBACnetContextTagBoolean(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetContextTagBoolean) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagCharacterString.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagCharacterString.go
index 24f5293..e605484 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagCharacterString.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagCharacterString.go
@@ -86,22 +86,19 @@ func NewBACnetContextTagCharacterString(payload *BACnetTagPayloadCharacterString
}
func CastBACnetContextTagCharacterString(structType interface{}) *BACnetContextTagCharacterString {
- castFunc := func(typ interface{}) *BACnetContextTagCharacterString {
- if casted, ok := typ.(BACnetContextTagCharacterString); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetContextTagCharacterString); ok {
- return casted
- }
- if casted, ok := typ.(BACnetContextTag); ok {
- return CastBACnetContextTagCharacterString(casted.Child)
- }
- if casted, ok := typ.(*BACnetContextTag); ok {
- return CastBACnetContextTagCharacterString(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetContextTagCharacterString); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetContextTagCharacterString); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetContextTag); ok {
+ return CastBACnetContextTagCharacterString(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetContextTag); ok {
+ return CastBACnetContextTagCharacterString(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetContextTagCharacterString) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagDate.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagDate.go
index ecbd9da..bb29370 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagDate.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagDate.go
@@ -86,22 +86,19 @@ func NewBACnetContextTagDate(payload *BACnetTagPayloadDate, header *BACnetTagHea
}
func CastBACnetContextTagDate(structType interface{}) *BACnetContextTagDate {
- castFunc := func(typ interface{}) *BACnetContextTagDate {
- if casted, ok := typ.(BACnetContextTagDate); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetContextTagDate); ok {
- return casted
- }
- if casted, ok := typ.(BACnetContextTag); ok {
- return CastBACnetContextTagDate(casted.Child)
- }
- if casted, ok := typ.(*BACnetContextTag); ok {
- return CastBACnetContextTagDate(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetContextTagDate); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetContextTagDate); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetContextTag); ok {
+ return CastBACnetContextTagDate(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetContextTag); ok {
+ return CastBACnetContextTagDate(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetContextTagDate) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagDeviceState.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagDeviceState.go
index 3b0622b..4ef423d 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagDeviceState.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagDeviceState.go
@@ -86,22 +86,19 @@ func NewBACnetContextTagDeviceState(state BACnetDeviceState, header *BACnetTagHe
}
func CastBACnetContextTagDeviceState(structType interface{}) *BACnetContextTagDeviceState {
- castFunc := func(typ interface{}) *BACnetContextTagDeviceState {
- if casted, ok := typ.(BACnetContextTagDeviceState); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetContextTagDeviceState); ok {
- return casted
- }
- if casted, ok := typ.(BACnetContextTag); ok {
- return CastBACnetContextTagDeviceState(casted.Child)
- }
- if casted, ok := typ.(*BACnetContextTag); ok {
- return CastBACnetContextTagDeviceState(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetContextTagDeviceState); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetContextTagDeviceState); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetContextTag); ok {
+ return CastBACnetContextTagDeviceState(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetContextTag); ok {
+ return CastBACnetContextTagDeviceState(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetContextTagDeviceState) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagDouble.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagDouble.go
index 0b38927..cc43f9e 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagDouble.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagDouble.go
@@ -91,22 +91,19 @@ func NewBACnetContextTagDouble(payload *BACnetTagPayloadDouble, header *BACnetTa
}
func CastBACnetContextTagDouble(structType interface{}) *BACnetContextTagDouble {
- castFunc := func(typ interface{}) *BACnetContextTagDouble {
- if casted, ok := typ.(BACnetContextTagDouble); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetContextTagDouble); ok {
- return casted
- }
- if casted, ok := typ.(BACnetContextTag); ok {
- return CastBACnetContextTagDouble(casted.Child)
- }
- if casted, ok := typ.(*BACnetContextTag); ok {
- return CastBACnetContextTagDouble(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetContextTagDouble); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetContextTagDouble); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetContextTag); ok {
+ return CastBACnetContextTagDouble(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetContextTag); ok {
+ return CastBACnetContextTagDouble(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetContextTagDouble) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagEmpty.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagEmpty.go
index fbaefba..57c0472 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagEmpty.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagEmpty.go
@@ -77,22 +77,19 @@ func NewBACnetContextTagEmpty(header *BACnetTagHeader, tagNumberArgument uint8)
}
func CastBACnetContextTagEmpty(structType interface{}) *BACnetContextTagEmpty {
- castFunc := func(typ interface{}) *BACnetContextTagEmpty {
- if casted, ok := typ.(BACnetContextTagEmpty); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetContextTagEmpty); ok {
- return casted
- }
- if casted, ok := typ.(BACnetContextTag); ok {
- return CastBACnetContextTagEmpty(casted.Child)
- }
- if casted, ok := typ.(*BACnetContextTag); ok {
- return CastBACnetContextTagEmpty(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetContextTagEmpty); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetContextTagEmpty); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetContextTag); ok {
+ return CastBACnetContextTagEmpty(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetContextTag); ok {
+ return CastBACnetContextTagEmpty(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetContextTagEmpty) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagEnumerated.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagEnumerated.go
index 8e0f823..283d902 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagEnumerated.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagEnumerated.go
@@ -91,22 +91,19 @@ func NewBACnetContextTagEnumerated(payload *BACnetTagPayloadEnumerated, header *
}
func CastBACnetContextTagEnumerated(structType interface{}) *BACnetContextTagEnumerated {
- castFunc := func(typ interface{}) *BACnetContextTagEnumerated {
- if casted, ok := typ.(BACnetContextTagEnumerated); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetContextTagEnumerated); ok {
- return casted
- }
- if casted, ok := typ.(BACnetContextTag); ok {
- return CastBACnetContextTagEnumerated(casted.Child)
- }
- if casted, ok := typ.(*BACnetContextTag); ok {
- return CastBACnetContextTagEnumerated(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetContextTagEnumerated); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetContextTagEnumerated); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetContextTag); ok {
+ return CastBACnetContextTagEnumerated(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetContextTag); ok {
+ return CastBACnetContextTagEnumerated(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetContextTagEnumerated) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagEventState.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagEventState.go
index a44f92c..5fb3959 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagEventState.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagEventState.go
@@ -100,22 +100,19 @@ func NewBACnetContextTagEventState(eventState BACnetEventState, proprietaryValue
}
func CastBACnetContextTagEventState(structType interface{}) *BACnetContextTagEventState {
- castFunc := func(typ interface{}) *BACnetContextTagEventState {
- if casted, ok := typ.(BACnetContextTagEventState); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetContextTagEventState); ok {
- return casted
- }
- if casted, ok := typ.(BACnetContextTag); ok {
- return CastBACnetContextTagEventState(casted.Child)
- }
- if casted, ok := typ.(*BACnetContextTag); ok {
- return CastBACnetContextTagEventState(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetContextTagEventState); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetContextTagEventState); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetContextTag); ok {
+ return CastBACnetContextTagEventState(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetContextTag); ok {
+ return CastBACnetContextTagEventState(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetContextTagEventState) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagEventType.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagEventType.go
index ed9eb61..e395302 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagEventType.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagEventType.go
@@ -100,22 +100,19 @@ func NewBACnetContextTagEventType(eventType BACnetEventType, proprietaryValue ui
}
func CastBACnetContextTagEventType(structType interface{}) *BACnetContextTagEventType {
- castFunc := func(typ interface{}) *BACnetContextTagEventType {
- if casted, ok := typ.(BACnetContextTagEventType); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetContextTagEventType); ok {
- return casted
- }
- if casted, ok := typ.(BACnetContextTag); ok {
- return CastBACnetContextTagEventType(casted.Child)
- }
- if casted, ok := typ.(*BACnetContextTag); ok {
- return CastBACnetContextTagEventType(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetContextTagEventType); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetContextTagEventType); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetContextTag); ok {
+ return CastBACnetContextTagEventType(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetContextTag); ok {
+ return CastBACnetContextTagEventType(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetContextTagEventType) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagNotifyType.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagNotifyType.go
index 38da2ef..d94137a 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagNotifyType.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagNotifyType.go
@@ -87,22 +87,19 @@ func NewBACnetContextTagNotifyType(value BACnetNotifyType, header *BACnetTagHead
}
func CastBACnetContextTagNotifyType(structType interface{}) *BACnetContextTagNotifyType {
- castFunc := func(typ interface{}) *BACnetContextTagNotifyType {
- if casted, ok := typ.(BACnetContextTagNotifyType); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetContextTagNotifyType); ok {
- return casted
- }
- if casted, ok := typ.(BACnetContextTag); ok {
- return CastBACnetContextTagNotifyType(casted.Child)
- }
- if casted, ok := typ.(*BACnetContextTag); ok {
- return CastBACnetContextTagNotifyType(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetContextTagNotifyType); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetContextTagNotifyType); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetContextTag); ok {
+ return CastBACnetContextTagNotifyType(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetContextTag); ok {
+ return CastBACnetContextTagNotifyType(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetContextTagNotifyType) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagObjectIdentifier.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagObjectIdentifier.go
index 4c5175f..1f00c0d 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagObjectIdentifier.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagObjectIdentifier.go
@@ -97,22 +97,19 @@ func NewBACnetContextTagObjectIdentifier(payload *BACnetTagPayloadObjectIdentifi
}
func CastBACnetContextTagObjectIdentifier(structType interface{}) *BACnetContextTagObjectIdentifier {
- castFunc := func(typ interface{}) *BACnetContextTagObjectIdentifier {
- if casted, ok := typ.(BACnetContextTagObjectIdentifier); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetContextTagObjectIdentifier); ok {
- return casted
- }
- if casted, ok := typ.(BACnetContextTag); ok {
- return CastBACnetContextTagObjectIdentifier(casted.Child)
- }
- if casted, ok := typ.(*BACnetContextTag); ok {
- return CastBACnetContextTagObjectIdentifier(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetContextTagObjectIdentifier); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetContextTagObjectIdentifier); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetContextTag); ok {
+ return CastBACnetContextTagObjectIdentifier(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetContextTag); ok {
+ return CastBACnetContextTagObjectIdentifier(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetContextTagObjectIdentifier) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagOctetString.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagOctetString.go
index 9c6aee2..0c3ca63 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagOctetString.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagOctetString.go
@@ -86,22 +86,19 @@ func NewBACnetContextTagOctetString(payload *BACnetTagPayloadOctetString, header
}
func CastBACnetContextTagOctetString(structType interface{}) *BACnetContextTagOctetString {
- castFunc := func(typ interface{}) *BACnetContextTagOctetString {
- if casted, ok := typ.(BACnetContextTagOctetString); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetContextTagOctetString); ok {
- return casted
- }
- if casted, ok := typ.(BACnetContextTag); ok {
- return CastBACnetContextTagOctetString(casted.Child)
- }
- if casted, ok := typ.(*BACnetContextTag); ok {
- return CastBACnetContextTagOctetString(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetContextTagOctetString); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetContextTagOctetString); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetContextTag); ok {
+ return CastBACnetContextTagOctetString(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetContextTag); ok {
+ return CastBACnetContextTagOctetString(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetContextTagOctetString) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagPropertyIdentifier.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagPropertyIdentifier.go
index 57fddae..96ec68c 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagPropertyIdentifier.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagPropertyIdentifier.go
@@ -100,22 +100,19 @@ func NewBACnetContextTagPropertyIdentifier(propertyIdentifier BACnetPropertyIden
}
func CastBACnetContextTagPropertyIdentifier(structType interface{}) *BACnetContextTagPropertyIdentifier {
- castFunc := func(typ interface{}) *BACnetContextTagPropertyIdentifier {
- if casted, ok := typ.(BACnetContextTagPropertyIdentifier); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetContextTagPropertyIdentifier); ok {
- return casted
- }
- if casted, ok := typ.(BACnetContextTag); ok {
- return CastBACnetContextTagPropertyIdentifier(casted.Child)
- }
- if casted, ok := typ.(*BACnetContextTag); ok {
- return CastBACnetContextTagPropertyIdentifier(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetContextTagPropertyIdentifier); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetContextTagPropertyIdentifier); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetContextTag); ok {
+ return CastBACnetContextTagPropertyIdentifier(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetContextTag); ok {
+ return CastBACnetContextTagPropertyIdentifier(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetContextTagPropertyIdentifier) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagReal.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagReal.go
index 5adfbec..6bf608a 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagReal.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagReal.go
@@ -91,22 +91,19 @@ func NewBACnetContextTagReal(payload *BACnetTagPayloadReal, header *BACnetTagHea
}
func CastBACnetContextTagReal(structType interface{}) *BACnetContextTagReal {
- castFunc := func(typ interface{}) *BACnetContextTagReal {
- if casted, ok := typ.(BACnetContextTagReal); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetContextTagReal); ok {
- return casted
- }
- if casted, ok := typ.(BACnetContextTag); ok {
- return CastBACnetContextTagReal(casted.Child)
- }
- if casted, ok := typ.(*BACnetContextTag); ok {
- return CastBACnetContextTagReal(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetContextTagReal); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetContextTagReal); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetContextTag); ok {
+ return CastBACnetContextTagReal(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetContextTag); ok {
+ return CastBACnetContextTagReal(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetContextTagReal) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagSignedInteger.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagSignedInteger.go
index 95d4653..73d1c6a 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagSignedInteger.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagSignedInteger.go
@@ -91,22 +91,19 @@ func NewBACnetContextTagSignedInteger(payload *BACnetTagPayloadSignedInteger, he
}
func CastBACnetContextTagSignedInteger(structType interface{}) *BACnetContextTagSignedInteger {
- castFunc := func(typ interface{}) *BACnetContextTagSignedInteger {
- if casted, ok := typ.(BACnetContextTagSignedInteger); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetContextTagSignedInteger); ok {
- return casted
- }
- if casted, ok := typ.(BACnetContextTag); ok {
- return CastBACnetContextTagSignedInteger(casted.Child)
- }
- if casted, ok := typ.(*BACnetContextTag); ok {
- return CastBACnetContextTagSignedInteger(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetContextTagSignedInteger); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetContextTagSignedInteger); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetContextTag); ok {
+ return CastBACnetContextTagSignedInteger(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetContextTag); ok {
+ return CastBACnetContextTagSignedInteger(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetContextTagSignedInteger) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagTime.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagTime.go
index 36f2326..816c277 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagTime.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagTime.go
@@ -86,22 +86,19 @@ func NewBACnetContextTagTime(payload *BACnetTagPayloadTime, header *BACnetTagHea
}
func CastBACnetContextTagTime(structType interface{}) *BACnetContextTagTime {
- castFunc := func(typ interface{}) *BACnetContextTagTime {
- if casted, ok := typ.(BACnetContextTagTime); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetContextTagTime); ok {
- return casted
- }
- if casted, ok := typ.(BACnetContextTag); ok {
- return CastBACnetContextTagTime(casted.Child)
- }
- if casted, ok := typ.(*BACnetContextTag); ok {
- return CastBACnetContextTagTime(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetContextTagTime); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetContextTagTime); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetContextTag); ok {
+ return CastBACnetContextTagTime(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetContextTag); ok {
+ return CastBACnetContextTagTime(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetContextTagTime) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagUnsignedInteger.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagUnsignedInteger.go
index 105d86f..97da873 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagUnsignedInteger.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetContextTagUnsignedInteger.go
@@ -91,22 +91,19 @@ func NewBACnetContextTagUnsignedInteger(payload *BACnetTagPayloadUnsignedInteger
}
func CastBACnetContextTagUnsignedInteger(structType interface{}) *BACnetContextTagUnsignedInteger {
- castFunc := func(typ interface{}) *BACnetContextTagUnsignedInteger {
- if casted, ok := typ.(BACnetContextTagUnsignedInteger); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetContextTagUnsignedInteger); ok {
- return casted
- }
- if casted, ok := typ.(BACnetContextTag); ok {
- return CastBACnetContextTagUnsignedInteger(casted.Child)
- }
- if casted, ok := typ.(*BACnetContextTag); ok {
- return CastBACnetContextTagUnsignedInteger(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetContextTagUnsignedInteger); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetContextTagUnsignedInteger); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetContextTag); ok {
+ return CastBACnetContextTagUnsignedInteger(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetContextTag); ok {
+ return CastBACnetContextTagUnsignedInteger(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetContextTagUnsignedInteger) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetDateTime.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetDateTime.go
index 7534a04..5d095f8 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetDateTime.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetDateTime.go
@@ -84,16 +84,13 @@ func NewBACnetDateTime(openingTag *BACnetOpeningTag, dateValue *BACnetApplicatio
}
func CastBACnetDateTime(structType interface{}) *BACnetDateTime {
- castFunc := func(typ interface{}) *BACnetDateTime {
- if casted, ok := typ.(BACnetDateTime); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetDateTime); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetDateTime); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetDateTime); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetDateTime) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetDeviceObjectPropertyReference.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetDeviceObjectPropertyReference.go
index e8f37ac..22e090c 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetDeviceObjectPropertyReference.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetDeviceObjectPropertyReference.go
@@ -99,16 +99,13 @@ func NewBACnetDeviceObjectPropertyReference(openingTag *BACnetOpeningTag, object
}
func CastBACnetDeviceObjectPropertyReference(structType interface{}) *BACnetDeviceObjectPropertyReference {
- castFunc := func(typ interface{}) *BACnetDeviceObjectPropertyReference {
- if casted, ok := typ.(BACnetDeviceObjectPropertyReference); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetDeviceObjectPropertyReference); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetDeviceObjectPropertyReference); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetDeviceObjectPropertyReference); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetDeviceObjectPropertyReference) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetError.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetError.go
index f7997d6..c9aef4e 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetError.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetError.go
@@ -82,16 +82,13 @@ func NewBACnetError(errorClass *BACnetApplicationTagEnumerated, errorCode *BACne
}
func CastBACnetError(structType interface{}) *BACnetError {
- castFunc := func(typ interface{}) *BACnetError {
- if casted, ok := typ.(BACnetError); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetError); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetError); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetError); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetError) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorAcknowledgeAlarm.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorAcknowledgeAlarm.go
index 1536ddc..6f9d1dc 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorAcknowledgeAlarm.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorAcknowledgeAlarm.go
@@ -75,22 +75,19 @@ func NewBACnetErrorAcknowledgeAlarm(errorClass *BACnetApplicationTagEnumerated,
}
func CastBACnetErrorAcknowledgeAlarm(structType interface{}) *BACnetErrorAcknowledgeAlarm {
- castFunc := func(typ interface{}) *BACnetErrorAcknowledgeAlarm {
- if casted, ok := typ.(BACnetErrorAcknowledgeAlarm); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetErrorAcknowledgeAlarm); ok {
- return casted
- }
- if casted, ok := typ.(BACnetError); ok {
- return CastBACnetErrorAcknowledgeAlarm(casted.Child)
- }
- if casted, ok := typ.(*BACnetError); ok {
- return CastBACnetErrorAcknowledgeAlarm(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetErrorAcknowledgeAlarm); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetErrorAcknowledgeAlarm); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetError); ok {
+ return CastBACnetErrorAcknowledgeAlarm(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetError); ok {
+ return CastBACnetErrorAcknowledgeAlarm(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetErrorAcknowledgeAlarm) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorAtomicReadFile.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorAtomicReadFile.go
index 89e3ded..d20dd72 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorAtomicReadFile.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorAtomicReadFile.go
@@ -75,22 +75,19 @@ func NewBACnetErrorAtomicReadFile(errorClass *BACnetApplicationTagEnumerated, er
}
func CastBACnetErrorAtomicReadFile(structType interface{}) *BACnetErrorAtomicReadFile {
- castFunc := func(typ interface{}) *BACnetErrorAtomicReadFile {
- if casted, ok := typ.(BACnetErrorAtomicReadFile); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetErrorAtomicReadFile); ok {
- return casted
- }
- if casted, ok := typ.(BACnetError); ok {
- return CastBACnetErrorAtomicReadFile(casted.Child)
- }
- if casted, ok := typ.(*BACnetError); ok {
- return CastBACnetErrorAtomicReadFile(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetErrorAtomicReadFile); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetErrorAtomicReadFile); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetError); ok {
+ return CastBACnetErrorAtomicReadFile(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetError); ok {
+ return CastBACnetErrorAtomicReadFile(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetErrorAtomicReadFile) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorAtomicWriteFile.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorAtomicWriteFile.go
index 253b7d8..10b71ca 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorAtomicWriteFile.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorAtomicWriteFile.go
@@ -75,22 +75,19 @@ func NewBACnetErrorAtomicWriteFile(errorClass *BACnetApplicationTagEnumerated, e
}
func CastBACnetErrorAtomicWriteFile(structType interface{}) *BACnetErrorAtomicWriteFile {
- castFunc := func(typ interface{}) *BACnetErrorAtomicWriteFile {
- if casted, ok := typ.(BACnetErrorAtomicWriteFile); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetErrorAtomicWriteFile); ok {
- return casted
- }
- if casted, ok := typ.(BACnetError); ok {
- return CastBACnetErrorAtomicWriteFile(casted.Child)
- }
- if casted, ok := typ.(*BACnetError); ok {
- return CastBACnetErrorAtomicWriteFile(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetErrorAtomicWriteFile); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetErrorAtomicWriteFile); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetError); ok {
+ return CastBACnetErrorAtomicWriteFile(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetError); ok {
+ return CastBACnetErrorAtomicWriteFile(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetErrorAtomicWriteFile) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorConfirmedEventNotification.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorConfirmedEventNotification.go
index 7f70974..71a5a71 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorConfirmedEventNotification.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorConfirmedEventNotification.go
@@ -75,22 +75,19 @@ func NewBACnetErrorConfirmedEventNotification(errorClass *BACnetApplicationTagEn
}
func CastBACnetErrorConfirmedEventNotification(structType interface{}) *BACnetErrorConfirmedEventNotification {
- castFunc := func(typ interface{}) *BACnetErrorConfirmedEventNotification {
- if casted, ok := typ.(BACnetErrorConfirmedEventNotification); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetErrorConfirmedEventNotification); ok {
- return casted
- }
- if casted, ok := typ.(BACnetError); ok {
- return CastBACnetErrorConfirmedEventNotification(casted.Child)
- }
- if casted, ok := typ.(*BACnetError); ok {
- return CastBACnetErrorConfirmedEventNotification(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetErrorConfirmedEventNotification); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetErrorConfirmedEventNotification); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetError); ok {
+ return CastBACnetErrorConfirmedEventNotification(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetError); ok {
+ return CastBACnetErrorConfirmedEventNotification(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetErrorConfirmedEventNotification) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorConfirmedPrivateTransfer.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorConfirmedPrivateTransfer.go
index 4e2fe64..7c5f995 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorConfirmedPrivateTransfer.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorConfirmedPrivateTransfer.go
@@ -75,22 +75,19 @@ func NewBACnetErrorConfirmedPrivateTransfer(errorClass *BACnetApplicationTagEnum
}
func CastBACnetErrorConfirmedPrivateTransfer(structType interface{}) *BACnetErrorConfirmedPrivateTransfer {
- castFunc := func(typ interface{}) *BACnetErrorConfirmedPrivateTransfer {
- if casted, ok := typ.(BACnetErrorConfirmedPrivateTransfer); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetErrorConfirmedPrivateTransfer); ok {
- return casted
- }
- if casted, ok := typ.(BACnetError); ok {
- return CastBACnetErrorConfirmedPrivateTransfer(casted.Child)
- }
- if casted, ok := typ.(*BACnetError); ok {
- return CastBACnetErrorConfirmedPrivateTransfer(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetErrorConfirmedPrivateTransfer); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetErrorConfirmedPrivateTransfer); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetError); ok {
+ return CastBACnetErrorConfirmedPrivateTransfer(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetError); ok {
+ return CastBACnetErrorConfirmedPrivateTransfer(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetErrorConfirmedPrivateTransfer) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorCreateObject.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorCreateObject.go
index b552d5c..7aed63c 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorCreateObject.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorCreateObject.go
@@ -75,22 +75,19 @@ func NewBACnetErrorCreateObject(errorClass *BACnetApplicationTagEnumerated, erro
}
func CastBACnetErrorCreateObject(structType interface{}) *BACnetErrorCreateObject {
- castFunc := func(typ interface{}) *BACnetErrorCreateObject {
- if casted, ok := typ.(BACnetErrorCreateObject); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetErrorCreateObject); ok {
- return casted
- }
- if casted, ok := typ.(BACnetError); ok {
- return CastBACnetErrorCreateObject(casted.Child)
- }
- if casted, ok := typ.(*BACnetError); ok {
- return CastBACnetErrorCreateObject(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetErrorCreateObject); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetErrorCreateObject); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetError); ok {
+ return CastBACnetErrorCreateObject(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetError); ok {
+ return CastBACnetErrorCreateObject(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetErrorCreateObject) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorDeviceCommunicationProtocol.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorDeviceCommunicationProtocol.go
index 6422c52..fca4b63 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorDeviceCommunicationProtocol.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorDeviceCommunicationProtocol.go
@@ -75,22 +75,19 @@ func NewBACnetErrorDeviceCommunicationProtocol(errorClass *BACnetApplicationTagE
}
func CastBACnetErrorDeviceCommunicationProtocol(structType interface{}) *BACnetErrorDeviceCommunicationProtocol {
- castFunc := func(typ interface{}) *BACnetErrorDeviceCommunicationProtocol {
- if casted, ok := typ.(BACnetErrorDeviceCommunicationProtocol); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetErrorDeviceCommunicationProtocol); ok {
- return casted
- }
- if casted, ok := typ.(BACnetError); ok {
- return CastBACnetErrorDeviceCommunicationProtocol(casted.Child)
- }
- if casted, ok := typ.(*BACnetError); ok {
- return CastBACnetErrorDeviceCommunicationProtocol(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetErrorDeviceCommunicationProtocol); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetErrorDeviceCommunicationProtocol); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetError); ok {
+ return CastBACnetErrorDeviceCommunicationProtocol(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetError); ok {
+ return CastBACnetErrorDeviceCommunicationProtocol(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetErrorDeviceCommunicationProtocol) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorGetAlarmSummary.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorGetAlarmSummary.go
index b3dd7dd..a909fe2 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorGetAlarmSummary.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorGetAlarmSummary.go
@@ -75,22 +75,19 @@ func NewBACnetErrorGetAlarmSummary(errorClass *BACnetApplicationTagEnumerated, e
}
func CastBACnetErrorGetAlarmSummary(structType interface{}) *BACnetErrorGetAlarmSummary {
- castFunc := func(typ interface{}) *BACnetErrorGetAlarmSummary {
- if casted, ok := typ.(BACnetErrorGetAlarmSummary); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetErrorGetAlarmSummary); ok {
- return casted
- }
- if casted, ok := typ.(BACnetError); ok {
- return CastBACnetErrorGetAlarmSummary(casted.Child)
- }
- if casted, ok := typ.(*BACnetError); ok {
- return CastBACnetErrorGetAlarmSummary(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetErrorGetAlarmSummary); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetErrorGetAlarmSummary); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetError); ok {
+ return CastBACnetErrorGetAlarmSummary(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetError); ok {
+ return CastBACnetErrorGetAlarmSummary(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetErrorGetAlarmSummary) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorGetEnrollmentSummary.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorGetEnrollmentSummary.go
index 45c4fa5..7dff4c1 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorGetEnrollmentSummary.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorGetEnrollmentSummary.go
@@ -75,22 +75,19 @@ func NewBACnetErrorGetEnrollmentSummary(errorClass *BACnetApplicationTagEnumerat
}
func CastBACnetErrorGetEnrollmentSummary(structType interface{}) *BACnetErrorGetEnrollmentSummary {
- castFunc := func(typ interface{}) *BACnetErrorGetEnrollmentSummary {
- if casted, ok := typ.(BACnetErrorGetEnrollmentSummary); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetErrorGetEnrollmentSummary); ok {
- return casted
- }
- if casted, ok := typ.(BACnetError); ok {
- return CastBACnetErrorGetEnrollmentSummary(casted.Child)
- }
- if casted, ok := typ.(*BACnetError); ok {
- return CastBACnetErrorGetEnrollmentSummary(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetErrorGetEnrollmentSummary); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetErrorGetEnrollmentSummary); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetError); ok {
+ return CastBACnetErrorGetEnrollmentSummary(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetError); ok {
+ return CastBACnetErrorGetEnrollmentSummary(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetErrorGetEnrollmentSummary) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorGetEventInformation.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorGetEventInformation.go
index 4e1d57b..4814954 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorGetEventInformation.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorGetEventInformation.go
@@ -75,22 +75,19 @@ func NewBACnetErrorGetEventInformation(errorClass *BACnetApplicationTagEnumerate
}
func CastBACnetErrorGetEventInformation(structType interface{}) *BACnetErrorGetEventInformation {
- castFunc := func(typ interface{}) *BACnetErrorGetEventInformation {
- if casted, ok := typ.(BACnetErrorGetEventInformation); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetErrorGetEventInformation); ok {
- return casted
- }
- if casted, ok := typ.(BACnetError); ok {
- return CastBACnetErrorGetEventInformation(casted.Child)
- }
- if casted, ok := typ.(*BACnetError); ok {
- return CastBACnetErrorGetEventInformation(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetErrorGetEventInformation); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetErrorGetEventInformation); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetError); ok {
+ return CastBACnetErrorGetEventInformation(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetError); ok {
+ return CastBACnetErrorGetEventInformation(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetErrorGetEventInformation) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorPasswordFailure.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorPasswordFailure.go
index ca9cf4b..55cbc63 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorPasswordFailure.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorPasswordFailure.go
@@ -75,22 +75,19 @@ func NewBACnetErrorPasswordFailure(errorClass *BACnetApplicationTagEnumerated, e
}
func CastBACnetErrorPasswordFailure(structType interface{}) *BACnetErrorPasswordFailure {
- castFunc := func(typ interface{}) *BACnetErrorPasswordFailure {
- if casted, ok := typ.(BACnetErrorPasswordFailure); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetErrorPasswordFailure); ok {
- return casted
- }
- if casted, ok := typ.(BACnetError); ok {
- return CastBACnetErrorPasswordFailure(casted.Child)
- }
- if casted, ok := typ.(*BACnetError); ok {
- return CastBACnetErrorPasswordFailure(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetErrorPasswordFailure); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetErrorPasswordFailure); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetError); ok {
+ return CastBACnetErrorPasswordFailure(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetError); ok {
+ return CastBACnetErrorPasswordFailure(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetErrorPasswordFailure) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorReadProperty.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorReadProperty.go
index 479e68b..8fc8217 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorReadProperty.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorReadProperty.go
@@ -75,22 +75,19 @@ func NewBACnetErrorReadProperty(errorClass *BACnetApplicationTagEnumerated, erro
}
func CastBACnetErrorReadProperty(structType interface{}) *BACnetErrorReadProperty {
- castFunc := func(typ interface{}) *BACnetErrorReadProperty {
- if casted, ok := typ.(BACnetErrorReadProperty); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetErrorReadProperty); ok {
- return casted
- }
- if casted, ok := typ.(BACnetError); ok {
- return CastBACnetErrorReadProperty(casted.Child)
- }
- if casted, ok := typ.(*BACnetError); ok {
- return CastBACnetErrorReadProperty(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetErrorReadProperty); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetErrorReadProperty); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetError); ok {
+ return CastBACnetErrorReadProperty(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetError); ok {
+ return CastBACnetErrorReadProperty(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetErrorReadProperty) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorReadPropertyMultiple.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorReadPropertyMultiple.go
index 5acc34f..433a1c4 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorReadPropertyMultiple.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorReadPropertyMultiple.go
@@ -75,22 +75,19 @@ func NewBACnetErrorReadPropertyMultiple(errorClass *BACnetApplicationTagEnumerat
}
func CastBACnetErrorReadPropertyMultiple(structType interface{}) *BACnetErrorReadPropertyMultiple {
- castFunc := func(typ interface{}) *BACnetErrorReadPropertyMultiple {
- if casted, ok := typ.(BACnetErrorReadPropertyMultiple); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetErrorReadPropertyMultiple); ok {
- return casted
- }
- if casted, ok := typ.(BACnetError); ok {
- return CastBACnetErrorReadPropertyMultiple(casted.Child)
- }
- if casted, ok := typ.(*BACnetError); ok {
- return CastBACnetErrorReadPropertyMultiple(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetErrorReadPropertyMultiple); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetErrorReadPropertyMultiple); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetError); ok {
+ return CastBACnetErrorReadPropertyMultiple(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetError); ok {
+ return CastBACnetErrorReadPropertyMultiple(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetErrorReadPropertyMultiple) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorReadRange.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorReadRange.go
index 1ad9edc..fcf535f 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorReadRange.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorReadRange.go
@@ -75,22 +75,19 @@ func NewBACnetErrorReadRange(errorClass *BACnetApplicationTagEnumerated, errorCo
}
func CastBACnetErrorReadRange(structType interface{}) *BACnetErrorReadRange {
- castFunc := func(typ interface{}) *BACnetErrorReadRange {
- if casted, ok := typ.(BACnetErrorReadRange); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetErrorReadRange); ok {
- return casted
- }
- if casted, ok := typ.(BACnetError); ok {
- return CastBACnetErrorReadRange(casted.Child)
- }
- if casted, ok := typ.(*BACnetError); ok {
- return CastBACnetErrorReadRange(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetErrorReadRange); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetErrorReadRange); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetError); ok {
+ return CastBACnetErrorReadRange(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetError); ok {
+ return CastBACnetErrorReadRange(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetErrorReadRange) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorRemovedAuthenticate.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorRemovedAuthenticate.go
index e612c7b..6d4bb82 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorRemovedAuthenticate.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorRemovedAuthenticate.go
@@ -75,22 +75,19 @@ func NewBACnetErrorRemovedAuthenticate(errorClass *BACnetApplicationTagEnumerate
}
func CastBACnetErrorRemovedAuthenticate(structType interface{}) *BACnetErrorRemovedAuthenticate {
- castFunc := func(typ interface{}) *BACnetErrorRemovedAuthenticate {
- if casted, ok := typ.(BACnetErrorRemovedAuthenticate); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetErrorRemovedAuthenticate); ok {
- return casted
- }
- if casted, ok := typ.(BACnetError); ok {
- return CastBACnetErrorRemovedAuthenticate(casted.Child)
- }
- if casted, ok := typ.(*BACnetError); ok {
- return CastBACnetErrorRemovedAuthenticate(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetErrorRemovedAuthenticate); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetErrorRemovedAuthenticate); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetError); ok {
+ return CastBACnetErrorRemovedAuthenticate(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetError); ok {
+ return CastBACnetErrorRemovedAuthenticate(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetErrorRemovedAuthenticate) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorRemovedReadPropertyConditional.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorRemovedReadPropertyConditional.go
index 37d451f..8797b38 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorRemovedReadPropertyConditional.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorRemovedReadPropertyConditional.go
@@ -75,22 +75,19 @@ func NewBACnetErrorRemovedReadPropertyConditional(errorClass *BACnetApplicationT
}
func CastBACnetErrorRemovedReadPropertyConditional(structType interface{}) *BACnetErrorRemovedReadPropertyConditional {
- castFunc := func(typ interface{}) *BACnetErrorRemovedReadPropertyConditional {
- if casted, ok := typ.(BACnetErrorRemovedReadPropertyConditional); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetErrorRemovedReadPropertyConditional); ok {
- return casted
- }
- if casted, ok := typ.(BACnetError); ok {
- return CastBACnetErrorRemovedReadPropertyConditional(casted.Child)
- }
- if casted, ok := typ.(*BACnetError); ok {
- return CastBACnetErrorRemovedReadPropertyConditional(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetErrorRemovedReadPropertyConditional); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetErrorRemovedReadPropertyConditional); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetError); ok {
+ return CastBACnetErrorRemovedReadPropertyConditional(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetError); ok {
+ return CastBACnetErrorRemovedReadPropertyConditional(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetErrorRemovedReadPropertyConditional) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorUnknown.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorUnknown.go
index c4a4257..4b3b34c 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorUnknown.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorUnknown.go
@@ -75,22 +75,19 @@ func NewBACnetErrorUnknown(errorClass *BACnetApplicationTagEnumerated, errorCode
}
func CastBACnetErrorUnknown(structType interface{}) *BACnetErrorUnknown {
- castFunc := func(typ interface{}) *BACnetErrorUnknown {
- if casted, ok := typ.(BACnetErrorUnknown); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetErrorUnknown); ok {
- return casted
- }
- if casted, ok := typ.(BACnetError); ok {
- return CastBACnetErrorUnknown(casted.Child)
- }
- if casted, ok := typ.(*BACnetError); ok {
- return CastBACnetErrorUnknown(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetErrorUnknown); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetErrorUnknown); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetError); ok {
+ return CastBACnetErrorUnknown(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetError); ok {
+ return CastBACnetErrorUnknown(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetErrorUnknown) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorVTData.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorVTData.go
index c6459cd..ed1ac34 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorVTData.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorVTData.go
@@ -75,22 +75,19 @@ func NewBACnetErrorVTData(errorClass *BACnetApplicationTagEnumerated, errorCode
}
func CastBACnetErrorVTData(structType interface{}) *BACnetErrorVTData {
- castFunc := func(typ interface{}) *BACnetErrorVTData {
- if casted, ok := typ.(BACnetErrorVTData); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetErrorVTData); ok {
- return casted
- }
- if casted, ok := typ.(BACnetError); ok {
- return CastBACnetErrorVTData(casted.Child)
- }
- if casted, ok := typ.(*BACnetError); ok {
- return CastBACnetErrorVTData(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetErrorVTData); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetErrorVTData); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetError); ok {
+ return CastBACnetErrorVTData(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetError); ok {
+ return CastBACnetErrorVTData(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetErrorVTData) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorVTOpen.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorVTOpen.go
index d898dc8..8da0162 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorVTOpen.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorVTOpen.go
@@ -75,22 +75,19 @@ func NewBACnetErrorVTOpen(errorClass *BACnetApplicationTagEnumerated, errorCode
}
func CastBACnetErrorVTOpen(structType interface{}) *BACnetErrorVTOpen {
- castFunc := func(typ interface{}) *BACnetErrorVTOpen {
- if casted, ok := typ.(BACnetErrorVTOpen); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetErrorVTOpen); ok {
- return casted
- }
- if casted, ok := typ.(BACnetError); ok {
- return CastBACnetErrorVTOpen(casted.Child)
- }
- if casted, ok := typ.(*BACnetError); ok {
- return CastBACnetErrorVTOpen(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetErrorVTOpen); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetErrorVTOpen); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetError); ok {
+ return CastBACnetErrorVTOpen(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetError); ok {
+ return CastBACnetErrorVTOpen(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetErrorVTOpen) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorWriteProperty.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorWriteProperty.go
index 42f14c0..1062696 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorWriteProperty.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetErrorWriteProperty.go
@@ -75,22 +75,19 @@ func NewBACnetErrorWriteProperty(errorClass *BACnetApplicationTagEnumerated, err
}
func CastBACnetErrorWriteProperty(structType interface{}) *BACnetErrorWriteProperty {
- castFunc := func(typ interface{}) *BACnetErrorWriteProperty {
- if casted, ok := typ.(BACnetErrorWriteProperty); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetErrorWriteProperty); ok {
- return casted
- }
- if casted, ok := typ.(BACnetError); ok {
- return CastBACnetErrorWriteProperty(casted.Child)
- }
- if casted, ok := typ.(*BACnetError); ok {
- return CastBACnetErrorWriteProperty(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetErrorWriteProperty); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetErrorWriteProperty); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetError); ok {
+ return CastBACnetErrorWriteProperty(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetError); ok {
+ return CastBACnetErrorWriteProperty(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetErrorWriteProperty) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParameters.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParameters.go
index 3f4f485..2de53a1 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParameters.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParameters.go
@@ -98,16 +98,13 @@ func NewBACnetNotificationParameters(openingTag *BACnetOpeningTag, peekedTagHead
}
func CastBACnetNotificationParameters(structType interface{}) *BACnetNotificationParameters {
- castFunc := func(typ interface{}) *BACnetNotificationParameters {
- if casted, ok := typ.(BACnetNotificationParameters); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetNotificationParameters); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetNotificationParameters); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetNotificationParameters); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetNotificationParameters) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersBufferReady.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersBufferReady.go
index 6e04ec7..50ff977 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersBufferReady.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersBufferReady.go
@@ -120,22 +120,19 @@ func NewBACnetNotificationParametersBufferReady(innerOpeningTag *BACnetOpeningTa
}
func CastBACnetNotificationParametersBufferReady(structType interface{}) *BACnetNotificationParametersBufferReady {
- castFunc := func(typ interface{}) *BACnetNotificationParametersBufferReady {
- if casted, ok := typ.(BACnetNotificationParametersBufferReady); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetNotificationParametersBufferReady); ok {
- return casted
- }
- if casted, ok := typ.(BACnetNotificationParameters); ok {
- return CastBACnetNotificationParametersBufferReady(casted.Child)
- }
- if casted, ok := typ.(*BACnetNotificationParameters); ok {
- return CastBACnetNotificationParametersBufferReady(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetNotificationParametersBufferReady); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetNotificationParametersBufferReady); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetNotificationParameters); ok {
+ return CastBACnetNotificationParametersBufferReady(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetNotificationParameters); ok {
+ return CastBACnetNotificationParametersBufferReady(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetNotificationParametersBufferReady) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersChangeOfBitString.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersChangeOfBitString.go
index 932e3e4..05cdaa7 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersChangeOfBitString.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersChangeOfBitString.go
@@ -112,22 +112,19 @@ func NewBACnetNotificationParametersChangeOfBitString(innerOpeningTag *BACnetOpe
}
func CastBACnetNotificationParametersChangeOfBitString(structType interface{}) *BACnetNotificationParametersChangeOfBitString {
- castFunc := func(typ interface{}) *BACnetNotificationParametersChangeOfBitString {
- if casted, ok := typ.(BACnetNotificationParametersChangeOfBitString); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetNotificationParametersChangeOfBitString); ok {
- return casted
- }
- if casted, ok := typ.(BACnetNotificationParameters); ok {
- return CastBACnetNotificationParametersChangeOfBitString(casted.Child)
- }
- if casted, ok := typ.(*BACnetNotificationParameters); ok {
- return CastBACnetNotificationParametersChangeOfBitString(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetNotificationParametersChangeOfBitString); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetNotificationParametersChangeOfBitString); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetNotificationParameters); ok {
+ return CastBACnetNotificationParametersChangeOfBitString(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetNotificationParameters); ok {
+ return CastBACnetNotificationParametersChangeOfBitString(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetNotificationParametersChangeOfBitString) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersChangeOfState.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersChangeOfState.go
index 1fa7cca..340ebe7 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersChangeOfState.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersChangeOfState.go
@@ -112,22 +112,19 @@ func NewBACnetNotificationParametersChangeOfState(innerOpeningTag *BACnetOpening
}
func CastBACnetNotificationParametersChangeOfState(structType interface{}) *BACnetNotificationParametersChangeOfState {
- castFunc := func(typ interface{}) *BACnetNotificationParametersChangeOfState {
- if casted, ok := typ.(BACnetNotificationParametersChangeOfState); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetNotificationParametersChangeOfState); ok {
- return casted
- }
- if casted, ok := typ.(BACnetNotificationParameters); ok {
- return CastBACnetNotificationParametersChangeOfState(casted.Child)
- }
- if casted, ok := typ.(*BACnetNotificationParameters); ok {
- return CastBACnetNotificationParametersChangeOfState(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetNotificationParametersChangeOfState); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetNotificationParametersChangeOfState); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetNotificationParameters); ok {
+ return CastBACnetNotificationParametersChangeOfState(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetNotificationParameters); ok {
+ return CastBACnetNotificationParametersChangeOfState(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetNotificationParametersChangeOfState) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersChangeOfValue.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersChangeOfValue.go
index 94ab332..7386aca 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersChangeOfValue.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersChangeOfValue.go
@@ -112,22 +112,19 @@ func NewBACnetNotificationParametersChangeOfValue(innerOpeningTag *BACnetOpening
}
func CastBACnetNotificationParametersChangeOfValue(structType interface{}) *BACnetNotificationParametersChangeOfValue {
- castFunc := func(typ interface{}) *BACnetNotificationParametersChangeOfValue {
- if casted, ok := typ.(BACnetNotificationParametersChangeOfValue); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetNotificationParametersChangeOfValue); ok {
- return casted
- }
- if casted, ok := typ.(BACnetNotificationParameters); ok {
- return CastBACnetNotificationParametersChangeOfValue(casted.Child)
- }
- if casted, ok := typ.(*BACnetNotificationParameters); ok {
- return CastBACnetNotificationParametersChangeOfValue(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetNotificationParametersChangeOfValue); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetNotificationParametersChangeOfValue); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetNotificationParameters); ok {
+ return CastBACnetNotificationParametersChangeOfValue(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetNotificationParameters); ok {
+ return CastBACnetNotificationParametersChangeOfValue(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetNotificationParametersChangeOfValue) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersChangeOfValueNewValue.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersChangeOfValueNewValue.go
index 6b26153..8979ce5 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersChangeOfValueNewValue.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersChangeOfValueNewValue.go
@@ -97,16 +97,13 @@ func NewBACnetNotificationParametersChangeOfValueNewValue(openingTag *BACnetOpen
}
func CastBACnetNotificationParametersChangeOfValueNewValue(structType interface{}) *BACnetNotificationParametersChangeOfValueNewValue {
- castFunc := func(typ interface{}) *BACnetNotificationParametersChangeOfValueNewValue {
- if casted, ok := typ.(BACnetNotificationParametersChangeOfValueNewValue); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetNotificationParametersChangeOfValueNewValue); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetNotificationParametersChangeOfValueNewValue); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetNotificationParametersChangeOfValueNewValue); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetNotificationParametersChangeOfValueNewValue) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersChangeOfValueNewValueChangedBits.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersChangeOfValueNewValueChangedBits.go
index 6ec873c..af5b602 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersChangeOfValueNewValueChangedBits.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersChangeOfValueNewValueChangedBits.go
@@ -87,22 +87,19 @@ func NewBACnetNotificationParametersChangeOfValueNewValueChangedBits(changedBits
}
func CastBACnetNotificationParametersChangeOfValueNewValueChangedBits(structType interface{}) *BACnetNotificationParametersChangeOfValueNewValueChangedBits {
- castFunc := func(typ interface{}) *BACnetNotificationParametersChangeOfValueNewValueChangedBits {
- if casted, ok := typ.(BACnetNotificationParametersChangeOfValueNewValueChangedBits); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetNotificationParametersChangeOfValueNewValueChangedBits); ok {
- return casted
- }
- if casted, ok := typ.(BACnetNotificationParametersChangeOfValueNewValue); ok {
- return CastBACnetNotificationParametersChangeOfValueNewValueChangedBits(casted.Child)
- }
- if casted, ok := typ.(*BACnetNotificationParametersChangeOfValueNewValue); ok {
- return CastBACnetNotificationParametersChangeOfValueNewValueChangedBits(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetNotificationParametersChangeOfValueNewValueChangedBits); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetNotificationParametersChangeOfValueNewValueChangedBits); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetNotificationParametersChangeOfValueNewValue); ok {
+ return CastBACnetNotificationParametersChangeOfValueNewValueChangedBits(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetNotificationParametersChangeOfValueNewValue); ok {
+ return CastBACnetNotificationParametersChangeOfValueNewValueChangedBits(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetNotificationParametersChangeOfValueNewValueChangedBits) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersChangeOfValueNewValueChangedValue.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersChangeOfValueNewValueChangedValue.go
index 55fabad..4140d75 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersChangeOfValueNewValueChangedValue.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersChangeOfValueNewValueChangedValue.go
@@ -87,22 +87,19 @@ func NewBACnetNotificationParametersChangeOfValueNewValueChangedValue(changedVal
}
func CastBACnetNotificationParametersChangeOfValueNewValueChangedValue(structType interface{}) *BACnetNotificationParametersChangeOfValueNewValueChangedValue {
- castFunc := func(typ interface{}) *BACnetNotificationParametersChangeOfValueNewValueChangedValue {
- if casted, ok := typ.(BACnetNotificationParametersChangeOfValueNewValueChangedValue); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetNotificationParametersChangeOfValueNewValueChangedValue); ok {
- return casted
- }
- if casted, ok := typ.(BACnetNotificationParametersChangeOfValueNewValue); ok {
- return CastBACnetNotificationParametersChangeOfValueNewValueChangedValue(casted.Child)
- }
- if casted, ok := typ.(*BACnetNotificationParametersChangeOfValueNewValue); ok {
- return CastBACnetNotificationParametersChangeOfValueNewValueChangedValue(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetNotificationParametersChangeOfValueNewValueChangedValue); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetNotificationParametersChangeOfValueNewValueChangedValue); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetNotificationParametersChangeOfValueNewValue); ok {
+ return CastBACnetNotificationParametersChangeOfValueNewValueChangedValue(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetNotificationParametersChangeOfValueNewValue); ok {
+ return CastBACnetNotificationParametersChangeOfValueNewValueChangedValue(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetNotificationParametersChangeOfValueNewValueChangedValue) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersComplexEventType.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersComplexEventType.go
index a285bc0..0d914dc 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersComplexEventType.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersComplexEventType.go
@@ -88,22 +88,19 @@ func NewBACnetNotificationParametersComplexEventType(listOfValues *BACnetPropert
}
func CastBACnetNotificationParametersComplexEventType(structType interface{}) *BACnetNotificationParametersComplexEventType {
- castFunc := func(typ interface{}) *BACnetNotificationParametersComplexEventType {
- if casted, ok := typ.(BACnetNotificationParametersComplexEventType); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetNotificationParametersComplexEventType); ok {
- return casted
- }
- if casted, ok := typ.(BACnetNotificationParameters); ok {
- return CastBACnetNotificationParametersComplexEventType(casted.Child)
- }
- if casted, ok := typ.(*BACnetNotificationParameters); ok {
- return CastBACnetNotificationParametersComplexEventType(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetNotificationParametersComplexEventType); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetNotificationParametersComplexEventType); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetNotificationParameters); ok {
+ return CastBACnetNotificationParametersComplexEventType(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetNotificationParameters); ok {
+ return CastBACnetNotificationParametersComplexEventType(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetNotificationParametersComplexEventType) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersExtended.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersExtended.go
index f4cacbc..d74514b 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersExtended.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersExtended.go
@@ -120,22 +120,19 @@ func NewBACnetNotificationParametersExtended(innerOpeningTag *BACnetOpeningTag,
}
func CastBACnetNotificationParametersExtended(structType interface{}) *BACnetNotificationParametersExtended {
- castFunc := func(typ interface{}) *BACnetNotificationParametersExtended {
- if casted, ok := typ.(BACnetNotificationParametersExtended); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetNotificationParametersExtended); ok {
- return casted
- }
- if casted, ok := typ.(BACnetNotificationParameters); ok {
- return CastBACnetNotificationParametersExtended(casted.Child)
- }
- if casted, ok := typ.(*BACnetNotificationParameters); ok {
- return CastBACnetNotificationParametersExtended(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetNotificationParametersExtended); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetNotificationParametersExtended); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetNotificationParameters); ok {
+ return CastBACnetNotificationParametersExtended(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetNotificationParameters); ok {
+ return CastBACnetNotificationParametersExtended(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetNotificationParametersExtended) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersExtendedParameters.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersExtendedParameters.go
index 9db4afb..f8c3977 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersExtendedParameters.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersExtendedParameters.go
@@ -169,16 +169,13 @@ func NewBACnetNotificationParametersExtendedParameters(openingTag *BACnetOpening
}
func CastBACnetNotificationParametersExtendedParameters(structType interface{}) *BACnetNotificationParametersExtendedParameters {
- castFunc := func(typ interface{}) *BACnetNotificationParametersExtendedParameters {
- if casted, ok := typ.(BACnetNotificationParametersExtendedParameters); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetNotificationParametersExtendedParameters); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetNotificationParametersExtendedParameters); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetNotificationParametersExtendedParameters); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetNotificationParametersExtendedParameters) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersFloatingLimit.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersFloatingLimit.go
index 672121a..ed227fe 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersFloatingLimit.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersFloatingLimit.go
@@ -128,22 +128,19 @@ func NewBACnetNotificationParametersFloatingLimit(innerOpeningTag *BACnetOpening
}
func CastBACnetNotificationParametersFloatingLimit(structType interface{}) *BACnetNotificationParametersFloatingLimit {
- castFunc := func(typ interface{}) *BACnetNotificationParametersFloatingLimit {
- if casted, ok := typ.(BACnetNotificationParametersFloatingLimit); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetNotificationParametersFloatingLimit); ok {
- return casted
- }
- if casted, ok := typ.(BACnetNotificationParameters); ok {
- return CastBACnetNotificationParametersFloatingLimit(casted.Child)
- }
- if casted, ok := typ.(*BACnetNotificationParameters); ok {
- return CastBACnetNotificationParametersFloatingLimit(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetNotificationParametersFloatingLimit); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetNotificationParametersFloatingLimit); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetNotificationParameters); ok {
+ return CastBACnetNotificationParametersFloatingLimit(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetNotificationParameters); ok {
+ return CastBACnetNotificationParametersFloatingLimit(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetNotificationParametersFloatingLimit) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersOutOfRange.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersOutOfRange.go
index 14db1bd..a924453 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersOutOfRange.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersOutOfRange.go
@@ -128,22 +128,19 @@ func NewBACnetNotificationParametersOutOfRange(innerOpeningTag *BACnetOpeningTag
}
func CastBACnetNotificationParametersOutOfRange(structType interface{}) *BACnetNotificationParametersOutOfRange {
- castFunc := func(typ interface{}) *BACnetNotificationParametersOutOfRange {
- if casted, ok := typ.(BACnetNotificationParametersOutOfRange); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetNotificationParametersOutOfRange); ok {
- return casted
- }
- if casted, ok := typ.(BACnetNotificationParameters); ok {
- return CastBACnetNotificationParametersOutOfRange(casted.Child)
- }
- if casted, ok := typ.(*BACnetNotificationParameters); ok {
- return CastBACnetNotificationParametersOutOfRange(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetNotificationParametersOutOfRange); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetNotificationParametersOutOfRange); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetNotificationParameters); ok {
+ return CastBACnetNotificationParametersOutOfRange(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetNotificationParameters); ok {
+ return CastBACnetNotificationParametersOutOfRange(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetNotificationParametersOutOfRange) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersUnsignedRange.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersUnsignedRange.go
index 81dd320..d9697ec 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersUnsignedRange.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetNotificationParametersUnsignedRange.go
@@ -120,22 +120,19 @@ func NewBACnetNotificationParametersUnsignedRange(innerOpeningTag *BACnetOpening
}
func CastBACnetNotificationParametersUnsignedRange(structType interface{}) *BACnetNotificationParametersUnsignedRange {
- castFunc := func(typ interface{}) *BACnetNotificationParametersUnsignedRange {
- if casted, ok := typ.(BACnetNotificationParametersUnsignedRange); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetNotificationParametersUnsignedRange); ok {
- return casted
- }
- if casted, ok := typ.(BACnetNotificationParameters); ok {
- return CastBACnetNotificationParametersUnsignedRange(casted.Child)
- }
- if casted, ok := typ.(*BACnetNotificationParameters); ok {
- return CastBACnetNotificationParametersUnsignedRange(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetNotificationParametersUnsignedRange); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetNotificationParametersUnsignedRange); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetNotificationParameters); ok {
+ return CastBACnetNotificationParametersUnsignedRange(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetNotificationParameters); ok {
+ return CastBACnetNotificationParametersUnsignedRange(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetNotificationParametersUnsignedRange) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetOpeningTag.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetOpeningTag.go
index f0b7728..cc3fa8a 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetOpeningTag.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetOpeningTag.go
@@ -78,22 +78,19 @@ func NewBACnetOpeningTag(header *BACnetTagHeader, tagNumberArgument uint8, actua
}
func CastBACnetOpeningTag(structType interface{}) *BACnetOpeningTag {
- castFunc := func(typ interface{}) *BACnetOpeningTag {
- if casted, ok := typ.(BACnetOpeningTag); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetOpeningTag); ok {
- return casted
- }
- if casted, ok := typ.(BACnetContextTag); ok {
- return CastBACnetOpeningTag(casted.Child)
- }
- if casted, ok := typ.(*BACnetContextTag); ok {
- return CastBACnetOpeningTag(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetOpeningTag); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetOpeningTag); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetContextTag); ok {
+ return CastBACnetOpeningTag(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetContextTag); ok {
+ return CastBACnetOpeningTag(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetOpeningTag) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetPropertyReference.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetPropertyReference.go
index 2f75857..b324936 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetPropertyReference.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetPropertyReference.go
@@ -68,16 +68,13 @@ func NewBACnetPropertyReference(propertyIdentifier *BACnetContextTagPropertyIden
}
func CastBACnetPropertyReference(structType interface{}) *BACnetPropertyReference {
- castFunc := func(typ interface{}) *BACnetPropertyReference {
- if casted, ok := typ.(BACnetPropertyReference); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetPropertyReference); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetPropertyReference); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetPropertyReference); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetPropertyReference) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetPropertyStates.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetPropertyStates.go
index 3b939ef..f810e0f 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetPropertyStates.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetPropertyStates.go
@@ -97,16 +97,13 @@ func NewBACnetPropertyStates(openingTag *BACnetOpeningTag, peekedTagHeader *BACn
}
func CastBACnetPropertyStates(structType interface{}) *BACnetPropertyStates {
- castFunc := func(typ interface{}) *BACnetPropertyStates {
- if casted, ok := typ.(BACnetPropertyStates); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetPropertyStates); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetPropertyStates); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetPropertyStates); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetPropertyStates) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetPropertyStatesAction.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetPropertyStatesAction.go
index f7dd61f..763e499 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetPropertyStatesAction.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetPropertyStatesAction.go
@@ -88,22 +88,19 @@ func NewBACnetPropertyStatesAction(action *BACnetAction, openingTag *BACnetOpeni
}
func CastBACnetPropertyStatesAction(structType interface{}) *BACnetPropertyStatesAction {
- castFunc := func(typ interface{}) *BACnetPropertyStatesAction {
- if casted, ok := typ.(BACnetPropertyStatesAction); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetPropertyStatesAction); ok {
- return casted
- }
- if casted, ok := typ.(BACnetPropertyStates); ok {
- return CastBACnetPropertyStatesAction(casted.Child)
- }
- if casted, ok := typ.(*BACnetPropertyStates); ok {
- return CastBACnetPropertyStatesAction(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetPropertyStatesAction); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetPropertyStatesAction); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetPropertyStates); ok {
+ return CastBACnetPropertyStatesAction(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetPropertyStates); ok {
+ return CastBACnetPropertyStatesAction(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetPropertyStatesAction) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetPropertyStatesBinaryValue.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetPropertyStatesBinaryValue.go
index da79f64..1531619 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetPropertyStatesBinaryValue.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetPropertyStatesBinaryValue.go
@@ -88,22 +88,19 @@ func NewBACnetPropertyStatesBinaryValue(binaryValue *BACnetBinaryPV, openingTag
}
func CastBACnetPropertyStatesBinaryValue(structType interface{}) *BACnetPropertyStatesBinaryValue {
- castFunc := func(typ interface{}) *BACnetPropertyStatesBinaryValue {
- if casted, ok := typ.(BACnetPropertyStatesBinaryValue); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetPropertyStatesBinaryValue); ok {
- return casted
- }
- if casted, ok := typ.(BACnetPropertyStates); ok {
- return CastBACnetPropertyStatesBinaryValue(casted.Child)
- }
- if casted, ok := typ.(*BACnetPropertyStates); ok {
- return CastBACnetPropertyStatesBinaryValue(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetPropertyStatesBinaryValue); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetPropertyStatesBinaryValue); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetPropertyStates); ok {
+ return CastBACnetPropertyStatesBinaryValue(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetPropertyStates); ok {
+ return CastBACnetPropertyStatesBinaryValue(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetPropertyStatesBinaryValue) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetPropertyStatesBoolean.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetPropertyStatesBoolean.go
index 123c822..a20cd45 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetPropertyStatesBoolean.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetPropertyStatesBoolean.go
@@ -88,22 +88,19 @@ func NewBACnetPropertyStatesBoolean(booleanValue *BACnetContextTagBoolean, openi
}
func CastBACnetPropertyStatesBoolean(structType interface{}) *BACnetPropertyStatesBoolean {
- castFunc := func(typ interface{}) *BACnetPropertyStatesBoolean {
- if casted, ok := typ.(BACnetPropertyStatesBoolean); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetPropertyStatesBoolean); ok {
- return casted
- }
- if casted, ok := typ.(BACnetPropertyStates); ok {
- return CastBACnetPropertyStatesBoolean(casted.Child)
- }
- if casted, ok := typ.(*BACnetPropertyStates); ok {
- return CastBACnetPropertyStatesBoolean(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetPropertyStatesBoolean); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetPropertyStatesBoolean); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetPropertyStates); ok {
+ return CastBACnetPropertyStatesBoolean(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetPropertyStates); ok {
+ return CastBACnetPropertyStatesBoolean(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetPropertyStatesBoolean) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetPropertyValue.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetPropertyValue.go
index 239a9ca..03ecae9 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetPropertyValue.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetPropertyValue.go
@@ -85,16 +85,13 @@ func NewBACnetPropertyValue(propertyIdentifier *BACnetContextTagPropertyIdentifi
}
func CastBACnetPropertyValue(structType interface{}) *BACnetPropertyValue {
- castFunc := func(typ interface{}) *BACnetPropertyValue {
- if casted, ok := typ.(BACnetPropertyValue); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetPropertyValue); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetPropertyValue); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetPropertyValue); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetPropertyValue) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetPropertyValues.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetPropertyValues.go
index 08d583f..e496534 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetPropertyValues.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetPropertyValues.go
@@ -78,16 +78,13 @@ func NewBACnetPropertyValues(innerOpeningTag *BACnetOpeningTag, data []*BACnetPr
}
func CastBACnetPropertyValues(structType interface{}) *BACnetPropertyValues {
- castFunc := func(typ interface{}) *BACnetPropertyValues {
- if casted, ok := typ.(BACnetPropertyValues); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetPropertyValues); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetPropertyValues); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetPropertyValues); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetPropertyValues) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetReadAccessSpecification.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetReadAccessSpecification.go
index 9f3bab8..dd94c3a 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetReadAccessSpecification.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetReadAccessSpecification.go
@@ -81,16 +81,13 @@ func NewBACnetReadAccessSpecification(objectIdentifier *BACnetContextTagObjectId
}
func CastBACnetReadAccessSpecification(structType interface{}) *BACnetReadAccessSpecification {
- castFunc := func(typ interface{}) *BACnetReadAccessSpecification {
- if casted, ok := typ.(BACnetReadAccessSpecification); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetReadAccessSpecification); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetReadAccessSpecification); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetReadAccessSpecification); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetReadAccessSpecification) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetSegmentation.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetSegmentation.go
index efe530b..0c71a8c 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetSegmentation.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetSegmentation.go
@@ -83,16 +83,13 @@ func NewBACnetSegmentation(rawData *BACnetApplicationTagEnumerated) *BACnetSegme
}
func CastBACnetSegmentation(structType interface{}) *BACnetSegmentation {
- castFunc := func(typ interface{}) *BACnetSegmentation {
- if casted, ok := typ.(BACnetSegmentation); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetSegmentation); ok {
- return casted
- }
- return nil
- }
- return castFunc(structType)
+ if casted, ok := structType.(BACnetSegmentation); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetSegmentation); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetSegmentation) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAck.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAck.go
index 1efa640..cf7a24f 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAck.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAck.go
@@ -69,16 +69,13 @@ func NewBACnetServiceAck() *BACnetServiceAck {
}
func CastBACnetServiceAck(structType interface{}) *BACnetServiceAck {
- castFunc := func(typ interface{}) *BACnetServiceAck {
- if casted, ok := typ.(BACnetServiceAck); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetServiceAck); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetServiceAck); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetServiceAck); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetServiceAck) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckAtomicReadFile.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckAtomicReadFile.go
index 405d267..2723088 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckAtomicReadFile.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckAtomicReadFile.go
@@ -88,22 +88,19 @@ func NewBACnetServiceAckAtomicReadFile(endOfFile *BACnetApplicationTagBoolean, a
}
func CastBACnetServiceAckAtomicReadFile(structType interface{}) *BACnetServiceAckAtomicReadFile {
- castFunc := func(typ interface{}) *BACnetServiceAckAtomicReadFile {
- if casted, ok := typ.(BACnetServiceAckAtomicReadFile); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetServiceAckAtomicReadFile); ok {
- return casted
- }
- if casted, ok := typ.(BACnetServiceAck); ok {
- return CastBACnetServiceAckAtomicReadFile(casted.Child)
- }
- if casted, ok := typ.(*BACnetServiceAck); ok {
- return CastBACnetServiceAckAtomicReadFile(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetServiceAckAtomicReadFile); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetServiceAckAtomicReadFile); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetServiceAck); ok {
+ return CastBACnetServiceAckAtomicReadFile(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetServiceAck); ok {
+ return CastBACnetServiceAckAtomicReadFile(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetServiceAckAtomicReadFile) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckAtomicReadFileRecord.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckAtomicReadFileRecord.go
index b1c19b9..700adc1 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckAtomicReadFileRecord.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckAtomicReadFileRecord.go
@@ -100,22 +100,19 @@ func NewBACnetServiceAckAtomicReadFileRecord(fileStartRecord *BACnetApplicationT
}
func CastBACnetServiceAckAtomicReadFileRecord(structType interface{}) *BACnetServiceAckAtomicReadFileRecord {
- castFunc := func(typ interface{}) *BACnetServiceAckAtomicReadFileRecord {
- if casted, ok := typ.(BACnetServiceAckAtomicReadFileRecord); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetServiceAckAtomicReadFileRecord); ok {
- return casted
- }
- if casted, ok := typ.(BACnetServiceAckAtomicReadFileStreamOrRecord); ok {
- return CastBACnetServiceAckAtomicReadFileRecord(casted.Child)
- }
- if casted, ok := typ.(*BACnetServiceAckAtomicReadFileStreamOrRecord); ok {
- return CastBACnetServiceAckAtomicReadFileRecord(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetServiceAckAtomicReadFileRecord); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetServiceAckAtomicReadFileRecord); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetServiceAckAtomicReadFileStreamOrRecord); ok {
+ return CastBACnetServiceAckAtomicReadFileRecord(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetServiceAckAtomicReadFileStreamOrRecord); ok {
+ return CastBACnetServiceAckAtomicReadFileRecord(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetServiceAckAtomicReadFileRecord) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckAtomicReadFileStream.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckAtomicReadFileStream.go
index df23863..e33b895 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckAtomicReadFileStream.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckAtomicReadFileStream.go
@@ -92,22 +92,19 @@ func NewBACnetServiceAckAtomicReadFileStream(fileStartPosition *BACnetApplicatio
}
func CastBACnetServiceAckAtomicReadFileStream(structType interface{}) *BACnetServiceAckAtomicReadFileStream {
- castFunc := func(typ interface{}) *BACnetServiceAckAtomicReadFileStream {
- if casted, ok := typ.(BACnetServiceAckAtomicReadFileStream); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetServiceAckAtomicReadFileStream); ok {
- return casted
- }
- if casted, ok := typ.(BACnetServiceAckAtomicReadFileStreamOrRecord); ok {
- return CastBACnetServiceAckAtomicReadFileStream(casted.Child)
- }
- if casted, ok := typ.(*BACnetServiceAckAtomicReadFileStreamOrRecord); ok {
- return CastBACnetServiceAckAtomicReadFileStream(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetServiceAckAtomicReadFileStream); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetServiceAckAtomicReadFileStream); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetServiceAckAtomicReadFileStreamOrRecord); ok {
+ return CastBACnetServiceAckAtomicReadFileStream(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetServiceAckAtomicReadFileStreamOrRecord); ok {
+ return CastBACnetServiceAckAtomicReadFileStream(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetServiceAckAtomicReadFileStream) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckAtomicReadFileStreamOrRecord.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckAtomicReadFileStreamOrRecord.go
index 43ab6fe..c2ad4fc 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckAtomicReadFileStreamOrRecord.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckAtomicReadFileStreamOrRecord.go
@@ -94,16 +94,13 @@ func NewBACnetServiceAckAtomicReadFileStreamOrRecord(peekedTagHeader *BACnetTagH
}
func CastBACnetServiceAckAtomicReadFileStreamOrRecord(structType interface{}) *BACnetServiceAckAtomicReadFileStreamOrRecord {
- castFunc := func(typ interface{}) *BACnetServiceAckAtomicReadFileStreamOrRecord {
- if casted, ok := typ.(BACnetServiceAckAtomicReadFileStreamOrRecord); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetServiceAckAtomicReadFileStreamOrRecord); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetServiceAckAtomicReadFileStreamOrRecord); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetServiceAckAtomicReadFileStreamOrRecord); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetServiceAckAtomicReadFileStreamOrRecord) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckAtomicWriteFile.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckAtomicWriteFile.go
index 0e31805..c69a87b 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckAtomicWriteFile.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckAtomicWriteFile.go
@@ -80,22 +80,19 @@ func NewBACnetServiceAckAtomicWriteFile(fileStartPosition *BACnetContextTagSigne
}
func CastBACnetServiceAckAtomicWriteFile(structType interface{}) *BACnetServiceAckAtomicWriteFile {
- castFunc := func(typ interface{}) *BACnetServiceAckAtomicWriteFile {
- if casted, ok := typ.(BACnetServiceAckAtomicWriteFile); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetServiceAckAtomicWriteFile); ok {
- return casted
- }
- if casted, ok := typ.(BACnetServiceAck); ok {
- return CastBACnetServiceAckAtomicWriteFile(casted.Child)
- }
- if casted, ok := typ.(*BACnetServiceAck); ok {
- return CastBACnetServiceAckAtomicWriteFile(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetServiceAckAtomicWriteFile); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetServiceAckAtomicWriteFile); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetServiceAck); ok {
+ return CastBACnetServiceAckAtomicWriteFile(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetServiceAck); ok {
+ return CastBACnetServiceAckAtomicWriteFile(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetServiceAckAtomicWriteFile) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckConfirmedPrivateTransfer.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckConfirmedPrivateTransfer.go
index f3cdbfa..151ba9b 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckConfirmedPrivateTransfer.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckConfirmedPrivateTransfer.go
@@ -72,22 +72,19 @@ func NewBACnetServiceAckConfirmedPrivateTransfer() *BACnetServiceAck {
}
func CastBACnetServiceAckConfirmedPrivateTransfer(structType interface{}) *BACnetServiceAckConfirmedPrivateTransfer {
- castFunc := func(typ interface{}) *BACnetServiceAckConfirmedPrivateTransfer {
- if casted, ok := typ.(BACnetServiceAckConfirmedPrivateTransfer); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetServiceAckConfirmedPrivateTransfer); ok {
- return casted
- }
- if casted, ok := typ.(BACnetServiceAck); ok {
- return CastBACnetServiceAckConfirmedPrivateTransfer(casted.Child)
- }
- if casted, ok := typ.(*BACnetServiceAck); ok {
- return CastBACnetServiceAckConfirmedPrivateTransfer(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetServiceAckConfirmedPrivateTransfer); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetServiceAckConfirmedPrivateTransfer); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetServiceAck); ok {
+ return CastBACnetServiceAckConfirmedPrivateTransfer(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetServiceAck); ok {
+ return CastBACnetServiceAckConfirmedPrivateTransfer(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetServiceAckConfirmedPrivateTransfer) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckCreateObject.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckCreateObject.go
index e5be97f..67af26f 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckCreateObject.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckCreateObject.go
@@ -72,22 +72,19 @@ func NewBACnetServiceAckCreateObject() *BACnetServiceAck {
}
func CastBACnetServiceAckCreateObject(structType interface{}) *BACnetServiceAckCreateObject {
- castFunc := func(typ interface{}) *BACnetServiceAckCreateObject {
- if casted, ok := typ.(BACnetServiceAckCreateObject); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetServiceAckCreateObject); ok {
- return casted
- }
- if casted, ok := typ.(BACnetServiceAck); ok {
- return CastBACnetServiceAckCreateObject(casted.Child)
- }
- if casted, ok := typ.(*BACnetServiceAck); ok {
- return CastBACnetServiceAckCreateObject(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetServiceAckCreateObject); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetServiceAckCreateObject); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetServiceAck); ok {
+ return CastBACnetServiceAckCreateObject(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetServiceAck); ok {
+ return CastBACnetServiceAckCreateObject(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetServiceAckCreateObject) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckGetAlarmSummary.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckGetAlarmSummary.go
index 57762d3..5eb482e 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckGetAlarmSummary.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckGetAlarmSummary.go
@@ -72,22 +72,19 @@ func NewBACnetServiceAckGetAlarmSummary() *BACnetServiceAck {
}
func CastBACnetServiceAckGetAlarmSummary(structType interface{}) *BACnetServiceAckGetAlarmSummary {
- castFunc := func(typ interface{}) *BACnetServiceAckGetAlarmSummary {
- if casted, ok := typ.(BACnetServiceAckGetAlarmSummary); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetServiceAckGetAlarmSummary); ok {
- return casted
- }
- if casted, ok := typ.(BACnetServiceAck); ok {
- return CastBACnetServiceAckGetAlarmSummary(casted.Child)
- }
- if casted, ok := typ.(*BACnetServiceAck); ok {
- return CastBACnetServiceAckGetAlarmSummary(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetServiceAckGetAlarmSummary); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetServiceAckGetAlarmSummary); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetServiceAck); ok {
+ return CastBACnetServiceAckGetAlarmSummary(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetServiceAck); ok {
+ return CastBACnetServiceAckGetAlarmSummary(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetServiceAckGetAlarmSummary) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckGetEnrollmentSummary.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckGetEnrollmentSummary.go
index 4063555..944163c 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckGetEnrollmentSummary.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckGetEnrollmentSummary.go
@@ -72,22 +72,19 @@ func NewBACnetServiceAckGetEnrollmentSummary() *BACnetServiceAck {
}
func CastBACnetServiceAckGetEnrollmentSummary(structType interface{}) *BACnetServiceAckGetEnrollmentSummary {
- castFunc := func(typ interface{}) *BACnetServiceAckGetEnrollmentSummary {
- if casted, ok := typ.(BACnetServiceAckGetEnrollmentSummary); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetServiceAckGetEnrollmentSummary); ok {
- return casted
- }
- if casted, ok := typ.(BACnetServiceAck); ok {
- return CastBACnetServiceAckGetEnrollmentSummary(casted.Child)
- }
- if casted, ok := typ.(*BACnetServiceAck); ok {
- return CastBACnetServiceAckGetEnrollmentSummary(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetServiceAckGetEnrollmentSummary); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetServiceAckGetEnrollmentSummary); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetServiceAck); ok {
+ return CastBACnetServiceAckGetEnrollmentSummary(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetServiceAck); ok {
+ return CastBACnetServiceAckGetEnrollmentSummary(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetServiceAckGetEnrollmentSummary) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckGetEventInformation.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckGetEventInformation.go
index b6e5360..72c1649 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckGetEventInformation.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckGetEventInformation.go
@@ -72,22 +72,19 @@ func NewBACnetServiceAckGetEventInformation() *BACnetServiceAck {
}
func CastBACnetServiceAckGetEventInformation(structType interface{}) *BACnetServiceAckGetEventInformation {
- castFunc := func(typ interface{}) *BACnetServiceAckGetEventInformation {
- if casted, ok := typ.(BACnetServiceAckGetEventInformation); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetServiceAckGetEventInformation); ok {
- return casted
- }
- if casted, ok := typ.(BACnetServiceAck); ok {
- return CastBACnetServiceAckGetEventInformation(casted.Child)
- }
- if casted, ok := typ.(*BACnetServiceAck); ok {
- return CastBACnetServiceAckGetEventInformation(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetServiceAckGetEventInformation); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetServiceAckGetEventInformation); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetServiceAck); ok {
+ return CastBACnetServiceAckGetEventInformation(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetServiceAck); ok {
+ return CastBACnetServiceAckGetEventInformation(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetServiceAckGetEventInformation) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckReadProperty.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckReadProperty.go
index 934c754..9495a5e 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckReadProperty.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckReadProperty.go
@@ -105,22 +105,19 @@ func NewBACnetServiceAckReadProperty(objectIdentifier *BACnetContextTagObjectIde
}
func CastBACnetServiceAckReadProperty(structType interface{}) *BACnetServiceAckReadProperty {
- castFunc := func(typ interface{}) *BACnetServiceAckReadProperty {
- if casted, ok := typ.(BACnetServiceAckReadProperty); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetServiceAckReadProperty); ok {
- return casted
- }
- if casted, ok := typ.(BACnetServiceAck); ok {
- return CastBACnetServiceAckReadProperty(casted.Child)
- }
- if casted, ok := typ.(*BACnetServiceAck); ok {
- return CastBACnetServiceAckReadProperty(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetServiceAckReadProperty); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetServiceAckReadProperty); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetServiceAck); ok {
+ return CastBACnetServiceAckReadProperty(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetServiceAck); ok {
+ return CastBACnetServiceAckReadProperty(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetServiceAckReadProperty) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckReadPropertyMultiple.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckReadPropertyMultiple.go
index 76ae2a2..ad4fa1f 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckReadPropertyMultiple.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckReadPropertyMultiple.go
@@ -72,22 +72,19 @@ func NewBACnetServiceAckReadPropertyMultiple() *BACnetServiceAck {
}
func CastBACnetServiceAckReadPropertyMultiple(structType interface{}) *BACnetServiceAckReadPropertyMultiple {
- castFunc := func(typ interface{}) *BACnetServiceAckReadPropertyMultiple {
- if casted, ok := typ.(BACnetServiceAckReadPropertyMultiple); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetServiceAckReadPropertyMultiple); ok {
- return casted
- }
- if casted, ok := typ.(BACnetServiceAck); ok {
- return CastBACnetServiceAckReadPropertyMultiple(casted.Child)
- }
- if casted, ok := typ.(*BACnetServiceAck); ok {
- return CastBACnetServiceAckReadPropertyMultiple(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetServiceAckReadPropertyMultiple); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetServiceAckReadPropertyMultiple); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetServiceAck); ok {
+ return CastBACnetServiceAckReadPropertyMultiple(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetServiceAck); ok {
+ return CastBACnetServiceAckReadPropertyMultiple(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetServiceAckReadPropertyMultiple) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckReadRange.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckReadRange.go
index 93dc941..64564a1 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckReadRange.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckReadRange.go
@@ -72,22 +72,19 @@ func NewBACnetServiceAckReadRange() *BACnetServiceAck {
}
func CastBACnetServiceAckReadRange(structType interface{}) *BACnetServiceAckReadRange {
- castFunc := func(typ interface{}) *BACnetServiceAckReadRange {
- if casted, ok := typ.(BACnetServiceAckReadRange); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetServiceAckReadRange); ok {
- return casted
- }
- if casted, ok := typ.(BACnetServiceAck); ok {
- return CastBACnetServiceAckReadRange(casted.Child)
- }
- if casted, ok := typ.(*BACnetServiceAck); ok {
- return CastBACnetServiceAckReadRange(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetServiceAckReadRange); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetServiceAckReadRange); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetServiceAck); ok {
+ return CastBACnetServiceAckReadRange(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetServiceAck); ok {
+ return CastBACnetServiceAckReadRange(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetServiceAckReadRange) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckRemovedAuthenticate.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckRemovedAuthenticate.go
index 6a1e54b..a49740a 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckRemovedAuthenticate.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckRemovedAuthenticate.go
@@ -72,22 +72,19 @@ func NewBACnetServiceAckRemovedAuthenticate() *BACnetServiceAck {
}
func CastBACnetServiceAckRemovedAuthenticate(structType interface{}) *BACnetServiceAckRemovedAuthenticate {
- castFunc := func(typ interface{}) *BACnetServiceAckRemovedAuthenticate {
- if casted, ok := typ.(BACnetServiceAckRemovedAuthenticate); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetServiceAckRemovedAuthenticate); ok {
- return casted
- }
- if casted, ok := typ.(BACnetServiceAck); ok {
- return CastBACnetServiceAckRemovedAuthenticate(casted.Child)
- }
- if casted, ok := typ.(*BACnetServiceAck); ok {
- return CastBACnetServiceAckRemovedAuthenticate(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetServiceAckRemovedAuthenticate); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetServiceAckRemovedAuthenticate); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetServiceAck); ok {
+ return CastBACnetServiceAckRemovedAuthenticate(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetServiceAck); ok {
+ return CastBACnetServiceAckRemovedAuthenticate(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetServiceAckRemovedAuthenticate) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckRemovedReadPropertyConditional.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckRemovedReadPropertyConditional.go
index a7bcb10..99f407c 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckRemovedReadPropertyConditional.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckRemovedReadPropertyConditional.go
@@ -72,22 +72,19 @@ func NewBACnetServiceAckRemovedReadPropertyConditional() *BACnetServiceAck {
}
func CastBACnetServiceAckRemovedReadPropertyConditional(structType interface{}) *BACnetServiceAckRemovedReadPropertyConditional {
- castFunc := func(typ interface{}) *BACnetServiceAckRemovedReadPropertyConditional {
- if casted, ok := typ.(BACnetServiceAckRemovedReadPropertyConditional); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetServiceAckRemovedReadPropertyConditional); ok {
- return casted
- }
- if casted, ok := typ.(BACnetServiceAck); ok {
- return CastBACnetServiceAckRemovedReadPropertyConditional(casted.Child)
- }
- if casted, ok := typ.(*BACnetServiceAck); ok {
- return CastBACnetServiceAckRemovedReadPropertyConditional(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetServiceAckRemovedReadPropertyConditional); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetServiceAckRemovedReadPropertyConditional); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetServiceAck); ok {
+ return CastBACnetServiceAckRemovedReadPropertyConditional(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetServiceAck); ok {
+ return CastBACnetServiceAckRemovedReadPropertyConditional(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetServiceAckRemovedReadPropertyConditional) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckVTData.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckVTData.go
index 3a1b625..ed39622 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckVTData.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckVTData.go
@@ -72,22 +72,19 @@ func NewBACnetServiceAckVTData() *BACnetServiceAck {
}
func CastBACnetServiceAckVTData(structType interface{}) *BACnetServiceAckVTData {
- castFunc := func(typ interface{}) *BACnetServiceAckVTData {
- if casted, ok := typ.(BACnetServiceAckVTData); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetServiceAckVTData); ok {
- return casted
- }
- if casted, ok := typ.(BACnetServiceAck); ok {
- return CastBACnetServiceAckVTData(casted.Child)
- }
- if casted, ok := typ.(*BACnetServiceAck); ok {
- return CastBACnetServiceAckVTData(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetServiceAckVTData); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetServiceAckVTData); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetServiceAck); ok {
+ return CastBACnetServiceAckVTData(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetServiceAck); ok {
+ return CastBACnetServiceAckVTData(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetServiceAckVTData) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckVTOpen.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckVTOpen.go
index 7970eb8..6896904 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckVTOpen.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetServiceAckVTOpen.go
@@ -72,22 +72,19 @@ func NewBACnetServiceAckVTOpen() *BACnetServiceAck {
}
func CastBACnetServiceAckVTOpen(structType interface{}) *BACnetServiceAckVTOpen {
- castFunc := func(typ interface{}) *BACnetServiceAckVTOpen {
- if casted, ok := typ.(BACnetServiceAckVTOpen); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetServiceAckVTOpen); ok {
- return casted
- }
- if casted, ok := typ.(BACnetServiceAck); ok {
- return CastBACnetServiceAckVTOpen(casted.Child)
- }
- if casted, ok := typ.(*BACnetServiceAck); ok {
- return CastBACnetServiceAckVTOpen(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetServiceAckVTOpen); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetServiceAckVTOpen); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetServiceAck); ok {
+ return CastBACnetServiceAckVTOpen(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetServiceAck); ok {
+ return CastBACnetServiceAckVTOpen(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetServiceAckVTOpen) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetStatusFlags.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetStatusFlags.go
index be7bb28..40c402a 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetStatusFlags.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetStatusFlags.go
@@ -86,16 +86,13 @@ func NewBACnetStatusFlags(rawBits *BACnetContextTagBitString, tagNumber uint8) *
}
func CastBACnetStatusFlags(structType interface{}) *BACnetStatusFlags {
- castFunc := func(typ interface{}) *BACnetStatusFlags {
- if casted, ok := typ.(BACnetStatusFlags); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetStatusFlags); ok {
- return casted
- }
- return nil
- }
- return castFunc(structType)
+ if casted, ok := structType.(BACnetStatusFlags); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetStatusFlags); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetStatusFlags) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagHeader.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagHeader.go
index f7f59b3..08a1d0f 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagHeader.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagHeader.go
@@ -175,16 +175,13 @@ func NewBACnetTagHeader(tagNumber uint8, tagClass TagClass, lengthValueType uint
}
func CastBACnetTagHeader(structType interface{}) *BACnetTagHeader {
- castFunc := func(typ interface{}) *BACnetTagHeader {
- if casted, ok := typ.(BACnetTagHeader); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetTagHeader); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetTagHeader); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetTagHeader); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetTagHeader) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadBitString.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadBitString.go
index da3ef12..1e30802 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadBitString.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadBitString.go
@@ -77,16 +77,13 @@ func NewBACnetTagPayloadBitString(unusedBits uint8, data []bool, unused []bool,
}
func CastBACnetTagPayloadBitString(structType interface{}) *BACnetTagPayloadBitString {
- castFunc := func(typ interface{}) *BACnetTagPayloadBitString {
- if casted, ok := typ.(BACnetTagPayloadBitString); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetTagPayloadBitString); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetTagPayloadBitString); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetTagPayloadBitString); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetTagPayloadBitString) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadBoolean.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadBoolean.go
index 0341541..3cea62f 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadBoolean.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadBoolean.go
@@ -74,16 +74,13 @@ func NewBACnetTagPayloadBoolean(actualLength uint32) *BACnetTagPayloadBoolean {
}
func CastBACnetTagPayloadBoolean(structType interface{}) *BACnetTagPayloadBoolean {
- castFunc := func(typ interface{}) *BACnetTagPayloadBoolean {
- if casted, ok := typ.(BACnetTagPayloadBoolean); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetTagPayloadBoolean); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetTagPayloadBoolean); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetTagPayloadBoolean); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetTagPayloadBoolean) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadCharacterString.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadCharacterString.go
index 62796fb..4f54b90 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadCharacterString.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadCharacterString.go
@@ -75,16 +75,13 @@ func NewBACnetTagPayloadCharacterString(encoding BACnetCharacterEncoding, value
}
func CastBACnetTagPayloadCharacterString(structType interface{}) *BACnetTagPayloadCharacterString {
- castFunc := func(typ interface{}) *BACnetTagPayloadCharacterString {
- if casted, ok := typ.(BACnetTagPayloadCharacterString); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetTagPayloadCharacterString); ok {
- return casted
- }
- return nil
- }
- return castFunc(structType)
+ if casted, ok := structType.(BACnetTagPayloadCharacterString); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetTagPayloadCharacterString); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetTagPayloadCharacterString) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadDate.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadDate.go
index 0bfd00b..05d0f94 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadDate.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadDate.go
@@ -146,16 +146,13 @@ func NewBACnetTagPayloadDate(yearMinus1900 uint8, month uint8, dayOfMonth uint8,
}
func CastBACnetTagPayloadDate(structType interface{}) *BACnetTagPayloadDate {
- castFunc := func(typ interface{}) *BACnetTagPayloadDate {
- if casted, ok := typ.(BACnetTagPayloadDate); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetTagPayloadDate); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetTagPayloadDate); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetTagPayloadDate); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetTagPayloadDate) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadDouble.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadDouble.go
index 7d5919a..68ba095 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadDouble.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadDouble.go
@@ -60,16 +60,13 @@ func NewBACnetTagPayloadDouble(value float64) *BACnetTagPayloadDouble {
}
func CastBACnetTagPayloadDouble(structType interface{}) *BACnetTagPayloadDouble {
- castFunc := func(typ interface{}) *BACnetTagPayloadDouble {
- if casted, ok := typ.(BACnetTagPayloadDouble); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetTagPayloadDouble); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetTagPayloadDouble); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetTagPayloadDouble); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetTagPayloadDouble) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadEnumerated.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadEnumerated.go
index 5fbea08..3f3c06e 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadEnumerated.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadEnumerated.go
@@ -68,16 +68,13 @@ func NewBACnetTagPayloadEnumerated(data []byte, actualLength uint32) *BACnetTagP
}
func CastBACnetTagPayloadEnumerated(structType interface{}) *BACnetTagPayloadEnumerated {
- castFunc := func(typ interface{}) *BACnetTagPayloadEnumerated {
- if casted, ok := typ.(BACnetTagPayloadEnumerated); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetTagPayloadEnumerated); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetTagPayloadEnumerated); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetTagPayloadEnumerated); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetTagPayloadEnumerated) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadObjectIdentifier.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadObjectIdentifier.go
index 6a7436f..f6c0846 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadObjectIdentifier.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadObjectIdentifier.go
@@ -79,16 +79,13 @@ func NewBACnetTagPayloadObjectIdentifier(objectType BACnetObjectType, proprietar
}
func CastBACnetTagPayloadObjectIdentifier(structType interface{}) *BACnetTagPayloadObjectIdentifier {
- castFunc := func(typ interface{}) *BACnetTagPayloadObjectIdentifier {
- if casted, ok := typ.(BACnetTagPayloadObjectIdentifier); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetTagPayloadObjectIdentifier); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetTagPayloadObjectIdentifier); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetTagPayloadObjectIdentifier); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetTagPayloadObjectIdentifier) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadOctetString.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadOctetString.go
index 2be415f..bdff557 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadOctetString.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadOctetString.go
@@ -68,16 +68,13 @@ func NewBACnetTagPayloadOctetString(value string, actualLength uint32) *BACnetTa
}
func CastBACnetTagPayloadOctetString(structType interface{}) *BACnetTagPayloadOctetString {
- castFunc := func(typ interface{}) *BACnetTagPayloadOctetString {
- if casted, ok := typ.(BACnetTagPayloadOctetString); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetTagPayloadOctetString); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetTagPayloadOctetString); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetTagPayloadOctetString); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetTagPayloadOctetString) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadReal.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadReal.go
index b3645e6..cf7874b 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadReal.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadReal.go
@@ -60,16 +60,13 @@ func NewBACnetTagPayloadReal(value float32) *BACnetTagPayloadReal {
}
func CastBACnetTagPayloadReal(structType interface{}) *BACnetTagPayloadReal {
- castFunc := func(typ interface{}) *BACnetTagPayloadReal {
- if casted, ok := typ.(BACnetTagPayloadReal); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetTagPayloadReal); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetTagPayloadReal); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetTagPayloadReal); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetTagPayloadReal) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadSignedInteger.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadSignedInteger.go
index 7b568a2..99e98de 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadSignedInteger.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadSignedInteger.go
@@ -321,16 +321,13 @@ func NewBACnetTagPayloadSignedInteger(valueInt8 *int8, valueInt16 *int16, valueI
}
func CastBACnetTagPayloadSignedInteger(structType interface{}) *BACnetTagPayloadSignedInteger {
- castFunc := func(typ interface{}) *BACnetTagPayloadSignedInteger {
- if casted, ok := typ.(BACnetTagPayloadSignedInteger); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetTagPayloadSignedInteger); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetTagPayloadSignedInteger); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetTagPayloadSignedInteger); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetTagPayloadSignedInteger) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadTime.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadTime.go
index 80f0360..ef0b89d 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadTime.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadTime.go
@@ -110,16 +110,13 @@ func NewBACnetTagPayloadTime(hour uint8, minute uint8, second uint8, fractional
}
func CastBACnetTagPayloadTime(structType interface{}) *BACnetTagPayloadTime {
- castFunc := func(typ interface{}) *BACnetTagPayloadTime {
- if casted, ok := typ.(BACnetTagPayloadTime); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetTagPayloadTime); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetTagPayloadTime); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetTagPayloadTime); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetTagPayloadTime) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadUnsignedInteger.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadUnsignedInteger.go
index c943a1b..6cf2b6b 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadUnsignedInteger.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTagPayloadUnsignedInteger.go
@@ -321,16 +321,13 @@ func NewBACnetTagPayloadUnsignedInteger(valueUint8 *uint8, valueUint16 *uint16,
}
func CastBACnetTagPayloadUnsignedInteger(structType interface{}) *BACnetTagPayloadUnsignedInteger {
- castFunc := func(typ interface{}) *BACnetTagPayloadUnsignedInteger {
- if casted, ok := typ.(BACnetTagPayloadUnsignedInteger); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetTagPayloadUnsignedInteger); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetTagPayloadUnsignedInteger); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetTagPayloadUnsignedInteger); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetTagPayloadUnsignedInteger) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTimeStamp.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTimeStamp.go
index 36aa016..672d958 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTimeStamp.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTimeStamp.go
@@ -97,16 +97,13 @@ func NewBACnetTimeStamp(openingTag *BACnetOpeningTag, peekedTagHeader *BACnetTag
}
func CastBACnetTimeStamp(structType interface{}) *BACnetTimeStamp {
- castFunc := func(typ interface{}) *BACnetTimeStamp {
- if casted, ok := typ.(BACnetTimeStamp); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetTimeStamp); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetTimeStamp); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetTimeStamp); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetTimeStamp) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTimeStampDateTime.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTimeStampDateTime.go
index c6429d7..761a989 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTimeStampDateTime.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTimeStampDateTime.go
@@ -87,22 +87,19 @@ func NewBACnetTimeStampDateTime(dateTimeValue *BACnetDateTime, openingTag *BACne
}
func CastBACnetTimeStampDateTime(structType interface{}) *BACnetTimeStampDateTime {
- castFunc := func(typ interface{}) *BACnetTimeStampDateTime {
- if casted, ok := typ.(BACnetTimeStampDateTime); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetTimeStampDateTime); ok {
- return casted
- }
- if casted, ok := typ.(BACnetTimeStamp); ok {
- return CastBACnetTimeStampDateTime(casted.Child)
- }
- if casted, ok := typ.(*BACnetTimeStamp); ok {
- return CastBACnetTimeStampDateTime(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetTimeStampDateTime); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetTimeStampDateTime); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetTimeStamp); ok {
+ return CastBACnetTimeStampDateTime(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetTimeStamp); ok {
+ return CastBACnetTimeStampDateTime(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetTimeStampDateTime) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTimeStampSequence.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTimeStampSequence.go
index a21c062..d31e479 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTimeStampSequence.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTimeStampSequence.go
@@ -87,22 +87,19 @@ func NewBACnetTimeStampSequence(sequenceNumber *BACnetContextTagUnsignedInteger,
}
func CastBACnetTimeStampSequence(structType interface{}) *BACnetTimeStampSequence {
- castFunc := func(typ interface{}) *BACnetTimeStampSequence {
- if casted, ok := typ.(BACnetTimeStampSequence); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetTimeStampSequence); ok {
- return casted
- }
- if casted, ok := typ.(BACnetTimeStamp); ok {
- return CastBACnetTimeStampSequence(casted.Child)
- }
- if casted, ok := typ.(*BACnetTimeStamp); ok {
- return CastBACnetTimeStampSequence(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetTimeStampSequence); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetTimeStampSequence); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetTimeStamp); ok {
+ return CastBACnetTimeStampSequence(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetTimeStamp); ok {
+ return CastBACnetTimeStampSequence(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetTimeStampSequence) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTimeStampTime.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTimeStampTime.go
index cca952b..4afd388 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTimeStampTime.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetTimeStampTime.go
@@ -87,22 +87,19 @@ func NewBACnetTimeStampTime(timeValue *BACnetContextTagTime, openingTag *BACnetO
}
func CastBACnetTimeStampTime(structType interface{}) *BACnetTimeStampTime {
- castFunc := func(typ interface{}) *BACnetTimeStampTime {
- if casted, ok := typ.(BACnetTimeStampTime); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetTimeStampTime); ok {
- return casted
- }
- if casted, ok := typ.(BACnetTimeStamp); ok {
- return CastBACnetTimeStampTime(casted.Child)
- }
- if casted, ok := typ.(*BACnetTimeStamp); ok {
- return CastBACnetTimeStampTime(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetTimeStampTime); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetTimeStampTime); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetTimeStamp); ok {
+ return CastBACnetTimeStampTime(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetTimeStamp); ok {
+ return CastBACnetTimeStampTime(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetTimeStampTime) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequest.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequest.go
index 65a5536..ce5e7a0 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequest.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequest.go
@@ -72,16 +72,13 @@ func NewBACnetUnconfirmedServiceRequest(len uint16) *BACnetUnconfirmedServiceReq
}
func CastBACnetUnconfirmedServiceRequest(structType interface{}) *BACnetUnconfirmedServiceRequest {
- castFunc := func(typ interface{}) *BACnetUnconfirmedServiceRequest {
- if casted, ok := typ.(BACnetUnconfirmedServiceRequest); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetUnconfirmedServiceRequest); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BACnetUnconfirmedServiceRequest); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BACnetUnconfirmedServiceRequest); ok {
+ return casted
+ }
+ return nil
}
func (m *BACnetUnconfirmedServiceRequest) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestIAm.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestIAm.go
index 25fc808..55c4ef7 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestIAm.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestIAm.go
@@ -108,22 +108,19 @@ func NewBACnetUnconfirmedServiceRequestIAm(deviceIdentifier *BACnetApplicationTa
}
func CastBACnetUnconfirmedServiceRequestIAm(structType interface{}) *BACnetUnconfirmedServiceRequestIAm {
- castFunc := func(typ interface{}) *BACnetUnconfirmedServiceRequestIAm {
- if casted, ok := typ.(BACnetUnconfirmedServiceRequestIAm); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetUnconfirmedServiceRequestIAm); ok {
- return casted
- }
- if casted, ok := typ.(BACnetUnconfirmedServiceRequest); ok {
- return CastBACnetUnconfirmedServiceRequestIAm(casted.Child)
- }
- if casted, ok := typ.(*BACnetUnconfirmedServiceRequest); ok {
- return CastBACnetUnconfirmedServiceRequestIAm(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetUnconfirmedServiceRequestIAm); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetUnconfirmedServiceRequestIAm); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetUnconfirmedServiceRequest); ok {
+ return CastBACnetUnconfirmedServiceRequestIAm(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetUnconfirmedServiceRequest); ok {
+ return CastBACnetUnconfirmedServiceRequestIAm(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetUnconfirmedServiceRequestIAm) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestIHave.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestIHave.go
index fc244cd..474ab4f 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestIHave.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestIHave.go
@@ -100,22 +100,19 @@ func NewBACnetUnconfirmedServiceRequestIHave(deviceIdentifier *BACnetApplication
}
func CastBACnetUnconfirmedServiceRequestIHave(structType interface{}) *BACnetUnconfirmedServiceRequestIHave {
- castFunc := func(typ interface{}) *BACnetUnconfirmedServiceRequestIHave {
- if casted, ok := typ.(BACnetUnconfirmedServiceRequestIHave); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetUnconfirmedServiceRequestIHave); ok {
- return casted
- }
- if casted, ok := typ.(BACnetUnconfirmedServiceRequest); ok {
- return CastBACnetUnconfirmedServiceRequestIHave(casted.Child)
- }
- if casted, ok := typ.(*BACnetUnconfirmedServiceRequest); ok {
- return CastBACnetUnconfirmedServiceRequestIHave(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetUnconfirmedServiceRequestIHave); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetUnconfirmedServiceRequestIHave); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetUnconfirmedServiceRequest); ok {
+ return CastBACnetUnconfirmedServiceRequestIHave(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetUnconfirmedServiceRequest); ok {
+ return CastBACnetUnconfirmedServiceRequestIHave(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetUnconfirmedServiceRequestIHave) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestTimeSynchronization.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestTimeSynchronization.go
index 6d376a2..1af98e3 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestTimeSynchronization.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestTimeSynchronization.go
@@ -92,22 +92,19 @@ func NewBACnetUnconfirmedServiceRequestTimeSynchronization(synchronizedDate *BAC
}
func CastBACnetUnconfirmedServiceRequestTimeSynchronization(structType interface{}) *BACnetUnconfirmedServiceRequestTimeSynchronization {
- castFunc := func(typ interface{}) *BACnetUnconfirmedServiceRequestTimeSynchronization {
- if casted, ok := typ.(BACnetUnconfirmedServiceRequestTimeSynchronization); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetUnconfirmedServiceRequestTimeSynchronization); ok {
- return casted
- }
- if casted, ok := typ.(BACnetUnconfirmedServiceRequest); ok {
- return CastBACnetUnconfirmedServiceRequestTimeSynchronization(casted.Child)
- }
- if casted, ok := typ.(*BACnetUnconfirmedServiceRequest); ok {
- return CastBACnetUnconfirmedServiceRequestTimeSynchronization(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetUnconfirmedServiceRequestTimeSynchronization); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetUnconfirmedServiceRequestTimeSynchronization); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetUnconfirmedServiceRequest); ok {
+ return CastBACnetUnconfirmedServiceRequestTimeSynchronization(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetUnconfirmedServiceRequest); ok {
+ return CastBACnetUnconfirmedServiceRequestTimeSynchronization(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetUnconfirmedServiceRequestTimeSynchronization) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestUTCTimeSynchronization.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestUTCTimeSynchronization.go
index 2ec5ea2..6490302 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestUTCTimeSynchronization.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestUTCTimeSynchronization.go
@@ -76,22 +76,19 @@ func NewBACnetUnconfirmedServiceRequestUTCTimeSynchronization(len uint16) *BACne
}
func CastBACnetUnconfirmedServiceRequestUTCTimeSynchronization(structType interface{}) *BACnetUnconfirmedServiceRequestUTCTimeSynchronization {
- castFunc := func(typ interface{}) *BACnetUnconfirmedServiceRequestUTCTimeSynchronization {
- if casted, ok := typ.(BACnetUnconfirmedServiceRequestUTCTimeSynchronization); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetUnconfirmedServiceRequestUTCTimeSynchronization); ok {
- return casted
- }
- if casted, ok := typ.(BACnetUnconfirmedServiceRequest); ok {
- return CastBACnetUnconfirmedServiceRequestUTCTimeSynchronization(casted.Child)
- }
- if casted, ok := typ.(*BACnetUnconfirmedServiceRequest); ok {
- return CastBACnetUnconfirmedServiceRequestUTCTimeSynchronization(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetUnconfirmedServiceRequestUTCTimeSynchronization); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetUnconfirmedServiceRequestUTCTimeSynchronization); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetUnconfirmedServiceRequest); ok {
+ return CastBACnetUnconfirmedServiceRequestUTCTimeSynchronization(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetUnconfirmedServiceRequest); ok {
+ return CastBACnetUnconfirmedServiceRequestUTCTimeSynchronization(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetUnconfirmedServiceRequestUTCTimeSynchronization) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestUnconfirmedCOVNotification.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestUnconfirmedCOVNotification.go
index bc575ec..722ae50 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestUnconfirmedCOVNotification.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestUnconfirmedCOVNotification.go
@@ -116,22 +116,19 @@ func NewBACnetUnconfirmedServiceRequestUnconfirmedCOVNotification(subscriberProc
}
func CastBACnetUnconfirmedServiceRequestUnconfirmedCOVNotification(structType interface{}) *BACnetUnconfirmedServiceRequestUnconfirmedCOVNotification {
- castFunc := func(typ interface{}) *BACnetUnconfirmedServiceRequestUnconfirmedCOVNotification {
- if casted, ok := typ.(BACnetUnconfirmedServiceRequestUnconfirmedCOVNotification); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetUnconfirmedServiceRequestUnconfirmedCOVNotification); ok {
- return casted
- }
- if casted, ok := typ.(BACnetUnconfirmedServiceRequest); ok {
- return CastBACnetUnconfirmedServiceRequestUnconfirmedCOVNotification(casted.Child)
- }
- if casted, ok := typ.(*BACnetUnconfirmedServiceRequest); ok {
- return CastBACnetUnconfirmedServiceRequestUnconfirmedCOVNotification(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetUnconfirmedServiceRequestUnconfirmedCOVNotification); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetUnconfirmedServiceRequestUnconfirmedCOVNotification); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetUnconfirmedServiceRequest); ok {
+ return CastBACnetUnconfirmedServiceRequestUnconfirmedCOVNotification(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetUnconfirmedServiceRequest); ok {
+ return CastBACnetUnconfirmedServiceRequestUnconfirmedCOVNotification(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetUnconfirmedServiceRequestUnconfirmedCOVNotification) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestUnconfirmedCOVNotificationMultiple.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestUnconfirmedCOVNotificationMultiple.go
index eeb2f00..fba92ec 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestUnconfirmedCOVNotificationMultiple.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestUnconfirmedCOVNotificationMultiple.go
@@ -76,22 +76,19 @@ func NewBACnetUnconfirmedServiceRequestUnconfirmedCOVNotificationMultiple(len ui
}
func CastBACnetUnconfirmedServiceRequestUnconfirmedCOVNotificationMultiple(structType interface{}) *BACnetUnconfirmedServiceRequestUnconfirmedCOVNotificationMultiple {
- castFunc := func(typ interface{}) *BACnetUnconfirmedServiceRequestUnconfirmedCOVNotificationMultiple {
- if casted, ok := typ.(BACnetUnconfirmedServiceRequestUnconfirmedCOVNotificationMultiple); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetUnconfirmedServiceRequestUnconfirmedCOVNotificationMultiple); ok {
- return casted
- }
- if casted, ok := typ.(BACnetUnconfirmedServiceRequest); ok {
- return CastBACnetUnconfirmedServiceRequestUnconfirmedCOVNotificationMultiple(casted.Child)
- }
- if casted, ok := typ.(*BACnetUnconfirmedServiceRequest); ok {
- return CastBACnetUnconfirmedServiceRequestUnconfirmedCOVNotificationMultiple(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetUnconfirmedServiceRequestUnconfirmedCOVNotificationMultiple); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetUnconfirmedServiceRequestUnconfirmedCOVNotificationMultiple); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetUnconfirmedServiceRequest); ok {
+ return CastBACnetUnconfirmedServiceRequestUnconfirmedCOVNotificationMultiple(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetUnconfirmedServiceRequest); ok {
+ return CastBACnetUnconfirmedServiceRequestUnconfirmedCOVNotificationMultiple(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetUnconfirmedServiceRequestUnconfirmedCOVNotificationMultiple) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestUnconfirmedEventNotification.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestUnconfirmedEventNotification.go
index 7330241..ebd0ae8 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestUnconfirmedEventNotification.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestUnconfirmedEventNotification.go
@@ -76,22 +76,19 @@ func NewBACnetUnconfirmedServiceRequestUnconfirmedEventNotification(len uint16)
}
func CastBACnetUnconfirmedServiceRequestUnconfirmedEventNotification(structType interface{}) *BACnetUnconfirmedServiceRequestUnconfirmedEventNotification {
- castFunc := func(typ interface{}) *BACnetUnconfirmedServiceRequestUnconfirmedEventNotification {
- if casted, ok := typ.(BACnetUnconfirmedServiceRequestUnconfirmedEventNotification); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetUnconfirmedServiceRequestUnconfirmedEventNotification); ok {
- return casted
- }
- if casted, ok := typ.(BACnetUnconfirmedServiceRequest); ok {
- return CastBACnetUnconfirmedServiceRequestUnconfirmedEventNotification(casted.Child)
- }
- if casted, ok := typ.(*BACnetUnconfirmedServiceRequest); ok {
- return CastBACnetUnconfirmedServiceRequestUnconfirmedEventNotification(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetUnconfirmedServiceRequestUnconfirmedEventNotification); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetUnconfirmedServiceRequestUnconfirmedEventNotification); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetUnconfirmedServiceRequest); ok {
+ return CastBACnetUnconfirmedServiceRequestUnconfirmedEventNotification(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetUnconfirmedServiceRequest); ok {
+ return CastBACnetUnconfirmedServiceRequestUnconfirmedEventNotification(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetUnconfirmedServiceRequestUnconfirmedEventNotification) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestUnconfirmedPrivateTransfer.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestUnconfirmedPrivateTransfer.go
index 213315b..acc6317 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestUnconfirmedPrivateTransfer.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestUnconfirmedPrivateTransfer.go
@@ -101,22 +101,19 @@ func NewBACnetUnconfirmedServiceRequestUnconfirmedPrivateTransfer(vendorId *BACn
}
func CastBACnetUnconfirmedServiceRequestUnconfirmedPrivateTransfer(structType interface{}) *BACnetUnconfirmedServiceRequestUnconfirmedPrivateTransfer {
- castFunc := func(typ interface{}) *BACnetUnconfirmedServiceRequestUnconfirmedPrivateTransfer {
- if casted, ok := typ.(BACnetUnconfirmedServiceRequestUnconfirmedPrivateTransfer); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetUnconfirmedServiceRequestUnconfirmedPrivateTransfer); ok {
- return casted
- }
- if casted, ok := typ.(BACnetUnconfirmedServiceRequest); ok {
- return CastBACnetUnconfirmedServiceRequestUnconfirmedPrivateTransfer(casted.Child)
- }
- if casted, ok := typ.(*BACnetUnconfirmedServiceRequest); ok {
- return CastBACnetUnconfirmedServiceRequestUnconfirmedPrivateTransfer(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetUnconfirmedServiceRequestUnconfirmedPrivateTransfer); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetUnconfirmedServiceRequestUnconfirmedPrivateTransfer); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetUnconfirmedServiceRequest); ok {
+ return CastBACnetUnconfirmedServiceRequestUnconfirmedPrivateTransfer(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetUnconfirmedServiceRequest); ok {
+ return CastBACnetUnconfirmedServiceRequestUnconfirmedPrivateTransfer(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetUnconfirmedServiceRequestUnconfirmedPrivateTransfer) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestUnconfirmedTextMessage.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestUnconfirmedTextMessage.go
index 36ef0ac..fd7ad22 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestUnconfirmedTextMessage.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestUnconfirmedTextMessage.go
@@ -76,22 +76,19 @@ func NewBACnetUnconfirmedServiceRequestUnconfirmedTextMessage(len uint16) *BACne
}
func CastBACnetUnconfirmedServiceRequestUnconfirmedTextMessage(structType interface{}) *BACnetUnconfirmedServiceRequestUnconfirmedTextMessage {
- castFunc := func(typ interface{}) *BACnetUnconfirmedServiceRequestUnconfirmedTextMessage {
- if casted, ok := typ.(BACnetUnconfirmedServiceRequestUnconfirmedTextMessage); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetUnconfirmedServiceRequestUnconfirmedTextMessage); ok {
- return casted
- }
- if casted, ok := typ.(BACnetUnconfirmedServiceRequest); ok {
- return CastBACnetUnconfirmedServiceRequestUnconfirmedTextMessage(casted.Child)
- }
- if casted, ok := typ.(*BACnetUnconfirmedServiceRequest); ok {
- return CastBACnetUnconfirmedServiceRequestUnconfirmedTextMessage(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetUnconfirmedServiceRequestUnconfirmedTextMessage); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetUnconfirmedServiceRequestUnconfirmedTextMessage); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetUnconfirmedServiceRequest); ok {
+ return CastBACnetUnconfirmedServiceRequestUnconfirmedTextMessage(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetUnconfirmedServiceRequest); ok {
+ return CastBACnetUnconfirmedServiceRequestUnconfirmedTextMessage(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetUnconfirmedServiceRequestUnconfirmedTextMessage) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestUnconfirmedUnknown.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestUnconfirmedUnknown.go
index d901095..0450211 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestUnconfirmedUnknown.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestUnconfirmedUnknown.go
@@ -84,22 +84,19 @@ func NewBACnetUnconfirmedServiceRequestUnconfirmedUnknown(unknownBytes []byte, l
}
func CastBACnetUnconfirmedServiceRequestUnconfirmedUnknown(structType interface{}) *BACnetUnconfirmedServiceRequestUnconfirmedUnknown {
- castFunc := func(typ interface{}) *BACnetUnconfirmedServiceRequestUnconfirmedUnknown {
- if casted, ok := typ.(BACnetUnconfirmedServiceRequestUnconfirmedUnknown); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetUnconfirmedServiceRequestUnconfirmedUnknown); ok {
- return casted
- }
- if casted, ok := typ.(BACnetUnconfirmedServiceRequest); ok {
- return CastBACnetUnconfirmedServiceRequestUnconfirmedUnknown(casted.Child)
- }
- if casted, ok := typ.(*BACnetUnconfirmedServiceRequest); ok {
- return CastBACnetUnconfirmedServiceRequestUnconfirmedUnknown(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetUnconfirmedServiceRequestUnconfirmedUnknown); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetUnconfirmedServiceRequestUnconfirmedUnknown); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetUnconfirmedServiceRequest); ok {
+ return CastBACnetUnconfirmedServiceRequestUnconfirmedUnknown(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetUnconfirmedServiceRequest); ok {
+ return CastBACnetUnconfirmedServiceRequestUnconfirmedUnknown(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetUnconfirmedServiceRequestUnconfirmedUnknown) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestWhoHas.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestWhoHas.go
index 46bfd6b..365f055 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestWhoHas.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestWhoHas.go
@@ -109,22 +109,19 @@ func NewBACnetUnconfirmedServiceRequestWhoHas(deviceInstanceRangeLowLimit *BACne
}
func CastBACnetUnconfirmedServiceRequestWhoHas(structType interface{}) *BACnetUnconfirmedServiceRequestWhoHas {
- castFunc := func(typ interface{}) *BACnetUnconfirmedServiceRequestWhoHas {
- if casted, ok := typ.(BACnetUnconfirmedServiceRequestWhoHas); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetUnconfirmedServiceRequestWhoHas); ok {
- return casted
- }
- if casted, ok := typ.(BACnetUnconfirmedServiceRequest); ok {
- return CastBACnetUnconfirmedServiceRequestWhoHas(casted.Child)
- }
- if casted, ok := typ.(*BACnetUnconfirmedServiceRequest); ok {
- return CastBACnetUnconfirmedServiceRequestWhoHas(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetUnconfirmedServiceRequestWhoHas); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetUnconfirmedServiceRequestWhoHas); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetUnconfirmedServiceRequest); ok {
+ return CastBACnetUnconfirmedServiceRequestWhoHas(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetUnconfirmedServiceRequest); ok {
+ return CastBACnetUnconfirmedServiceRequestWhoHas(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetUnconfirmedServiceRequestWhoHas) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestWhoIs.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestWhoIs.go
index 1f2e13f..1422fb9 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestWhoIs.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestWhoIs.go
@@ -93,22 +93,19 @@ func NewBACnetUnconfirmedServiceRequestWhoIs(deviceInstanceRangeLowLimit *BACnet
}
func CastBACnetUnconfirmedServiceRequestWhoIs(structType interface{}) *BACnetUnconfirmedServiceRequestWhoIs {
- castFunc := func(typ interface{}) *BACnetUnconfirmedServiceRequestWhoIs {
- if casted, ok := typ.(BACnetUnconfirmedServiceRequestWhoIs); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetUnconfirmedServiceRequestWhoIs); ok {
- return casted
- }
- if casted, ok := typ.(BACnetUnconfirmedServiceRequest); ok {
- return CastBACnetUnconfirmedServiceRequestWhoIs(casted.Child)
- }
- if casted, ok := typ.(*BACnetUnconfirmedServiceRequest); ok {
- return CastBACnetUnconfirmedServiceRequestWhoIs(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetUnconfirmedServiceRequestWhoIs); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetUnconfirmedServiceRequestWhoIs); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetUnconfirmedServiceRequest); ok {
+ return CastBACnetUnconfirmedServiceRequestWhoIs(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetUnconfirmedServiceRequest); ok {
+ return CastBACnetUnconfirmedServiceRequestWhoIs(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetUnconfirmedServiceRequestWhoIs) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestWriteGroup.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestWriteGroup.go
index 3f05d16..bd43970 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestWriteGroup.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BACnetUnconfirmedServiceRequestWriteGroup.go
@@ -76,22 +76,19 @@ func NewBACnetUnconfirmedServiceRequestWriteGroup(len uint16) *BACnetUnconfirmed
}
func CastBACnetUnconfirmedServiceRequestWriteGroup(structType interface{}) *BACnetUnconfirmedServiceRequestWriteGroup {
- castFunc := func(typ interface{}) *BACnetUnconfirmedServiceRequestWriteGroup {
- if casted, ok := typ.(BACnetUnconfirmedServiceRequestWriteGroup); ok {
- return &casted
- }
- if casted, ok := typ.(*BACnetUnconfirmedServiceRequestWriteGroup); ok {
- return casted
- }
- if casted, ok := typ.(BACnetUnconfirmedServiceRequest); ok {
- return CastBACnetUnconfirmedServiceRequestWriteGroup(casted.Child)
- }
- if casted, ok := typ.(*BACnetUnconfirmedServiceRequest); ok {
- return CastBACnetUnconfirmedServiceRequestWriteGroup(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BACnetUnconfirmedServiceRequestWriteGroup); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BACnetUnconfirmedServiceRequestWriteGroup); ok {
+ return casted
+ }
+ if casted, ok := structType.(BACnetUnconfirmedServiceRequest); ok {
+ return CastBACnetUnconfirmedServiceRequestWriteGroup(casted.Child)
+ }
+ if casted, ok := structType.(*BACnetUnconfirmedServiceRequest); ok {
+ return CastBACnetUnconfirmedServiceRequestWriteGroup(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BACnetUnconfirmedServiceRequestWriteGroup) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BVLC.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BVLC.go
index 4749696..164a1e7 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BVLC.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BVLC.go
@@ -78,16 +78,13 @@ func NewBVLC() *BVLC {
}
func CastBVLC(structType interface{}) *BVLC {
- castFunc := func(typ interface{}) *BVLC {
- if casted, ok := typ.(BVLC); ok {
- return &casted
- }
- if casted, ok := typ.(*BVLC); ok {
- return casted
- }
- return nil
+ if casted, ok := structType.(BVLC); ok {
+ return &casted
}
- return castFunc(structType)
+ if casted, ok := structType.(*BVLC); ok {
+ return casted
+ }
+ return nil
}
func (m *BVLC) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BVLCDeleteForeignDeviceTableEntry.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BVLCDeleteForeignDeviceTableEntry.go
index b1373ad..3df1888 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BVLCDeleteForeignDeviceTableEntry.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BVLCDeleteForeignDeviceTableEntry.go
@@ -72,22 +72,19 @@ func NewBVLCDeleteForeignDeviceTableEntry() *BVLC {
}
func CastBVLCDeleteForeignDeviceTableEntry(structType interface{}) *BVLCDeleteForeignDeviceTableEntry {
- castFunc := func(typ interface{}) *BVLCDeleteForeignDeviceTableEntry {
- if casted, ok := typ.(BVLCDeleteForeignDeviceTableEntry); ok {
- return &casted
- }
- if casted, ok := typ.(*BVLCDeleteForeignDeviceTableEntry); ok {
- return casted
- }
- if casted, ok := typ.(BVLC); ok {
- return CastBVLCDeleteForeignDeviceTableEntry(casted.Child)
- }
- if casted, ok := typ.(*BVLC); ok {
- return CastBVLCDeleteForeignDeviceTableEntry(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BVLCDeleteForeignDeviceTableEntry); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BVLCDeleteForeignDeviceTableEntry); ok {
+ return casted
+ }
+ if casted, ok := structType.(BVLC); ok {
+ return CastBVLCDeleteForeignDeviceTableEntry(casted.Child)
+ }
+ if casted, ok := structType.(*BVLC); ok {
+ return CastBVLCDeleteForeignDeviceTableEntry(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BVLCDeleteForeignDeviceTableEntry) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BVLCDistributeBroadcastToNetwork.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BVLCDistributeBroadcastToNetwork.go
index aacf9270..bd1ab28 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BVLCDistributeBroadcastToNetwork.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BVLCDistributeBroadcastToNetwork.go
@@ -83,22 +83,19 @@ func NewBVLCDistributeBroadcastToNetwork(npdu *NPDU, bvlcPayloadLength uint16) *
}
func CastBVLCDistributeBroadcastToNetwork(structType interface{}) *BVLCDistributeBroadcastToNetwork {
- castFunc := func(typ interface{}) *BVLCDistributeBroadcastToNetwork {
- if casted, ok := typ.(BVLCDistributeBroadcastToNetwork); ok {
- return &casted
- }
- if casted, ok := typ.(*BVLCDistributeBroadcastToNetwork); ok {
- return casted
- }
- if casted, ok := typ.(BVLC); ok {
- return CastBVLCDistributeBroadcastToNetwork(casted.Child)
- }
- if casted, ok := typ.(*BVLC); ok {
- return CastBVLCDistributeBroadcastToNetwork(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BVLCDistributeBroadcastToNetwork); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BVLCDistributeBroadcastToNetwork); ok {
+ return casted
+ }
+ if casted, ok := structType.(BVLC); ok {
+ return CastBVLCDistributeBroadcastToNetwork(casted.Child)
+ }
+ if casted, ok := structType.(*BVLC); ok {
+ return CastBVLCDistributeBroadcastToNetwork(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BVLCDistributeBroadcastToNetwork) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BVLCForwardedNPDU.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BVLCForwardedNPDU.go
index 2c69d3c..9d6ba33 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BVLCForwardedNPDU.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BVLCForwardedNPDU.go
@@ -99,22 +99,19 @@ func NewBVLCForwardedNPDU(ip []uint8, port uint16, npdu *NPDU, bvlcPayloadLength
}
func CastBVLCForwardedNPDU(structType interface{}) *BVLCForwardedNPDU {
- castFunc := func(typ interface{}) *BVLCForwardedNPDU {
- if casted, ok := typ.(BVLCForwardedNPDU); ok {
- return &casted
- }
- if casted, ok := typ.(*BVLCForwardedNPDU); ok {
- return casted
- }
- if casted, ok := typ.(BVLC); ok {
- return CastBVLCForwardedNPDU(casted.Child)
- }
- if casted, ok := typ.(*BVLC); ok {
- return CastBVLCForwardedNPDU(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BVLCForwardedNPDU); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BVLCForwardedNPDU); ok {
+ return casted
+ }
+ if casted, ok := structType.(BVLC); ok {
+ return CastBVLCForwardedNPDU(casted.Child)
+ }
+ if casted, ok := structType.(*BVLC); ok {
+ return CastBVLCForwardedNPDU(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BVLCForwardedNPDU) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BVLCOriginalBroadcastNPDU.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BVLCOriginalBroadcastNPDU.go
index 73df046..5731667 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BVLCOriginalBroadcastNPDU.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BVLCOriginalBroadcastNPDU.go
@@ -83,22 +83,19 @@ func NewBVLCOriginalBroadcastNPDU(npdu *NPDU, bvlcPayloadLength uint16) *BVLC {
}
func CastBVLCOriginalBroadcastNPDU(structType interface{}) *BVLCOriginalBroadcastNPDU {
- castFunc := func(typ interface{}) *BVLCOriginalBroadcastNPDU {
- if casted, ok := typ.(BVLCOriginalBroadcastNPDU); ok {
- return &casted
- }
- if casted, ok := typ.(*BVLCOriginalBroadcastNPDU); ok {
- return casted
- }
- if casted, ok := typ.(BVLC); ok {
- return CastBVLCOriginalBroadcastNPDU(casted.Child)
- }
- if casted, ok := typ.(*BVLC); ok {
- return CastBVLCOriginalBroadcastNPDU(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BVLCOriginalBroadcastNPDU); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BVLCOriginalBroadcastNPDU); ok {
+ return casted
+ }
+ if casted, ok := structType.(BVLC); ok {
+ return CastBVLCOriginalBroadcastNPDU(casted.Child)
+ }
+ if casted, ok := structType.(*BVLC); ok {
+ return CastBVLCOriginalBroadcastNPDU(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BVLCOriginalBroadcastNPDU) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BVLCOriginalUnicastNPDU.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BVLCOriginalUnicastNPDU.go
index bf3df72..0976d92 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BVLCOriginalUnicastNPDU.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BVLCOriginalUnicastNPDU.go
@@ -83,22 +83,19 @@ func NewBVLCOriginalUnicastNPDU(npdu *NPDU, bvlcPayloadLength uint16) *BVLC {
}
func CastBVLCOriginalUnicastNPDU(structType interface{}) *BVLCOriginalUnicastNPDU {
- castFunc := func(typ interface{}) *BVLCOriginalUnicastNPDU {
- if casted, ok := typ.(BVLCOriginalUnicastNPDU); ok {
- return &casted
- }
- if casted, ok := typ.(*BVLCOriginalUnicastNPDU); ok {
- return casted
- }
- if casted, ok := typ.(BVLC); ok {
- return CastBVLCOriginalUnicastNPDU(casted.Child)
- }
- if casted, ok := typ.(*BVLC); ok {
- return CastBVLCOriginalUnicastNPDU(casted.Child)
- }
- return nil
+ if casted, ok := structType.(BVLCOriginalUnicastNPDU); ok {
+ return &casted
+ }
+ if casted, ok := structType.(*BVLCOriginalUnicastNPDU); ok {
+ return casted
+ }
+ if casted, ok := structType.(BVLC); ok {
+ return CastBVLCOriginalUnicastNPDU(casted.Child)
+ }
+ if casted, ok := structType.(*BVLC); ok {
+ return CastBVLCOriginalUnicastNPDU(casted.Child)
}
- return castFunc(structType)
+ return nil
}
func (m *BVLCOriginalUnicastNPDU) GetTypeName() string {
diff --git a/plc4go/internal/plc4go/bacnetip/readwrite/model/BVLCReadBroadcastDistributionTable.go b/plc4go/internal/plc4go/bacnetip/readwrite/model/BVLCReadBroadcastDistributionTable.go
index 1cb2261..b64e304 100644
--- a/plc4go/internal/plc4go/bacnetip/readwrite/model/BVLCReadBroadcastDistributionTable.go
+++ b/plc4go/internal/plc4go/bacnetip/readwrite/model/BVLCReadBroadcastDistributionTable.go
... 15947 lines suppressed ...